Pular para conteúdo

Padrões de Resiliência

Quando uma dependência degrada, o comportamento ingênuo — continuar enviando requisições e esperar a resposta — produz com certeza a cascata da visão geral: as threads de quem chama bloqueiam, sua fila enche e a falha sobe até usuários que não tinham nada a ver com a dependência quebrada. Padrões de resiliência são decisões de projeto que interrompem essa propagação. Eles não evitam falhas; eles limitam até onde uma falha vai1.

Ao longo desta página seguimos uma chamada do BoxOffice: o order chama o payment, o adaptador na frente do provedor externo de pagamento, para cobrar o cartão de um fã durante a saga de compra (veja Mensageria — padrões). É a chamada mais perigosa do sistema: está no caminho da receita, atravessa a internet até um terceiro e o dia ruim do terceiro vira o nosso.

Padrão Pergunta que responde Protege contra
Timeout Quanto tempo estou disposto a esperar? Chamadas penduradas segurando recursos
Retry com backoff e jitter Vale tentar de novo — quando? Falhas transitórias
Circuit breaker Devo sequer tentar? Martelar uma dependência sabidamente fora do ar
Fallback O que respondo no lugar? Perder uma página inteira por causa de uma funcionalidade
Bulkhead Quanto da minha capacidade uma dependência pode tomar? Esgotamento se espalhando entre funcionalidades
Load shedding Que trabalho recuso quando estou sobrecarregado? Colapso sob sobrecarga
Rate limiting Quanto cada cliente recebe? Clientes abusivos, bots, picos
Health checks O tráfego deve chegar a esta instância? Rotear para instâncias quebradas

Timeout

Um timeout é um prazo em uma chamada de saída: se a resposta não chegou a tempo, quem chama a abandona e trata o erro. Sem timeout, uma dependência pendurada segura uma thread (e uma conexão e memória) indefinidamente; com ele, o estrago que uma chamada lenta pode fazer é limitado.

sequenceDiagram
    participant O as order
    participant P as adaptador payment
    participant X as provedor de pagamento
    O->>+P: POST /charges (prazo de 2 s)
    P->>+X: cobra o cartão
    Note over X: o provedor está lento hoje
    Note over O: 2 s se passaram: desiste, libera a thread
    O-->>O: trata o erro (retry? fallback?)
    X-->>-P: (a resposta chega em 4 s)
    P-->>-O: (tarde demais: descartada)

Como escolher o valor:

  • A partir da distribuição de latência da dependência. Coloque um pouco acima do p99,9 da operação normal: qualquer coisa mais lenta já é anormal. Para o payment, que normalmente responde em cerca de 200 ms com um p99,9 bem abaixo de um segundo, o lab 9 lê com timeout de 1 s.
  • Dois timeouts por chamada HTTP: o timeout de conexão (abrir a conexão TCP/TLS — curto, algumas centenas de milissegundos) e o timeout de leitura (esperar a resposta).
  • Por dependência. Uma consulta ao cache, uma query no banco e uma API de terceiros têm latências que diferem em ordens de grandeza. Um timeout global está sempre errado para a maioria delas.
  • Dentro do orçamento de quem chama. Se a requisição do fã tem 5 s no gateway, tudo abaixo precisa caber nisso, inclusive os retries.

Propagação de prazo

Os timeouts precisam encolher à medida que a requisição desce. Um prazo definido na borda e propagado com a requisição (o gRPC faz isso nativamente com deadlines; em HTTP, um cabeçalho com o orçamento restante) permite que cada serviço saiba quanto tempo resta e pare de trabalhar numa requisição cujo chamador já desistiu.

Camada Orçamento Gasto em
Borda (Nginx) 10 s tudo abaixo
Gateway 5 s tudo abaixo + o próprio trabalho
order → payment 1 s por tentativa × 3 tentativas + backoff (200 ms, 400 ms ± 50%) ≈ 3,6 s a cobrança
payment → provedor 2 s (PSP_READ_TIMEOUT) a chamada ao provedor
sequenceDiagram
    participant G as gateway (5 s)
    participant O as order
    participant P as adaptador payment
    participant X as provedor
    G->>O: POST /orders/{id}/pay, restam 5 s
    O->>P: cobrança, tentativa 1 (timeout de leitura 1 s)
    P->>X: cobrar o cartão (timeout de leitura 2 s)
    Note over O,P: 1 s sem resposta: o order desiste
    O->>O: backoff de cerca de 200 ms
    O->>P: cobrança, tentativa 2 (mesma Idempotency-Key)
    P->>X: cobrar o cartão
    X-->>P: aprovado depois de 400 ms
    P-->>O: AUTHORIZED
    O-->>G: CONFIRMED depois de cerca de 1,7 s, dentro de 5 s

Cada camada gasta parte do orçamento e passa o resto para baixo: até três tentativas (cerca de 3,6 s) cabem nos 5 s do gateway e uma quarta (cerca de 5,4 s) não caberia. Um valor do lab quebra a regra: o payment espera até 2 s pelo provedor, mais que a tentativa de 1 s do order, então, quando o provedor está lento, o payment continua trabalhando numa cobrança que o order já abandonou — inofensivo só por causa da chave de idempotência. Em produção, dê ao adaptador menos tempo que ao seu chamador.

Timeouts são só o primeiro passo

Um timeout transforma uma espera infinita em um erro rápido. Você ainda precisa decidir o que fazer com o erro: repetir (se for transitório e seguro), parar de chamar por um tempo (circuit breaker) ou responder outra coisa (fallback). E um timeout numa chamada não idempotente deixa um resultado desconhecido — a cobrança pode ter sido feita — e é por isso que as chamadas ao payment levam uma chave de idempotência (veja Integrações).

No código do BoxOffice: os timeouts de order → payment (lab 9)

O Hands-on 9 — Padrões de resiliência dá ao cliente do payment seus dois timeouts: 500 ms para conectar e 1 s para ler (PAYMENT_READ_TIMEOUT; 0 espera para sempre, o experimento "antes"). A chave de idempotência order-<id> é a mesma em toda tentativa e é isso que torna seguro o retry da próxima seção. A aritmética do lab: 20 pagamentos/s contra um provedor 3 s lento seguram 20 × 3 = 60 threads, mais que o pool de 50; com o timeout de 1 s, 20 × 1 = 20.

services/order/src/main/java/boxoffice/order/payment/PaymentClient.java (timeouts and idempotency key)
public PaymentClient(RestClient.Builder builder,
                     @Value("${boxoffice.payment.url}") String url,
                     @Value("${boxoffice.payment.connect-timeout}") Duration connectTimeout,
                     @Value("${boxoffice.payment.read-timeout}") Duration readTimeout) {
    SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
    factory.setConnectTimeout(connectTimeout);
    factory.setReadTimeout(readTimeout); // 0 = wait forever (the "before" experiment)
    this.http = builder.baseUrl(url).requestFactory(factory).build();
}

public PaymentResponse charge(UUID orderId, java.math.BigDecimal amount) {
    return http.post()
            .uri("/payments")
            .header("Idempotency-Key", "order-" + orderId) // same key on every retry
            .body(new PaymentRequest(orderId, amount))
            .retrieve()
            .body(PaymentResponse.class);
}

Retry com backoff e jitter

Um retry repete uma chamada que falhou, apostando que a falha foi transitória: uma conexão derrubada, um pod reiniciando, uma eleição de líder. Retries tornam invisíveis muitas pequenas oscilações. Feitos sem cuidado, são também o jeito mais rápido de transformar um problema pequeno numa indisponibilidade.

O que repetir

Falha Repetir? Por quê
Conexão recusada / resetada, timeout de conexão ✅ Sim Falha transitória típica; a requisição provavelmente nem rodou
Timeout de leitura ⚠️ Só se a operação for idempotente (ou tiver chave de idempotência) A requisição pode ter rodado
503 Service Unavailable, 429 Too Many Requests ✅ Sim, com backoff; respeite o Retry-After O servidor está pedindo para você voltar depois
500 Internal Server Error ⚠️ No máximo uma vez Muitas vezes é um bug que falha de novo
400, 401, 403, 404, 409, 422; "cartão recusado" ❌ Nunca A requisição em si está errada ou a resposta é definitiva

Backoff exponencial e jitter

Repetir imediatamente atinge de novo uma dependência em dificuldade antes que ela tenha qualquer chance de se recuperar. O backoff exponencial espera mais depois de cada falha:

\[ \text{wait}_n = \min\left(\text{base} \cdot 2^{n},\ \text{cap}\right) \]

As esperas se somam: o que importa a quem chama é o tempo desde a primeira falha. Com base de 1 s e teto de 16 s:

Antes do retry Espera Tempo desde a primeira falha
1º (\(n\) = 0) 1 s 1 s
2º (\(n\) = 1) 2 s 3 s
3º (\(n\) = 2) 4 s 7 s
4º (\(n\) = 3) 8 s 15 s
5º em diante 16 s (o teto) +16 s cada

O lab 9 usa base de 200 ms e até 3 tentativas — esperas de 200 ms e depois 400 ms, o último retry 600 ms depois da primeira falha (mais o tempo de cada tentativa). Mas se muitos clientes falharam no mesmo instante (o provedor oscilou para todos), todos repetem nos mesmos instantes também — ondas sincronizadas. O jitter torna as esperas aleatórias; a análise de Marc Brooker na AWS recomenda o full jitter2:

\[ \text{wait}_n = \text{random}\left(0,\ \min\left(\text{base} \cdot 2^{n},\ \text{cap}\right)\right) \]

Retries amplificam a carga

A simulação abaixo tem dois experimentos com números ilustrativos. À esquerda, um tráfego de compras estável (1.000 requisições/s) encontra um provedor de pagamento que degrada por 5 segundos; um servidor sobrecarregado desperdiça parte da capacidade em requisições que vão dar timeout de qualquer jeito. À direita, 1.000 clientes falham no mesmo instante (digamos, um reset de conexão durante um failover) e repetem contra um servidor que aguenta 150 requisições a cada 100 ms.

2026-11-18T00:40:40.997289 image/svg+xml Matplotlib v3.11.2, https://matplotlib.org/ 0 10 20 30 40 50 60 seconds 0 200 400 600 800 1000 1200 Successful requests/s (shaded: provider slow) no retries 3 retries, backoff + jitter same + retry budget (10%) 0 2 4 6 8 10 12 14 16 seconds 0 200 400 600 800 1000 capacity Retries per 100 ms after 1,000 clients fail together backoff + full jitter exponential backoff, no jitter
  • Esquerda — retries podem manter um sistema caído. Sem retries (cinza), os sucessos caem durante a degradação e voltam no instante em que ela termina. Com 3 retries por requisição (vermelho), cada falha vira até 4 chamadas; a carga extra mantém o provedor sobrecarregado depois que o gatilho passou e o sistema se acomoda num estado degradado — uma falha metaestável (veja a visão geral). Backoff e jitter não resolvem isso: eles espalham os retries no tempo, mas não reduzem a quantidade. Um retry budget (azul) — os retries podem acrescentar no máximo 10% ao tráfego normal — limita a amplificação e o sistema se recupera na hora.
  • Direita — jitter evita ondas sincronizadas. Sem jitter (laranja), todos os clientes que falharam juntos repetem juntos: 1.000 chamadas em uma janela de 100 ms, só 150 têm sucesso, as outras 850 repetem juntas de novo… depois de 15 segundos, 250 clientes ainda não conseguiram. Com full jitter (azul), os mesmos retries se espalham abaixo da linha de capacidade e todos conseguem em cerca de 1,5 s.

Daí saem três regras:

  1. Faça retry em uma só camada. Se o gateway, o order e o adaptador payment fazem até 3 tentativas cada, um clique do fã pode virar \(3 \times 3 \times 3 = 27\) chamadas ao provedor. Faça retry perto da dependência que falha e deixe as camadas de cima falharem rápido.
  2. Limite as tentativas e o tempo total: poucas tentativas (1–2 retries), todas dentro do prazo de quem chama.
  3. Use um retry budget (Envoy, retry throttling do gRPC, Finagle): retries só são permitidos enquanto forem uma pequena fração das requisições. Quando a dependência está realmente fora, os retries param sozinhos.

Experimente no playground

O cenário retry-storm tem clientes repetindo chamadas que falharam, sem backoff, contra um serviço que sofre uma indisponibilidade curta. Aperte Run e observe a taxa de requisições ao serviço pular para várias vezes a taxa dos clientes durante a indisponibilidade e o serviço continuar sobrecarregado depois de quando deveria ter se recuperado. Depois troque a política de retry para backoff exponencial com jitter, adicione um retry budget e compare o tempo de recuperação.

Nunca repita uma chamada não idempotente sem chave de idempotência

Repetir POST /charges depois de um timeout de leitura pode cobrar o fã duas vezes: a primeira tentativa pode ter dado certo. O serviço order envia um Idempotency-Key (o id do pedido) em toda cobrança; o adaptador e o provedor devolvem o resultado guardado para uma chave que já viram. Veja Mensageria — semântica de entrega e Integrações.


Circuit breaker

Um circuit breaker observa os resultados das chamadas a uma dependência. Quando a taxa de falhas passa de um limite, ele abre e rejeita as chamadas imediatamente, sem tocar na rede, por um tempo; depois deixa passar algumas chamadas de teste para verificar a recuperação3.

stateDiagram-v2
    state "Fechado" as Closed
    state "Aberto" as Open
    state "Meio-aberto" as HalfOpen
    [*] --> Closed
    Closed --> Open : taxa de falhas ou de chamadas lentas ≥ 50% (últimas 20)
    Open --> HalfOpen : depois de 10 s
    HalfOpen --> Closed : taxas das 3 sondas abaixo dos limites
    HalfOpen --> Open : taxa de falhas ou de lentas das sondas ≥ 50%

Fechado (normal) : As chamadas passam; o breaker registra sucessos, falhas e chamadas lentas numa janela deslizante.

Aberto (falhando rápido) : As chamadas falham na hora (CallNotPermittedException no Resilience4j). As threads de quem chama ficam livres e a dependência ganha espaço para respirar em vez de uma tempestade de retries.

Meio-aberto (testando) : Depois do tempo de espera, algumas chamadas de sonda são permitidas e toda outra chamada continua rejeitada. Quando as sondas terminam, o breaker calcula as taxas de falhas e de chamadas lentas delas: abaixo dos limites, ele fecha; senão, abre para mais uma espera.

Parâmetro (propriedade do Resilience4j) Padrão do Resilience4j Valor do lab 9 para o payment Efeito
Janela deslizante (sliding-window-size) 100 chamadas últimas 20 chamadas (por contagem) Quanto histórico decide
Mínimo de chamadas (minimum-number-of-calls) 100 10 Nenhuma decisão antes desse número — evita abrir com 1 falha em 2
Limite de taxa de falhas (failure-rate-threshold) 50% 50% Abre quando a fração de chamadas com falha é igual ou maior que ele
Chamadas lentas (slow-call-duration-threshold, slow-call-rate-threshold) 60 s, 100% 800 ms, 50% Um provedor lento também abre o breaker — essencial contra gray failures
Espera no estado aberto (wait-duration-in-open-state) 60 s 10 s Tempo que a dependência ganha para se recuperar — e quanto tempo os fãs veem a falha rápida
Chamadas no meio-aberto (permitted-number-of-calls-in-half-open-state) 10 3 Com quanto cuidado a recuperação é testada

Os padrões são conservadores: com uma janela de 100 chamadas, um breaker que vê 1 chamada por segundo precisa de bem mais de um minuto para decidir. Chamadas lentas têm o seu próprio limite de taxa: com o padrão de 100%, elas só abrem o breaker quando toda chamada da janela é lenta e, com a duração padrão de 60 s, uma chamada atrás de um timeout de leitura de 1 s nunca conta como lenta. O lab 9 define o limite de chamada lenta em 800 ms, abaixo do seu timeout de leitura de 1 s: uma chamada mais lenta que o timeout nunca termina — vira falha —, então um limite acima do timeout jamais veria uma chamada lenta e o breaker esperaria os timeouts em vez de reagir primeiro à lentidão.

Importa quais erros contam: um cartão recusado é uma resposta correta de um provedor saudável, não uma falha. Configure-o como ignorado, ou uma onda de cartões recusados num ataque com cartões roubados abriria o breaker para todos os fãs honestos. O lab 9 não tem cartões recusados; o seu retry ignora todo 4xx (HttpClientErrorException), porque a mesma requisição falharia de novo, e o seu breaker ignora a BulkheadFullException, uma recusa nossa que não diz nada sobre o payment.

A espera é um compromisso que dá para calcular. Com 10 s, um provedor que se recupera um segundo depois de o breaker abrir ainda custa aos fãs cerca de 9 s de "pagamento temporariamente indisponível", até as sondas do meio-aberto o verem saudável; um provedor que continua fora mantém o breaker aberto em degraus de 10 s, cada um custando só 3 chamadas de sonda. Uma espera maior protege melhor um provedor em dificuldade e faz mais fãs falharem depois que ele se recupera.


Fallback e degradação graciosa

Falhar rápido é melhor que ficar pendurado, mas um erro ainda é um erro. Um fallback é o que quem chama faz no lugar. O objetivo é a degradação graciosa: perder uma funcionalidade, não a página.

Dependência fora do ar Fallback no BoxOffice
Recomendações ("fãs também compraram") Esconder o widget, ou mostrar uma lista estática de "populares da semana" do cache
Busca Servir os últimos resultados em cache; mostrar "os resultados podem estar alguns minutos desatualizados"
Serviço de renderização do mapa de lugares Mostrar o seletor de melhores lugares disponíveis ("2 lugares, setor B") em vez do mapa interativo
notification Nada a fazer de forma síncrona: o evento já está no Kafka e será entregue depois
payment Nada de sucesso falso. Manter os lugares reservados, dizer ao fã "pagamento temporariamente indisponível — seus lugares estão reservados por 10 minutos, tente de novo" e deixar a saga repetir ou liberar

Um fallback precisa ser seguro e simples

Um fallback que chama outro serviço remoto também pode falhar e precisa da própria proteção. Algumas operações — cobrar um cartão, confirmar um lugar — nunca podem ser fingidas: falhar com clareza é o comportamento gracioso. E teste seus fallbacks; um fallback exercitado pela primeira vez durante uma indisponibilidade costuma falhar.


Bulkhead

Um bulkhead — nome dos compartimentos estanques do casco de um navio — dá a cada dependência o próprio pool limitado de threads, conexões ou chamadas concorrentes, para que uma dependência lenta não consuma a capacidade das outras.

flowchart LR
    req["order: 50 threads do Tomcat"] --> bp["bulkhead do payment<br/>máx. 10 concorrentes, sem fila"]
    req --> rest["as outras 40 threads<br/>POST /orders, GET /orders/{id}"]
    bp --> pay["payment<br/>(lento: 3 s)"]
    bp -.->|"11ª chamada concorrente: 503 na hora"| fb["fallback"]
    rest --> db[("banco de pedidos<br/>(saudável)")]

O dimensionamento vem de novo da Lei de Little. Com os 20 pagamentos/s do lab 9 e 200 ms por cobrança, cerca de 4 chamadas estão em voo. Um bulkhead de 10 deixa espaço para a latência crescer 2,5× (até 0,5 s) antes de as chamadas serem rejeitadas; quando o provedor vai para 3 s, no máximo 10 threads esperam por ele (em vez de 60, mais que o pool) e as outras 40 continuam criando e lendo pedidos. Com max-wait-duration: 0 a 11ª chamada concorrente não entra em fila: ela falha em microssegundos e vai para o fallback.

O custo de um bulkhead é capacidade que não pode ser compartilhada: com o bulkhead do pagamento cheio, um 11º pagamento é recusado na hora mesmo com outras threads ociosas, enquanto um pool compartilhado o teria atendido. Essa recusa é o objetivo — as threads ociosas ficam para as rotas que funcionam.

O Resilience4j oferece um bulkhead de semáforo (limita chamadas concorrentes nas threads de quem chama; barato, o padrão) e um bulkhead de pool de threads (executa as chamadas num pool dedicado). A ideia é geral: pools de conexão separados por carga de trabalho num banco, consumer groups separados no Kafka, deployments separados para tráfego crítico e não crítico, filas separadas para confirmações e e-mails de marketing.


Load shedding

Quando a demanda passa da capacidade, algumas requisições vão falhar. O load shedding (descarte de carga) decide quais e as faz falhar cedo e barato, para que o resto tenha sucesso. Sem ele, o servidor aceita tudo, toda requisição fica lenta, a maioria dá timeout depois de consumir recursos e o goodput (trabalho útil) desaba — todos falham4.

  • Descarte na porta. Rejeite com 503 + Retry-After antes de fazer qualquer trabalho: uma rejeição custa microssegundos, uma requisição que dá timeout custa o processamento inteiro.
  • Descarte por prioridade. Durante a abertura do estádio, o BoxOffice classifica o tráfego: compras e reservas são críticas; navegação no catálogo é importante; recomendações, autocomplete e "eventos relacionados" são descartáveis. Sob sobrecarga, os descartáveis saem primeiro.
  • Descarte trabalho velho. Uma requisição que já esperou mais que o prazo de quem chamou é inútil; tire-a da fila em vez de processá-la (filas limitadas com prazos, último a chegar, primeiro a sair (LIFO, last in, first out) sob sobrecarga).
  • Adapte o limite. Em vez de um limite fixo de concorrência, limitadores adaptativos (inspirados no controle de congestionamento do TCP, por exemplo a biblioteca concurrency-limits da Netflix) reduzem o número de requisições concorrentes quando a latência sobe e o aumentam quando a latência está saudável.

BoxOffice: a sala de espera é load shedding

A sala de espera da flash sale é load shedding feito com gentileza: em vez de rejeitar fãs, ela os admite na taxa que o sistema consegue atender e informa aos outros a sua posição. Atrás dela, o gateway ainda descarta as rotas descartáveis quando a latência do order sobe, como segunda linha de defesa.


Rate limiting

O rate limiting limita quantas requisições um cliente (um IP, um usuário, uma chave de API, um parceiro) pode enviar numa janela de tempo. O load shedding protege o servidor da sobrecarga total; o rate limiting o protege de clientes individuais — bots atualizando o mapa de lugares centenas de vezes por segundo, a integração bugada de um parceiro, um scraper.

O algoritmo comum é o token bucket: os tokens se recarregam numa taxa constante (o limite sustentado), o tamanho do balde permite rajadas curtas e cada requisição consome um token; balde vazio significa 429 Too Many Requests. Limites por usuário ou chave de API ficam no API gateway, apoiados num armazenamento compartilhado como o Redis, onde a identidade autenticada é conhecida. Os algoritmos (token bucket, leaky bucket, janela deslizante) e sua implementação estão em Borda — API gateway; o cenário rate-limiter do playground mostra um gateway protegendo um backend.


Health checks

Health checks permitem que orquestradores e load balancers parem de enviar tráfego para instâncias quebradas — failover automático na menor escala.

Liveness : O processo está vivo e não travado? Se falha, o Kubernetes reinicia o container.

Readiness : Esta instância pode atender tráfego agora? Se falha, a instância é removida do load balancer sem ser reiniciada (aquecendo, sobrecarregada, perdeu a conexão com o próprio banco).

Startup : A aplicação terminou de iniciar? Liveness e readiness só são verificados depois que ele passa, então uma JVM que demora para subir não é morta durante o boot.

O Spring Boot Actuator serve as probes em /actuator/health/liveness e /actuator/health/readiness. No Spring Boot 4 (a versão dos labs) esses grupos de probes vêm ligados por padrão, em qualquer ambiente; do Spring Boot 2.3 ao 3.x eram automáticos só no Kubernetes e em outros lugares — no Docker Compose, por exemplo — pediam management.endpoint.health.probes.enabled=true (o lab 9 ainda o define, o que não faz mal). Por padrão eles refletem só o estado da própria aplicação: uma dependência só aparece no readiness se você a adicionar.

stateDiagram-v2
    [*] --> Iniciando
    Iniciando --> Pronto : startup passa, depois readiness passa
    Iniciando --> Reiniciado : startup falha 30 vezes (150 s)
    Pronto --> NaoPronto : readiness falha duas vezes
    NaoPronto --> Pronto : readiness volta a passar
    Pronto --> Reiniciado : liveness falha 3 vezes
    NaoPronto --> Reiniciado : liveness falha 3 vezes
    Reiniciado --> Iniciando
    note right of NaoPronto : fora do load balancer, sem reiniciar
# order Deployment, container spec (Spring Boot Actuator endpoints)
startupProbe:
  httpGet: { path: /actuator/health/liveness, port: 8080 }
  periodSeconds: 5
  failureThreshold: 30        # up to 150 s to start
livenessProbe:
  httpGet: { path: /actuator/health/liveness, port: 8080 }
  periodSeconds: 10
  failureThreshold: 3
readinessProbe:
  httpGet: { path: /actuator/health/readiness, port: 8080 }
  periodSeconds: 5
  failureThreshold: 2

Nunca coloque dependências no liveness

Se o liveness do order verifica o provedor de pagamento e o provedor oscila, o Kubernetes reinicia todas as réplicas do order de uma vez — transformando um soluço de um terceiro numa indisponibilidade total do BoxOffice enquanto as JVMs sobem. O liveness responde só "este processo está travado?". Cuidado também com o readiness: se toda réplica depende do mesmo banco, todas ficam não prontas juntas e o serviço some em vez de devolver erros claros.


Juntando tudo

Os padrões trabalham em camadas. Para a chamada order → payment, o BoxOffice usa todos eles, configurados com Resilience4j5 no lab 9. Os números são do tamanho de um laptop — 20 pagamentos/s contra 50 threads do Tomcat — e cada parâmetro lê uma variável de ambiente, então cada experimento desliga um padrão sem rebuild.

No código do BoxOffice: a pilha de proteção no order (lab 9)

O Hands-on 9 — Padrões de resiliência configura cada camada e cada valor tem um motivo:

  • Timeouts: 500 ms para conectar e 1 s para ler (PAYMENT_READ_TIMEOUT; 0 espera para sempre, o experimento "antes") — cerca de cinco vezes os 200 ms normais do provedor.
  • Retry: 3 tentativas (1 chamada + 2 retries), 200 ms e depois 400 ms de backoff, cada um ± 50% (jitter), só em erros de E/S, 5xx e conexões resetadas; um 4xx é definitivo e um breaker aberto (CallNotPermittedException) ou um bulkhead cheio (BulkheadFullException) falha rápido em vez de ser repetido.
  • Circuit breaker: por contagem sobre as últimas 20 chamadas (no mínimo 10), abre quando 50% falharam ou levaram mais de 800 ms — um provedor lento também o dispara —, fica aberto 10 s e depois deixa 3 sondas decidirem; ele ignora a BulkheadFullException.
  • Bulkhead: 10 chamadas concorrentes das 50 threads, max-wait-duration: 0 — cheio significa 503 na hora.

O PaymentGateway empilha as anotações na ordem padrão do Resilience4j — Retry ( CircuitBreaker ( Bulkhead ( call ) ) ) — com o fallback na camada externa. O fallback responde 503 e o pedido fica PENDING_PAYMENT, o "tente de novo" honesto do Fallback. Com o provedor 3 s lento, o lab mediu o GET /orders/{id} — que nunca chama o payment — com mediana de 9,04 s sem proteção e 6,5 ms com os padrões.

services/order/src/main/resources/application.yaml (timeouts and resilience4j)
  payment:                           # lab 9
    url: ${PAYMENT_URL:http://payment:8085}
    resilience: ${PAYMENT_RESILIENCE:true}   # false = call payment with no Resilience4j at all
    connect-timeout: 500ms
    read-timeout: ${PAYMENT_READ_TIMEOUT:1s} # 0 = wait forever

resilience4j:
  retry:
    instances:
      payment:
        max-attempts: ${PAYMENT_RETRY_ATTEMPTS:3}    # 1 = no retry
        wait-duration: 200ms
        enable-exponential-backoff: true
        exponential-backoff-multiplier: 2            # 200 ms, 400 ms ...
        enable-randomized-wait: true
        randomized-wait-factor: 0.5                  # ... each +/- 50% (jitter)
        retry-exceptions:
          - org.springframework.web.client.ResourceAccessException   # timeouts, connection refused/reset
          - org.springframework.web.client.HttpServerErrorException  # 5xx
          - org.springframework.web.client.RestClientException       # connection reset while reading the response
        ignore-exceptions:
          - org.springframework.web.client.HttpClientErrorException  # 4xx: the same request fails again
          - io.github.resilience4j.circuitbreaker.CallNotPermittedException  # circuit open: fail fast
          - io.github.resilience4j.bulkhead.BulkheadFullException           # bulkhead full: fail fast
  circuitbreaker:
    instances:
      payment:
        sliding-window-type: COUNT_BASED
        sliding-window-size: 20
        minimum-number-of-calls: 10
        failure-rate-threshold: 50                   # open when >= 50% of the last 20 calls failed...
        slow-call-duration-threshold: 800ms
        slow-call-rate-threshold: 50                 # ... or >= 50% were slower than 800 ms
        wait-duration-in-open-state: 10s
        permitted-number-of-calls-in-half-open-state: 3
        automatic-transition-from-open-to-half-open-enabled: true
        register-health-indicator: true
        ignore-exceptions:
          - io.github.resilience4j.bulkhead.BulkheadFullException  # our own refusal is not the dependency's fault
  bulkhead:
    instances:
      payment:
        max-concurrent-calls: ${PAYMENT_BULKHEAD:10} # at most 10 of the 50 threads wait on payment
        max-wait-duration: 0                         # full = reject immediately
services/order/src/main/java/boxoffice/order/payment/PaymentGateway.java (the stack)
@Retry(name = "payment", fallbackMethod = "unavailable")
@CircuitBreaker(name = "payment")
@Bulkhead(name = "payment")
public PaymentResponse charge(UUID orderId, BigDecimal amount) {
    return client.charge(orderId, amount);
}

Experimente

São 10:02 e o provedor responde em 4 s em vez de 200 ms. As chaves usam os valores do quadro acima (timeout de leitura de 1 s; 3 tentativas com backoff de 200 ms × 2 ± 50%; um breaker sobre as últimas 20 chamadas que abre com 50% de falhas ou acima de 800 ms e espera 10 s). Ligue uma de cada vez, recomeçando a cada rodada:

  1. Nada ligado: 20 pagamentos/s × 4 s pedem 80 threads; as 50 ficam ocupadas em segundos e, em 30 s, cerca de 220 pagamentos não encontram thread nenhuma — nem o GET /orders encontraria.
  2. Timeout: só cerca de 20 threads ficam ocupadas, mas 0% dos pagamentos dão certo. O timeout protege o order, não o pagamento.
  3. + retentativas: o provedor passa a receber cerca de 2× os pagamentos (44 chamadas/s) justamente quando está com dificuldade e as 50 threads lotam de novo — 3 tentativas de 1 s mais o backoff prendem cada thread por cerca de 3,6 s. Timeout mais retentativas sem breaker é pior que nada: depois de 30 s, 0 pagamentos dão certo a cada 10 s (128 deram certo com nada ligado, devagar), cerca de 200 não encontraram thread e o provedor recebe o dobro da carga.
  4. + circuit breaker: ele abre 1,6 s depois do início; os pagamentos falham rápido, as threads caem para cerca de 1 e o provedor não recebe chamadas. Arraste a latência de volta para 200 ms: 10 s depois de abrir, o breaker fica semiaberto, 3 sondas dão certo e ele fecha. Pontos vermelhos na janela dele são falhas, laranja são chamadas lentas.

As anotações decidem o caminho de cada chamada. Leia da esquerda: o retry envolve o breaker, que envolve o bulkhead, que envolve a chamada HTTP — e toda recusa termina no mesmo fallback.

flowchart LR
    call(["charge"]) --> R["Retry<br/>3 tentativas, 200 ms × 2 ± 50%"]
    R --> CB{"circuit breaker<br/>deixa passar?"}
    CB -->|"aberto: CallNotPermitted"| FB["fallback<br/>pagamento indisponível, assentos reservados"]:::problem
    CB -->|"fechado ou uma sonda meio-aberta"| BH{"bulkhead<br/>permissão livre?"}
    BH -->|"cheio: BulkheadFull"| FB
    BH -->|"sim"| HTTP["chamada HTTP<br/>conexão 500 ms, leitura 1 s"]
    HTTP -->|"timeout, 5xx ou reset: contado pelo breaker"| R
    HTTP -->|"2xx"| OK(["cobrado"]):::comp
    R -->|"tentativas esgotadas"| FB

Como as camadas interagem — verifique antes de lançar:

  • Ordem dos decoradores. O padrão do Resilience4j no Spring Boot é Retry ( CircuitBreaker ( RateLimiter ( TimeLimiter ( Bulkhead ( call ) ) ) ) ): o retry é o mais externo, então toda tentativa é contada pelo breaker e um breaker aberto faz o retry falhar na hora. Garanta que os retries nunca contornem o breaker. Ponha o fallback na camada mais externa (o retry): um fallback no breaker transforma toda falha numa resposta normal, então o retry nunca vê um erro e nunca repete.
  • Orçamento de tempo. 3 tentativas × 1 s + backoffs de cerca de 200 ms e 400 ms ≈ 3,6 s, dentro dos 5 s do gateway.
  • Métricas. O Resilience4j exporta pelo Micrometer o estado do breaker, a saturação do bulkhead e a contagem de retries; coloque-os em gráficos ao lado do dashboard de objetivos de nível de serviço (SLO, service level objective) (Hands-on 8), porque um breaker que abre é um incidente em andamento.
  • Prova. Nada disso é confiável até você injetar a falha e ver funcionar — engenharia do caos e Hands-on 9.

Experimente no playground

Abra o cenário cascading-failure no modo completo. Rode uma vez como está (sem proteção) e anote a taxa de erros das rotas saudáveis. Depois adicione, uma de cada vez, um timeout, um circuit breaker e um bulkhead na chamada ao terceiro, rodando depois de cada mudança. Qual deles protege mais as rotas saudáveis? Quanto cada um custa às requisições que precisam do terceiro?

Experimente no playground: os números do lab 9

O preset boxoffice-payment é o Hands-on 9 no playground: o pay-under-chaos.js manda 20 pagamentos/s e 20 requisições de navegação/s ao order, que tem 50 threads do Tomcat, e em t = 60 s o Toxiproxy acrescenta 3 s a toda chamada ao payment. Rode como está: 20 pagamentos/s × 3 s = 60 chamadas em andamento > 50 threads e a navegação, que nunca toca o provedor, falha junto. Depois proteja a aresta order → payment como o lab faz — timeout de 1 000 ms, 3 tentativas com backoff com jitter, o circuit breaker e um bulkhead de 0,2 das threads (10 de 50) — e rode de novo: os pagamentos falham rápido durante o incidente e a navegação mantém as suas threads.

As camadas também têm uma ordem, da mais externa para dentro, e cada posição tem um motivo:

Camada, da mais externa Trata Por que nesta posição Configuração no BoxOffice
Rate limiting, load shedding (gateway) Clientes abusivos, sobrecarga Recusa o trabalho excedente antes que ele custe algo token bucket por conta; recomendações e autocomplete descartados primeiro
Retry + backoff + jitter, com o fallback Erros transitórios Fora do breaker: um breaker aberto para os retries na hora; o fallback roda uma vez, depois que tudo lá dentro desistiu 3 tentativas, 200 ms × 2 ± 50%, chave de idempotência; 503, lugares reservados
Circuit breaker Uma dependência sabidamente falhando ou lenta Vê cada tentativa, timeouts incluídos, como uma chamada a julgar 50% de falhas ou de chamadas acima de 800 ms nas últimas 20, aberto por 10 s
Bulkhead Uma dependência lenta comendo todas as threads Limita as threads que as tentativas podem segurar 10 chamadas concorrentes ao pagamento das 50 threads, sem fila
Timeout Espera sem limite A mais interna: limita cada tentativa, não a soma 500 ms de conexão, 1 s de leitura

Essa é a ordem padrão dos aspectos do Resilience4j no Spring Boot, Retry ( CircuitBreaker ( RateLimiter ( TimeLimiter ( Bulkhead ( call ) ) ) ) ) — no lab 9 o timeout de leitura do cliente HTTP faz o papel do time limiter, dentro da chamada. O handler de resiliência padrão da Microsoft para o HttpClient do .NET empilha do mesmo jeito: rate limiter → timeout total → retry → circuit breaker → timeout por tentativa6. Qualquer que seja a biblioteca, verifique que os retries não contornam o breaker e que o timeout limita cada tentativa.

Na entrevista

Quando um projeto tem uma chamada a um terceiro ou a uma dependência crítica, ofereça a pilha de proteção de uma vez: "timeout por volta do p99,9, um ou dois retries com backoff e jitter e uma chave de idempotência, um circuit breaker que também conta chamadas lentas, um bulkhead dimensionado com a Lei de Little e um fallback que diz a verdade ao usuário". Depois justifique um número (o bulkhead ou o timeout) com aritmética. Se perguntarem sobre sobrecarga, diferencie rate limiting (por cliente) de load shedding (o sistema todo, por prioridade) e mencione a amplificação de retries entre camadas.

Boas práticas

  • Derive cada timeout do p99,9 medido da dependência e mantenha-o abaixo do orçamento que resta ao chamador — o orçamento encolhe a cada salto (borda 10 s > gateway 5 s > uma tentativa 1 s). No BoxOffice: timeout de leitura de 1 s no payment (quadro acima).
  • Dimensione cada bulkhead com a Lei de Little e recalcule quando a latência ou o tráfego mudarem — 20 pagamentos/s × 0,2 s = 4 chamadas em voo, então um bulkhead de 10 deixa espaço para 2,5× a latência. No BoxOffice: 10 das 50 threads do order (Hands-on 9).
  • Faça de todo parâmetro de resiliência configuração, não código — durante um incidente você aumenta um timeout ou encolhe um bulkhead mudando configuração, sem build. No BoxOffice: PAYMENT_READ_TIMEOUT, PAYMENT_RETRY_ATTEMPTS, PAYMENT_BULKHEAD no application.yaml.
  • Limite os retries com um orçamento, não só com uma contagem — retries que somam no máximo 10% ao tráfego normal deixaram o provedor se recuperar na simulação acima, onde 3 retries por chamada o mantinham caído.
  • Publique o estado do breaker, as permissões do bulkhead e as contagens de retry como métricas e alerte quando o breaker abrir — um breaker aberto é um incidente em andamento. No BoxOffice: /actuator/circuitbreakers e o breaker no /actuator/health (lab 9).
  • Devolva o fallback como um estado explícito sobre o qual o cliente pode agir — "pagamento indisponível, lugares reservados" deixa o fã tentar de novo; um 500 genérico não. No BoxOffice: 503 com o pedido mantido em PENDING_PAYMENT.

Armadilhas comuns

  • Timeouts padrão de minutos (ou nenhum) em clientes HTTP e de banco de dados.
  • Retries em todas as camadas — 3 × 3 × 3 = 27 chamadas por clique a um serviço em dificuldade.
  • Repetir chamadas não idempotentes sem chave de idempotência: cobranças duplicadas.
  • Contar erros de negócio como falhas: cartões recusados abrindo o breaker para todos.
  • Breakers que só contam erros, não lentidão: um provedor a 4 s por chamada nunca os dispara.
  • Dependências nos probes de liveness: uma oscilação de um terceiro reinicia a frota inteira.
  • Fallbacks não testados que falham na primeira vez em que são necessários.

Como se conecta

flowchart LR
    SLOW["dependência lenta<br/>(provedor de pagamento)"] --> TO["timeout ≈ p99,9<br/>+ propagação de deadline"]
    TO --> RT["retry: backoff, jitter,<br/>retry budget, uma camada"]
    RT --> IK["chave de idempotência<br/>→ Compute — integrações"]
    TO --> CB["circuit breaker<br/>(também conta chamadas lentas)"]
    CB --> FB["fallback: assentos reservados,<br/>diga a verdade"]
    SLOW --> BH["bulkhead dimensionado pela<br/>Lei de Little → Estimativas"]
    OVER["sobrecarga"] --> LS["descarte de carga<br/>→ sala de espera (Mensageria)"]
    OVER --> RL["rate limiting<br/>→ Borda — API gateway"]
    HC["liveness, readiness, startup<br/>→ Cloud-native — Kubernetes"] --> LB["fora do load balancer<br/>→ Borda — balanceamento"]
    CB --> CH["prove sob falha<br/>→ Engenharia do caos"]

Componentes da paleta: thirdparty · payment (a chamada que todos os padrões desta página protegem) · app (as réplicas de order cujas threads o bulkhead protege) · apigw (rate limiting e descarte de carga na porta) · queue (a sala de espera) · healthcheck (liveness, readiness, startup) · lb (retira instâncias não prontas). Cenários: cascading-failure, retry-storm, rate-limiter, payment-system, flash-sale. Continua em: Compute — integrações, Mensageria — semântica de entrega, Mensageria — a sala de espera, Borda — API gateway, Borda — balanceamento de carga, Cloud-native — Kubernetes, Hands-on 9 — pagamento e Toxiproxy.



  1. NYGARD, M. Release It! Design and Deploy Production-Ready Software, 2. ed. Pragmatic Bookshelf, 2018. Capítulo "Stability Patterns". ↩

  2. BROOKER, M. Exponential Backoff And Jitter. AWS Architecture Blog, 2015; BROOKER, M. Timeouts, retries, and backoff with jitter. Amazon Builders' Library. ↩

  3. FOWLER, M. CircuitBreaker. martinfowler.com, 2014. ↩

  4. BEYER, B. et al. Site Reliability Engineering. O'Reilly, 2016. Capítulo 21, "Handling Overload"; YANACEK, D. Using load shedding to avoid overload. Amazon Builders' Library. ↩

  5. Documentação do Resilience4j. ↩

  6. MICROSOFT. Build resilient HTTP apps: key development patterns. Microsoft Learn (o handler de resiliência padrão). ↩