Arquitetura de custo

1) Princípios e papéis

Cost as a Feature. O preço é parte de UX/produto e soluções arquitetônicas.
Responsabilidade conjunta. Engenheiros, plataforma/DevEx, finanças, produto - um único laço de feedback.
Uma única fonte de verdade. Catálogo de marcas/marcas, dicionário de custo e fontes de dados.
O laço «Observa Otimiza». Dashboards embutidos, gates automáticos e políticas.

Papéis: Arquiteto de valor, analista, dono do produto, equipe de plataforma.

2) Modelo de valor de dados

• Por API: '$/1000 consultas', '$/milissegundo CPU', '$/GB egress'.
• Por «$/GB-mês de armazenamento», «$/consulta à base de dados», «$/milhões de mensagens».
• Por «CAC», «ARPU/ARPU», «Gross Margin», «LTV: CAC».
• Para «$/transação», «$/deplay», «$/teste».

cost_record {
ts, provider, account, region, service, usage_qty, usage_unit,
list_price, net_price, discounts,
tags: { env, team, product, feature, tenant, cost_center, pii, tier },
resource_id, allocation_keys: {req_id?, tenant_id?, dataset?}
}

Tags douradas (obrigatórias): "env", "team", "product'," fonte "," owner "," pii "," tier (hot/warm/cold) "," region ".

3) Atribuição: showback/chargeback

Showback: relatórios transparentes por comandos/fichas sem tarifação de transferências internas.
Chargeback: distribuição de acordo com as regras: custos diretos → proprietário; recursos shared - RPS, segundo CPU, relógio GB, volume de eventos.

cluster_cost = sum(provider_cost where resource in "k8s-node:")
weights = { service: cpu_seconds(service)/total_cpu_seconds }
for service in services:
charge[service] = direct_cost(service) + cluster_cost weights[service]

4) Políticas e gates de custo (Policy as Código)

Regras de orçamento: limites de 'eng/team/função'; auto-alert/unidade de deploy quando o excesso previsto.
Requisitos de rótulos: recursos sem marcas de formatação - deny no controlador de adesão.
Limites de perfil: proibição de máquinas grandes em 'dave', TTL em recursos ephemeral, reservas mínimas.

yaml policy: require-tags-and-limits deny_if_missing_tags: [team, product, env, cost_center, owner]
constraints:
env==dev:
max_instance_type: "c6i. large"
ttl_hours: 72

5) Cálculos: pattern de redução de custo

Tamanho certo (rightsizing): seleção automática vCPU/RAM baseada em p95/p99, sazonalidade e headroom.
Escala automática: target-based (CPU/RPS/lag), funções step; proteção contra thrash através da histerese.
Selecione um modelo de price: on-demand vs spot/preemptil, Reserved Instances/Savings Plans; uma mistura para críticos e fundos.
Linhas de montagem Batch - janelas de carga «barata», compressão batch, filas prioritárias.
Keshash e coligação de consultas: redução da leitura de fontes caras.
Edge/otimização da rede HTTP/2/3, keep-alive, compressão, CDN.

if rps > target1. 2 for 3m: replicas += ceil(rps/target); cool_down 5m if rps < target0. 6 for 10m: replicas = max(min_replicas, replicas-1)

6) Armazenamento e dados: quente/quente/frio

Tiring: dados quentes (acesso instantâneo), quentes (consultas raras), frios/arquivos.
Formatos: Colinvertebrados (Parquet/ORC) para analistas, compressão e particionamento por data/chave.
TTL/ILM: Política de vida do conjunto: 'hot 7d → warm 90d → cold 365d → delete'.
Camada de dinheiro Redis/Memcached com request coalescing, proteção contra tempestades miss.
Cotas e orçamentos de solicitação: limites previsíveis para joões/scans caros.

yaml dataset: events_main lifecycle:
- phase: hot; duration: 7d; storage: nvme
- phase: warm; duration: 90d; storage: ssd; compress: zstd
- phase: cold; duration: 365d; storage: object; glacier: true
- phase: purge; duration: 0d

7) Rede e egress

Minimize o tráfego interregional: cópias locais e agregação na borda.
CDN e keshi: origin-shield, TTL razoável, validação/deficiência.
Protocolos: binários (gRPC) para chatadas, compressão apenas onde for benéfico.
«Não levamos lixo».

8) Bilheteria e custo de SRE

Cartões de custo de telemetria: '$/logg-GB', '$/metrica-série', '$/pista'.
Semente e agregação: tail-based sampling, downsampling métricas, retensas de importância (métricas SLO - prioridade superior).
Deadup de logs e «logo-sanitário»: proibição de PD, redução de campos fantasmas, limites para o tamanho do evento.

9) CI/CD e ambientes de teste

Estandes Ephemeral com auto-TTL, ambiente «por PR».
Perf-smoke em PR: testes curtos para estimativa precoce do «valor da consulta».
Cash/artefactos: reutilização de contêineres, compilações.
Gates: bild/deplay é rejeitado se o «preço da latência »/RPS piorar em relação ao basline> X%.

10) Previsões, orçamentos e anomalias

Forecasts: sazonalidade/tendência, eventos (campanhas, lançamentos), correlação fici → custo.
Orçamentos de nível: team/product/função/tenant; Escalar a 80/90/100%.
Anomalias: picos repentinos por serviço/região/conta; «bisect» automático e reversão da bandeira.

if forecast(month_end_cost) > budget0. 9 and variance ↑:
alert(team_owner)
suggest: rightsizing + RI/SP coverage + ILM tighten

11) Compras e comércio

RI/Savings Plans/Committed Use: cobre uma base estável; monitora a cobertura e «unutilized» os juros.
Spot/Preemptible: tarefas de fundo e tolerant-workflow; checkpointing e reinício rápido.
Licenças e SaaS: matriz ROY, alternativas benchmarking, «vendor fitness review».

12) Multiplicidade e billing

Partitioning by tenant: divisão lógica/física, limites e quotas.
Tenant-aware limitadores/classificações: impede o «vizinho barulhento».
Modelos Usage: billing por evento, RPS, volume de dados; métricas transparentes para os clientes.

13) Segurança e complacência como fator de custo

Cripto e armazenamento: FPE/chaves - gastos com KMS/HSM; otimize a frequência das operações.
Cópias regulatórias: separe os retensivos «legais» das operações; arquivo é mais barato que armazenamento «sempre quente».
Data minimization: menos dados - menos contas e riscos.

14) Engenharia anti-pattern (caro!)

API de bate-papo sem batota ou cachê-lo.
Filas ilimitadas e paralelismo ilimitado - aumento da latidão e da conta.
TTL zero e chaves quentes sem coligação.
Dashboards com milhões de métricas da série.
Recursos sem marcas de formatação → gastos «cinzentos» sem dono.
A ausência de ILM/TTL → o crescimento eterno do armazenamento.

15) Ferramentas e artefatos (vendor-neutral)

Catálogo de marcas de formatação (schema + linter em CI).
Extrator de custo (agregação usage/billing, normalização em um único formato).
Dashboards unit economics (valor API, valor datpra, valor tenant).
Edição automática (rightsizer, recomendador RI/SP, enforcador ILM).
Políticas de custo (admissão/OPA/Kyverno) e «linhas vermelhas» do orçamento.

16) Mini-receitas

Fórmula de preço de consulta (HTTP)

request_cost = (cpu_ms $/cpu_ms) +
(mem_mb_s $/mb_s) +
(egress_mb $/mb) +
(db_calls $/call) +
(cache_ops $/op miss_penalty)

Auditoria rápida do serviço

Top 3 endpoint custoso a $/1000 req.
Hit/miss cachê e chaves de tempestade.
Listas de recursos sem marcas de formatação.
O ILM e a retenha de datasets.
Cobertura RI/SP (%).

Retry-polisy econômico

retry = min(3, floor(budget_ms / (base_timeout_ms 1. 5^attempt)))
jitter = uniform(0. 5..1. 5)

17) Folha de cheque do arquiteto valor

1. Definidas as métricas unit ('$/req', '$/GB-month', '$/txn') e os proprietários?
2. A Tag-Política Enforcada? Os recursos sem marcas de formatação são bloqueados?
3. Showback/chargeback e relatórios de produtos/fichas foram incorporados?
4. Scale automático e rightsizing configurados, headroom definido?
5. São aplicados os dados (hot/warm/cold), ILM/TTL?
6. Egress e fluxos interregionais minimizados? CDN/cachês incluídos?
7. Mobilidade otimizada (sampling, retenção, downsampling)?
8. A CI/CD gate para regredir o custo e policy-checks estão ativos?
9. Projeções/orçamentos/análises de anomalias automatizadas?
10. RI/SP/Mix Spot cobre cargas básicas?
11. Há quotas, limitadores e métricas transparentes para multi-tenant?
12. Documentado com o runbook e o plano de vale-review mensal?

Conclusão

A arquitetura de custo não é «economizar a qualquer custo», mas sim gerenciar o valor: quanto custa cada milissegundo e o rendimento que gera. Ao incorporar valor à arquitetura, processos e ferramentas (tags, políticas, gates, dashboards, ILM, auto scail), você recebe uma plataforma onde as decisões são tomadas com base em métricas e economia, em vez de intuição. Isso acelera o produto, reduz os riscos e torna o negócio previsivelmente rentável.