Teste de sustentabilidade

1) Conceitos básicos e objetivos

Confiabilidade (reliability) - probabilidade de funcionamento; resistência (resilience) - comportamento em decorrência e após falha.
SLO/orçamento errado: critérios de «aceitabilidade» da degradação.
Steady-state hypothesis: espera formal de métricas estáveis (por exemplo, p95 <200 ms, errador rate <0. 5%). A experiência é considerada um sucesso se a hipótese for suportada.
Tipos de falhas de rede (latência, perdas/duplas, quebras), computação (CPU, memória), estorco (I/O, esgotamento de disco), dependências (5x, timeouts, rate-limit), lógico (incidentes parciais, «degradação lenta»), operacional (lançamento, config), escuro (split-brain, turnos de hora).

2) Pirâmide de sustentabilidade

1. Testes unit de falhas de lógica (retraí, idempotidade, temporizações).
2. Componentes com adaptadores fault-inject (Testcontainers/tc-netem).
3. Integração/sistema com rede/BD/Cães e perfis real-world.
4. Experimentos de caos em pré-prod (e depois restrito à venda) por runbook's.
5. Game Day - ensinamentos de palco da equipe (pessoas + ferramentas).

3) Observabilidade como base

SLI: latência p50/p95/p99, erro rate, saturação (CPU/heap/FD/IOPS), drop/timeout, queue depth.
Traçados para encontrar «estreitos» sob rejeição.
Métricas semânticas de estabilidade: proporção de graceful-degrade bem-sucedida, proporção de consultas shed, taxa de auto-definição (MTTR).
Marcação de experiências: 'chaos. experiment _ id ',' phase = inject/recover 'em eventos/logs.

4) Catálogo de injeções de falhas (faults)

Rede: atraso/jitter, perda/duplicação/reorderamento, limitação de largura de banda, «tempestades» de pacote, aberturas TLS.
Hospedeiro: limitação de CPU, vazamento/limite de memória, pausas GC, esgotamento de descriptor, «clock skew».
Armazenamento: aumento da latência, EROFS, ENOSPC, degradação da réplica, perda do líder.
Dependências: 5xx/429, desaceleração, flapping DNS, certificados obsoletos, rate-limit, «respostas parciais».
Dados: danos na gravação, «buracos» nos fluxos, duplicações de eventos, conflitos de versões.
Operações: lançamento falhado, bandeira de fich, deriva config, erro manual (dentro da simulação).

5) Pattern de estabilidade (o que verificar)

Retraias com jitter e temporizações em cada RPC.
Circuito Breaker (abertura/semiaberto, recuperação exponencial).
Bolkheads (isolar pool/fila para domínios críticos).
Load Shedding (redefinindo solicitações de baixa prioridade na saturação).
Backpressure (sinais para cima da cadeia, limites de paralelismo).
Idempotency (chaves de idempotação em «efeitos colaterais»).
Cajueiros e manadas em caso de degradação da origem.
Graceful Descradation (respostas facilitadas, dados stale, desativação do fic).
Timeout-budget (orçamento total de tempo por cadeia de chamadas).
Atômico/compensação (Saga/Outbox/Transactional Inbox).
Quórum e replicação (R/W quórum, degradação da consistência para a disponibilidade).
Anti-entropy/replay (recuperação em «buracos» de eventos).

6) Receitas de injecções e expectativas (pseudocode)

Retrai com jitter e breaker

for attempt in 1..N:
if breaker. open(): return fallback()
res = call(dep, timeout = base 0. 8)
if res. ok: return res sleep(exp_backoff(attempt) jitter(0. 5..1. 5))
if attempt == N: breaker. trip()
return fallback()

Shading e backpreser

if queue. depth() > HIGH          cpu. load() > 0. 85:
if request. priority < HIGH: return 503_SHED limiter. acquire () # constrain concurrency

Idempotidade

key = hash("payout:"+external_id)
if store. exists(key): return store. get(key)
result = do_side_effect()
store. put(key, result, ttl=30d)
return result

7) Experiências: cenários e hipóteses

7. 1 «Dependência lenta»

Injeção: + 400 ms p95 para API externa.
Espera: aumento dos temporizadores de ≤ X%, abertura do breaker, respostas fallback, conservação do serviço p99 <SLA, falta de cascata em retais.

7. 2 «Perda parcial de dinheiro»

Injeção: 50% de nódulos Redis/Kesh Shard falha.
Espera: Miss ampliada, mas sem avalanche de origem (request coalescing/TTL imutável), auto-aquecimento e recuperação.

7. 3 «Split-brain em BD»

Injecção: perder o líder, mudar para a réplica.
Espera: deny gravações de curta duração, lendo de quórum, sem perda de dados, Outbox não perde a mensagem.

7. 4 «ENOSPC/disco cheio»

Injeção: disco de 95% a 100%.
Espera: rotações de emergência de logs, falhas não bloqueadoras, registros críticos (WAL), alertas e auto-visualização.

7. 5 «Bursta de tráfego»

Injeção x 3 RPS para endpoint quente 10 min

Espera: shading de baixa prioridade, p95 estáveis nas vias «nucleares», crescimento de filas dentro dos limites, falta de tempestades DLQ.

7. 6 «Clock Skew»

Injecção: deslocamento do tempo do furo para +/- 2 min.
Espera: TTL/assinaturas corretas (leeway), temporizadores monotônicos em retais, tokens validos à deriva permitida.

8) Ambientes e segurança de experiências

Comece com o pré-prod, dados sintéticos o mais próximo possível da venda de configs/topologia.
Na venda, apenas janelas controladas, bandeiras de fich, amplitude passo a passo, reversão automática, botão vermelho.
Guardrails: limites de RPS/erros, guardas SLO, bloqueio de lançamentos durante incidentes críticos.
O runbook é obrigatório: como reverter, quem chamar, onde olhar.

9) Automação e CI/CD

Catálogo de experiências como código (YAML/DSL): alvos, injeções, métricas, liminares, botões de reversão.
Smoke-chaos em cada lançamento: injeções curtas (por exemplo, 2 min + 200 ms para dependência) em um stage.
Testes noturnos da matriz, serviços x tipos de falhas.
Gate de lançamento: impede o deploy se a resistência estiver abaixo do limite (por exemplo, 'fallback coverage <95%' sob 'dependência lenta').

10) Dados e consistência

Verifique as compensações (Saga): As operações em parte devem ser concluídas.
Teste repetições/duplicações de eventos, remessa out-of-order, «buracos» e réplicas.
Confira os invariantes de domínio após a falha: o saldo não é negativo, as transações não ficam presas e os limites não estão comprometidos.

11) Anti-pattern

Testar apenas happy-path e carga sem falhas.
Retraias sem jitter → tempestade degradada.
A falta de um orçamento de tempo global → os temporais em cascata.
Um único pool para todas as tarefas → sem isolamento (bulkheads).
Filas «infinitas» → aumento da latência/EOM.
Telemetria zero de experiências → práticas de caos «cegas».
Caos na venda sem retrocesso/limite/proprietário responsável.

12) Folha de cheque do arquiteto

1. Hipótese steady-state definida e SLO?
2. Todos os RPC têm temporizadores, retais com jitter, breakers?
3. Implementado bulkheads, limitadores, backpressure, load-shedding?
4. O cash é resistente, coalescing, protecção contra tempestades em dinheiro, aquecimento?
5. Outbox/Saga para efeitos colaterais, chaves idumpotentes?
6. Quórum/replicação/feelover testados?
7. Há um catálogo de experiências, caos nightly e gates em CI/CD?
8. As métricas/traçados marcam experiências, há dashboards?
9. Runbook e o botão vermelho estão prontos. A responsabilidade foi atribuída?
10. Jogos regulares com o Dave/SRE/Apoio?

13) Ferramentas e exemplos de cenário (sketches YAML)

Rede (tc/netem)

yaml experiment: add-latency target: svc:payments inject:
netem:
delay_ms: 300 jitter_ms: 50 loss: 2%
duration: 10m guardrails:
error_rate: "< 1%"
p95_latency: "< 400ms"

CPU/Heap

yaml inject:
cpu_burn: { cores: 2, duration: 5m }
heap_fill: { mb: 512 }

Dependência

yaml inject:
dependency:
name: currency-api mode: slow p95_add_ms: 500 fallback_expectation: "serve stale rates ≤ 15m old"

Conclusão

Testar a sustentabilidade não é um truque de caos, mas uma disciplina que torna o sistema previsível sob falhas. Hipóteses claras, telemetria, catálogo de experiências controladas e pattern incorporados à arquitetura (temporizadores, breakers, isolamento, idempotação) transformam potenciais incidentes em cenários controlados. A equipe ganha confiança nos lançamentos e os usuários têm um serviço estável, mesmo em condições de falha.