Arquitetura de Sistemas · Insper

Hands-on 9 — Resiliência e Caos

Um provedor de pagamento lento não pode derrubar o checkout

A história até aqui

capítulo 9 · lab 8dashboards, traces, um alerta de burn rate: acionou ~440 s depois que o db parou
→
capítulo 10 · lab 9timeout, retry, breaker, bulkhead, game day
→
depois · lab 10o Kubernetes cura e escala

10:02: o provedor de pagamento responde em 4 s em vez de 200 ms. O dashboard do lab 8 mostra, o alerta dispara — e o checkout morre mesmo assim. Ver a falha basta para sobreviver a ela?

  • Neste lab, o Toxiproxy soma 3 s a cada chamada ao payment.

Nada está fora do ar. Tudo está quebrado.

10:00, venda relâmpago. O provedor de pagamento responde em 3 s em vez de 300 ms. Em um minuto o order para de responder qualquer coisa — até o GET /orders/{id}. Por quê?

  • 20 pagamentos/s × 3 s = 60 threads só esperando o payment.
  • O order tem 50 → toda requisição vai para a fila: uma falha em cascata.
  • Lei de Little: concorrência = taxa × tempo retido.

O ambiente do lab

k6pay 20/s + browse 20/s
→
order50 threads · Resilience4j
:18085 →
toxiproxyproxy payment
→
payment8085 · idempotente
:18095 →
toxiproxyproxy psp
→
pspWireMock
  • payment: adaptador para o provedor de serviços de pagamento (PSP, payment service provider), POST /payments idempotente pela Idempotency-Key.
  • toxiproxy (API na 8474): proxies do Transmission Control Protocol (TCP, protocolo de controle de transmissão) — latência, resets, quedas, dois lugares para quebrar.
  • Novo endpoint: POST /orders/{id}/pay → CONFIRMED + OrderConfirmed no outbox.

Toxics

Toxic Simula
latency (+ jitter) dependência lenta
timeout (0) buraco negro
reset_peer conexão resetada
bandwidth cano estreito
proxy enabled: false dependência fora do ar
curl -X POST localhost:8474/proxies/payment/toxics \
  -d '{"name":"slow","type":"latency","attributes":{"latency":3000}}'

toxicity 0–1: a probabilidade por conexão. POST /reset é o botão de abortar.

1 · Timeout

factory.setConnectTimeout(Duration.ofMillis(500));
factory.setReadTimeout(Duration.ofSeconds(1)); // 0 = forever (the default!)
  • Uma thread fica presa no máximo 1 s: 20/s × 1 s = 20 threads → o pool sobrevive.
  • Falha lenta → falha rápida; falhas rápidas não se propagam em cascata.

Os orçamentos encolhem a cada salto: borda 10 s > gateway 5 s > order→payment 1 s × tentativas.

2 · Retry, backoff, jitter

max-attempts: ${PAYMENT_RETRY_ATTEMPTS:3}
wait-duration: 200ms
enable-exponential-backoff: true      # 200 ms, 400 ms
enable-randomized-wait: true
randomized-wait-factor: 0.5           # ± 50% jitter
retry-exceptions: [ResourceAccessException, HttpServerErrorException, RestClientException]
ignore-exceptions: [HttpClientErrorException, CallNotPermittedException, BulkheadFullException]
  • Por tentativa p = 0,3 → três tentativas falham com p³ = 2,7%. Medido: 0,5% → 0,1% — o toxic só atinge conexões novas.
  • Custos: até 3× a carga, mais latência. Só em chamadas idempotentes.

Idempotência de ponta a ponta

orderIdempotency-Key: order-<id>, a mesma em toda tentativa
→
paymentchave UNIQUE · chave conhecida = primeiro resultado (200)
→
provedorrecebe a mesma chave

Um timeout não significa que a chamada falhou — a resposta pode ter se perdido. A chave torna o retry inofensivo.

3 · Circuit breaker

CLOSEDjanela de 20, mín. 10
proxy desativado · 10 chamadas falham →
OPENCallNotPermitted · 503 em µs
10 s →
HALF_OPEN3 sondas
proxy volta →
CLOSED
  • Abre com ≥ 50% de falhas ou ≥ 50% acima de 800 ms — sem rede, sem retry, sem espera.
  • Protege as threads de quem chama e dá espaço para a dependência se recuperar.
  • Tempo da reativação até CLOSED: até 10 s mais as sondas — depende de onde estava a espera.

Acompanhe: /actuator/circuitbreakers, /actuator/circuitbreakerevents.

4 · Bulkhead

As chamadas dão certo em 700 ms — abaixo do timeout e do limite de chamada lenta. A 70/s, o GET /orders/{id} fica lento mesmo assim. Por quê e o que resolve?

  • 70/s × 0,7 s ≈ 49 de 50 threads esperam o payment.
  • Bulkhead max-concurrent-calls: 10, max-wait-duration: 0 → a 11ª chamada recebe 503 na hora.
order50 threads
→
bulkhead: 10esperam 700 ms o payment
+
as outras 40GET /orders/{id} em ms
+
o resto503 na hora (~85%)

Como as anotações se empilham

@Retry(name = "payment", fallbackMethod = "unavailable")
@CircuitBreaker(name = "payment")
@Bulkhead(name = "payment")
public PaymentResponse charge(UUID orderId, BigDecimal amount) { ... }
Retry3 tentativas
→
CircuitBreakeraberto: falha rápido
→
Bulkheadcheio: falha rápido
→
chamada
qualquer recusa →
fallback: 503
  • O retry ignora CallNotPermittedException e BulkheadFullException; o breaker ignora BulkheadFullException.

Nunca espere dentro de uma transação

  • O pay() chama o payment sem transação aberta.
  • Depois, uma transação curta: UPDATE … WHERE status = 'PENDING_PAYMENT' + evento no outbox.
  • Esperar 3 s dentro de uma transação leva o esgotamento para o pool de conexões (≈ 10).

Simulador: as cinco execuções, sem a stack

timeout, antesmediana do browse 4,75 s · 65 iterações descartadas
→
depois (1 s)o pay falha em 1,01 s · p95 do browse 8 ms
retry0,3% → 0,0% falharam
breakerabre em 0,3 s · fecha em 61,1 s
bulkhead58% falham rápido, p95 do browse 759 ms → 81% rejeitados, 8 ms
  • O simulador pay-under-chaos da página de padrões: escolha um passo, antes ou depois do seu padrão, e leia o resumo do k6.
  • Os números do modelo não são os seus — compare a forma com as suas execuções.

Meça

Experimento Toxic Antes → depois
Timeout latência 3 s p95 do pay, p95 do browse
Retry reset_peer 30% % confirmados
Circuit breaker proxy desativado p95 do pay, pay_fast_fail
Bulkhead latência 700 ms, 70 pay/s p95 do browse, % rejeitados

Uma execução de teste (45 s, payment + 3 s): p50 do browse de 9,04 s sem proteção e 6,5 ms com todos os padrões — reproduza o contraste, não os números.

k6 load/pay-under-chaos.js: pay (usa o payment) e browse (não usa) ao mesmo tempo — o segundo revela a cascata.

5 · Game day

mestre do jogoinjeta, escondido
→
alerta dispara
→
operadoresdashboard → trace → logs
→
mitigar primeiro
→
escribatempos de detectar e mitigar
  • Antes: estado estável, hipóteses, raio de impacto, abortar = POST /reset; as regras de burn rate para o order.
  • Depois: revisão sem culpados — tempo para detectar, tempo para mitigar, itens de ação. Rodízio de papéis.

Sem hipótese, não há experimento. Uma hipótese refutada é o resultado valioso.

Experimente no playground

  • boxoffice-payment: este lab — em t = 60 s o payment ganha +3 s; adicione timeout, retries, breaker e um bulkhead de 0,2.
  • cascading-failure: aumente a latência do terceiro, veja a utilização chegar a 100%; adicione timeout + breaker.
  • retry-storm: retries sem backoff amplificam uma queda; adicione exp+jitter.

O simulador mostra a forma; k6 + Toxiproxy dão os seus próprios números.

O que quebra em seguida

lab 9 · contidoGET /orders/{id}: 9 s na mediana sem proteção, milissegundos com os padrões
→
o limitetoda mitigação do game day foi uma pessoa num terminal
→
lab 10 · Kubernetesreiniciar, escalar antes das 10:00, liberar: laços de controle
  • Às 10:00, ninguém deveria estar reiniciando contêineres à mão.

Pontos-chave

  1. Uma dependência lenta é pior que uma morta: ela esgota as threads (Lei de Little).
  2. Timeouts em todo lugar, menores a cada salto mais interno.
  3. Retries com backoff + jitter, só em erros transitórios, só com chaves de idempotência.
  4. Circuit breakers falham rápido e deixam as dependências se recuperarem; bulkheads limitam a concorrência por dependência.
  5. Nunca segure uma transação de banco durante uma chamada remota.
  6. Pratique a falha: game days com hipóteses e revisões sem culpados.

Capítulo 10 da história da disciplina. Roteiro: (1) a cascata; (2) payment, psp, Toxiproxy; (3) timeout; (4) retry + idempotência; (5) circuit breaker; (6) bulkhead; (7) as cinco execuções no simulador; (8) game day; (9) medir.

A história da disciplina (visão geral de 2027.1, "A história da disciplina"): o capítulo 10 abre com o provedor lento que o dashboard do lab 8 enxerga, mas não segura.