CS Fundamentals Trainer · Guias
Padrões de resiliência: timeouts, retries e circuit breakers
Como uma dependência lenta se espalha e as ferramentas que a contêm: timeouts e deadlines, retries com backoff, jitter e orçamentos, circuit breakers, bulkheads, backpressure e load shedding, com experimentos medidos e duas animações passo a passo.
31 min de leitura
Toda dependência que o seu serviço chama será, mais cedo ou mais tarde, lenta, errada ou inexistente. Resiliência é o que o seu serviço faz em seguida: se uma dependência doente continua sendo um problema local ou se espalha até tudo cair. As ferramentas são poucas e antigas: timeouts, retries com backoff e jitter, circuit breakers, bulkheads, backpressure e load shedding. Cada uma é simples. A dificuldade é que elas interagem: uma política de retry razoável para um cliente vira um ataque ao servidor quando mil clientes a compartilham, e um timeout generoso demais é pior que nenhum para o chamador que está esperando.
Este guia monta o quadro na ordem em que uma requisição encontra as ferramentas. Executei pequenos experimentos para cada número citado aqui; o código está no apêndice.
1. Como uma falha se espalha
Uma dependência lenta é mais perigosa que uma morta. Uma morta recusa conexões e o chamador fica sabendo na hora. Uma lenta segura os recursos do chamador (uma thread, uma conexão, memória) pelo tempo que for preciso, e toda nova requisição que chega nesse meio-tempo faz o mesmo.
Diagram: One slow dependency exhausts the callers' workers
Medi o efeito com 10 workers e 50 requisições que chegam juntas, enquanto a dependência leva 1 segundo em vez de alguns milissegundos:
| Política | Tempo para responder as 50 | Resultado |
|---|---|---|
| Sem timeout | 5,0 s (cinco rodadas de 10) | as 50 têm sucesso, mas o último usuário esperou cinco segundos |
| Timeout de 0,2 s | 1,0 s | as 50 falham rápido; os workers ficam livres depois de 0,2 s cada |
Note o que o timeout fez e o que não fez. Ele não fez as requisições terem sucesso; a dependência realmente estava lenta demais. Ele limitou o dano: nenhuma requisição ocupa um worker por mais de 0,2 s, então o serviço mantém sua capacidade para as requisições que não precisam da dependência doente, e o chamador fica sabendo rápido e pode usar um fallback. Esse é todo o propósito do resto deste guia: limitar por quanto tempo, com que frequência e quantas.
2. Timeouts
Um timeout é o tempo máximo que você esperará por uma resposta. Três regras cobrem a maior parte da prática.
- Toda chamada que sai do processo recebe um. Muitos clientes HTTP, drivers de banco de dados e clientes de fila têm por padrão nenhum timeout ou minutos. Confira o padrão de cada cliente que você usa; é uma causa raiz comum de incidentes.
- Escolha-o a partir dos dados. Olhe a distribuição de latência da dependência (veja observabilidade sobre percentis) e defina o timeout um pouco acima da latência que você considera normal, por exemplo logo acima do percentil 99 ou 99,9. Curto demais e você transforma sucessos lentos em falhas e, com retries, em carga; longo demais e ele não protege nada.
- Separe os tipos. Um timeout de conexão (tem alguém aí?) pode ser curto, um timeout de leitura depende da operação e um deadline geral limita a requisição inteira.
Os deadlines viajam com a requisição
Se uma requisição voltada ao usuário tem 2 segundos no total e o serviço A gasta 1,5 s antes de chamar B, então B não deve receber o seu timeout habitual de 2 s, porque ninguém estará esperando pela resposta. Repasse o orçamento de tempo restante (o gRPC chama isso de deadline; em HTTP costuma ser um cabeçalho que você define) e faça cada salto usar min(seu próprio timeout, o que sobrou). Sem isso, o trabalho continua para requisições cujo chamador já desistiu, e esse trabalho desperdiçado é exatamente o que torna um sistema sobrecarregado mais lento.
Um timeout não para o trabalho do outro lado
Quando o timeout de um chamador dispara, o chamador para de esperar. Ele não para a dependência. A menos que algo avise, o servidor continua: a consulta continua rodando, as chamadas a jusante ainda são feitas, a mensagem ainda é processada e uma escrita ainda pode ser confirmada depois que o chamador relatou uma falha. Medi o custo com um pequeno serviço TCP cuja requisição leva 1 segundo (20 passos de 50 ms) e 20 clientes que desistem depois de 0,2 s e fecham a conexão:
| Comportamento do servidor | Passos de trabalho executados (de 400 se toda requisição fosse até o fim) |
|---|---|
| ignora a conexão fechada | 400 (100%), tudo para chamadores que já tinham ido embora |
| confere antes de cada passo se o cliente ainda está conectado | 80 (20%) |
Os timeouts do primeiro experimento deste guia pararam a dependência simulada, porque ela vivia no mesmo processo e o asyncio a cancelou. Por uma rede isso não acontece sozinho. Propagar o cancelamento dá trabalho em todas as camadas:
- Sinalize-o. Use um mecanismo que carregue o cancelamento pela chamada: um contexto ou token de cancelamento repassado adiante (
contextdo Go,CancellationTokendo .NET, cancelamento de tarefas do Python), um deadline e cancelamento do gRPC (o servidor vê o contexto cancelado) ou o fechamento da conexão ou do stream HTTP (RST_STREAMdo HTTP/2). Se o servidor percebe uma conexão fechada depende do framework. - Verifique-o. O servidor precisa olhar: repasse o contexto às chamadas de banco de dados e aos clientes a jusante, confira-o entre os passos de um job longo e pare. Um handler que nunca olha para o sinal de cancelamento não pode ser cancelado.
- Saiba o que não pode ser desfeito. O cancelamento é um pedido para parar, não um rollback. Uma transação que foi confirmada continua confirmada, uma mensagem já colocada em uma fila será consumida e um e-mail já enviado continua enviado. Para esses casos, o timeout é um resultado ambíguo (veja "O que é seguro repetir"), e a operação precisa de uma chave de idempotência ou de uma forma de consultar o seu resultado.
- Limite o trabalho também no servidor. Um deadline no servidor (tomado do orçamento restante da requisição, ou um máximo fixo) para requisições descontroladas mesmo quando o cliente nunca sinaliza nada, e as filas devem descartar as requisições cujo deadline já passou em vez de iniciá-las.
- Fique de olho nas sobras. Compare o trabalho que a dependência faz com o trabalho que seus chamadores ainda queriam (requisições que terminaram depois do timeout do chamador; o número de consultas em andamento comparado com o número de chamadores vivos). A diferença é o desperdício, e ele é maior exatamente quando o sistema está sobrecarregado.
3. Retries
Um retry corrige falhas transitórias: um pacote perdido, um failover breve, uma requisição que caiu numa instância reiniciando. Ele piora as falhas persistentes, porque multiplica a carga sobre algo que já está com dificuldade.
A aritmética é simples. Se cada tentativa falha com probabilidade p e você permite 3 retries, o número esperado de tentativas por requisição é 1 + p + p² + p³:
| Taxa de falha p | Tentativas por requisição (3 retries) |
|---|---|
| 0,1 | 1,11 |
| 0,5 | 1,88 |
| 0,9 | 3,44 |
Com 10% de falhas, os retries não custam quase nada, e é por isso que parecem de graça nos testes. Com 90%, a dependência recebe 3,4 vezes a sua carga normal exatamente quando é menos capaz de lidar com ela. E isso é para uma camada. Se o serviço A faz retry 3 vezes contra B, e B faz retry 3 vezes contra C, uma única falha em C pode causar 4 × 4 = 16 chamadas. Faça retry em uma camada, em geral a mais próxima do usuário ou a que sabe que a operação é segura de repetir, e não em todas.
O que é seguro repetir
Repetir só é seguro quando repetir a requisição não pode causar dano. Leituras são. Escritas são se forem idempotentes (um UPDATE ... SET status = 'paid' é; balance = balance - 10 não é) ou carregarem uma chave de idempotência que o servidor confere; veja projetando uma API REST e os limites das chaves de idempotência em transações distribuídas. Um timeout não é uma falha: a requisição pode ter tido sucesso e só a resposta se perdeu. É por isso que a chave importa.
Quais erros repetir
"Repita em caso de falha" é grosseiro demais. O que fazer depende do que a falha diz sobre a requisição e de a requisição poder ser repetida de todo (a seção anterior):
| O que aconteceu | Repetir? | Por quê e como |
|---|---|---|
| Conexão recusada, falha de DNS, conexão resetada antes de a requisição ser enviada | Sim | A requisição nunca chegou ao servidor, então repeti-la é seguro até para escritas. Tente outra instância se puder. |
| Timeout, ou conexão perdida depois de a requisição ser enviada | Só se idempotente (ou com uma chave de idempotência) | O resultado é desconhecido: o servidor pode ter feito o trabalho. |
429 Too Many Requests, gRPC RESOURCE_EXHAUSTED | Sim, depois da espera que o servidor pede (Retry-After), com backoff | O servidor está dizendo para você desacelerar. Repetir antes piora, e um orçamento de retries deve contá-los. |
503 Service Unavailable, gRPC UNAVAILABLE | Sim, com backoff e jitter, dentro do orçamento | Em geral transitório (reinício, sobrecarga, failover). Respeite o Retry-After. |
502 Bad Gateway, 504 Gateway Timeout | Como um timeout | Um proxy falhou ou desistiu; o upstream ainda pode ter processado a requisição. |
500 Internal Server Error, gRPC INTERNAL, UNKNOWN | Raramente, uma ou duas vezes, e só para requisições idempotentes | Muitas vezes um bug determinístico que falhará de novo; repetições são só carga. |
408 Request Timeout | Sim (idempotente) | O servidor não recebeu a requisição inteira a tempo. |
409 Conflict, 412 Precondition Failed | Não, não como está | O estado mudou. Releia, decida de novo e então envie uma requisição nova. |
400, 401, 403, 404, 422, gRPC INVALID_ARGUMENT, PERMISSION_DENIED, NOT_FOUND | Não | A requisição em si está errada ou não é permitida. Exceção: um retry de um 401 depois de renovar um token expirado. |
gRPC DEADLINE_EXCEEDED, CANCELLED (por você) | Não, o deadline acabou | O orçamento do chamador se esgotou (veja "Os deadlines viajam com a requisição"). |
Trate a tabela como um ponto de partida e confira as convenções dos seus próprios serviços: algumas APIs devolvem 500 para problemas transitórios e 400 para condições que se resolveriam esperando, e diferentes provedores discordam sobre 429 versus 503. Tome a decisão de retry em um só lugar (um objeto de política ou a biblioteca cliente), mantenha explícita a lista de erros repetíveis e registre a classe do erro de cada retry para ver quais tipos realmente têm sucesso na segunda tentativa: um erro que quase nunca é consertado por um retry deve sair da lista.
Backoff e jitter
Esperar um tempo crescente entre as tentativas (backoff exponencial: 0,1 s, 0,2 s, 0,4 s, ...) dá espaço à dependência para se recuperar. Mas se mil clientes falharam no mesmo instante, todos repetirão no mesmo instante, depois do mesmo atraso, de novo e de novo. O backoff sozinho não desfaz a multidão. O jitter (aleatoriedade) desfaz.
Simulei 1 000 clientes que falham todos no tempo zero e repetem seis vezes, e contei o maior número de clientes que repetem dentro da mesma janela de 50 ms em cada rodada:
| Estratégia | Maior multidão em uma janela de 50 ms, rodadas 1 a 6 |
|---|---|
| Atraso fixo | 1000, 1000, 1000, 1000, 1000, 1000 |
| Exponencial, sem jitter | 1000, 1000, 1000, 1000, 1000, 1000 |
| Equal jitter (metade fixa, metade aleatória) | 1000, 478, 267, 133, 81, 42 |
| Full jitter (aleatório de 0 até o teto do backoff) | 519, 260, 138, 71, 36, 24 |
O backoff exponencial sem jitter mantém a multidão intacta: são mil clientes repetindo juntos, só que com menos frequência. O full jitter espalha a primeira rodada pela metade e segue em frente. Acrescente um teto ao atraso e um limite ao número de tentativas, e respeite um cabeçalho Retry-After quando o servidor enviar um.
Interactive animation: retry storm
A animação acima mostra o mesmo efeito em um servidor com capacidade limitada. Quando todos os clientes repetem de uma vez, o servidor continua sobrecarregado e, neste modelo, não atende ninguém: gasta sua capacidade em requisições que estão prestes a ser abandonadas. Isso é uma tempestade de retries (retry storm, ou falha metaestável): o sistema continua quebrado depois que a causa original foi embora, porque os próprios retries sustentam a sobrecarga. Com backoff e jitter a carga diminui e todos são atendidos.
Um orçamento de retries
Uma regra fixa de "repita até 3 vezes" não distingue um período saudável de um doente. Um orçamento de retries limita os retries como uma fração do tráfego normal, por exemplo "os retries podem ser no máximo 10% das requisições enviadas no último minuto". Durante um pequeno soluço o orçamento permite os retries; durante uma queda ele se esgota e o cliente para de acrescentar carga. Várias bibliotecas cliente e service meshes oferecem isso.
Orçamentos em um sistema distribuído
Um orçamento mantido dentro de cada processo cliente é um bom começo, mas tem limites em uma frota:
- Cada processo vê apenas o seu próprio tráfego. Com 1 000 instâncias, cada uma limitando os retries a 10% das suas próprias requisições, o total da frota é cerca de 10% só quando a carga está distribuída uniformemente e as falhas se distribuem com ela. Se as requisições que falham se concentram em poucas instâncias, ou poucos clientes fazem a maior parte das chamadas, a carga agregada de retries sobre a dependência pode ser muito maior ou menor que 10%. Um orçamento sobre uma janela curta também deixa passar uma rajada de retries no começo de uma queda, porque todo processo ainda tem tokens.
- As camadas multiplicam seus orçamentos. Se A e B permitem cada um 10% de retries extras, a carga sobre C pode ser 1,1 × 1,1 = 1,21 vez a normal, e com orçamentos maiores ou mais camadas, muito mais. O conselho anterior vale: faça retry em uma camada, ou faça as camadas se conhecerem.
- Avise o próximo salto de que isto é um retry. Propague o número da tentativa (um cabeçalho ou campo de metadados como
retry-attempt, definido pela sua plataforma) para que um serviço a jusante saiba que uma requisição já é um retry, não a repita de novo e possa dar a ela prioridade menor que às primeiras tentativas quando precisar descartar carga. O retry throttling do gRPC e proxies como o Envoy implementam variantes dessas ideias: um token bucket por cliente que as falhas esvaziam e os sucessos reabastecem, e um limite superior de retries ativos por upstream. - Aplique também no servidor. O servidor é o único lugar que vê a carga total. Ele pode rejeitar os retries primeiro (pelo cabeçalho de tentativa), usar controle de admissão guiado por sua própria fila e CPU e devolver valores de
Retry-Afterque espalhem os clientes. Um orçamento no cliente é educado; um limite no servidor é o que protege. - Um orçamento compartilhado precisa de estado compartilhado, que é ele próprio uma dependência (um rate limiter central) que pode falhar ou acrescentar latência. Muitos sistemas aceitam orçamentos locais aproximados mais descarte de carga no servidor, e usam um limite central somente para operações muito caras.
- Meça-o. Acompanhe a razão entre retries e primeiras tentativas por cliente e por dependência, o número de retries que tiveram sucesso e com que frequência o orçamento recusou um retry. Um orçamento que nunca recusa é grande demais; um que recusa constantemente na operação normal é pequeno demais ou esconde um problema real.
4. Circuit breakers
Se uma dependência falhou cinco vezes seguidas, a sexta tentativa provavelmente falhará também. Um circuit breaker lembra disso e falha rápido: não chama a dependência de forma alguma por um tempo.
Diagram: The three states of a circuit breaker
- Fechado (closed): normal. As chamadas passam e o breaker conta as falhas.
- Aberto (open): as chamadas falham imediatamente, sem tocar a dependência. Isso protege a dependência (ela ganha uma folga) e o chamador (ele não espera).
- Meio-aberto (half-open): depois de um período de espera, deixa passar uma chamada de teste (ou algumas). Se ela tem sucesso, fecha o breaker; se falha, abre-o de novo.
Percorra um breaker abaixo. Ele abre depois de 3 falhas seguidas, falha as 3 requisições seguintes na hora, tenta uma chamada de teste e fecha de novo quando o serviço se recuperou. Na execução com um serviço que se recupera, a dependência recebeu 10 das 16 requisições e 6 falharam imediatamente sem esperar; se o serviço não se recupera, só 7 de 16 chegaram a ele e 9 falharam rápido.
Interactive animation: circuit breaker
Perguntas de projeto que decidem se um breaker ajuda:
- O que conta como falha? Timeouts e respostas 5xx, sim. Um 404 ou um erro de validação é problema do chamador, não da dependência.
- Contagem ou taxa? "3 seguidas" é fácil de explicar. Uma taxa de falhas sobre uma janela (por exemplo, mais de 50% de pelo menos 20 chamadas em 10 segundos) lida melhor com serviços movimentados e com erros ocasionais.
- O que o chamador faz quando está aberto? O breaker dá uma falha rápida, não uma resposta. Decida o fallback: um valor em cache, um padrão, uma página degradada ou um erro honesto. Falhar rápido sem plano só falha mais depressa.
- Um breaker por dependência, ou por instância? Um breaker por host para de enviar tráfego a uma instância ruim enquanto as outras atendem; um único breaker para o serviço inteiro abriria para todos por causa de um nó ruim.
- Lembre que é por processo. Cada instância do seu serviço tem o seu próprio breaker com a sua própria visão, então eles abrem em momentos ligeiramente diferentes. Isso normalmente é aceitável.
Ajustando um breaker com tráfego de produção
Os números usados acima (3 seguidas, um período de espera de poucas requisições) são para ensino. Um limiar que funciona é derivado de como a dependência real se comporta, e um limiar copiado de um post de blog ou do padrão de uma biblioteca é um palpite. Um procedimento que funciona bem:
- Meça a linha de base. Das métricas de produção, tome a taxa normal de erros, os percentis de latência e a taxa de requisições por instância de cada dependência, incluindo seu padrão diário (uma noite tranquila e uma tarde movimentada dão estatísticas diferentes) e seus incidentes normais (deploys, failovers).
- Leve em conta os erros de fundo. Uma dependência raramente está em 0% de erros. Simulei um breaker que abre depois de 3 falhas seguidas, chamando uma dependência saudável exceto por uma taxa constante de erros de fundo. Só por acaso, ele abriu cerca de 3 vezes por hora com 2% de erros e 100 chamadas por segundo (cerca de 3 por hora e por instância, então uma frota de 50 instâncias abre algumas vezes a cada minuto), e quase nunca com 0,5%. Com 5 chamadas por segundo, 2% de erros o abriram cerca de uma vez em dez horas. "N seguidas" é sensível ao volume de tráfego, e faz uma dependência saudável parecer doente sempre que o volume é alto.
- Prefira uma taxa sobre uma janela com volume mínimo para serviços movimentados: por exemplo, abra quando mais de 50% de pelo menos 20 chamadas nos últimos 10 segundos falharam. Defina o mínimo de modo que um punhado de chamadas azaradas não o dispare, e defina a janela longa o bastante para suavizar o ruído e curta o bastante para reagir antes de os workers dos chamadores se esgotarem (as 50 requisições e os 10 workers do primeiro experimento deram alguns segundos). Para serviços com pouco tráfego, considere uma janela mais longa ou nenhum breaker (um timeout pode bastar).
- Conte as chamadas lentas como falhas, com um limiar tirado da distribuição de latência (por exemplo, mais lentas que o percentil 99,9 da linha de base), porque muitas quedas começam como latência, não como erros.
- Escolha o período de espera e as sondagens a partir do tempo real de recuperação. Se a dependência costuma se recuperar em 30 segundos depois de um reinício, um período de espera de 2 segundos só produz chamadas de teste que falham repetidamente; um de vários minutos mantém o chamador degradado depois que a dependência voltou. Permita algumas chamadas de teste no estado meio-aberto, não uma, para que uma única resposta com sorte ou azar não decida, e deixe o breaker fechar gradualmente.
- Reproduza e use shadow antes de aplicar. Execute as configurações candidatas sobre métricas de produção gravadas ou um replay de tráfego e conte com que frequência e quando teriam aberto, comparado com os incidentes reais. Melhor ainda, implante o breaker em modo somente observação (registre e conte as decisões de "abriria" sem agir) por uma ou duas semanas. Depois ative-o, por dependência e com um rollout gradual.
- Continue observando. Revise as métricas que importam: o número de aberturas por instância (uma abertura que não corresponde a nenhum incidente é um falso positivo), o tempo do início de um incidente até a abertura, o tempo da recuperação até o fechamento e as chamadas rejeitadas enquanto aberto. O tráfego cresce, as dependências mudam e os limiares ficam obsoletos, então ajuste depois de incidentes e de grandes mudanças de carga.
5. Bulkheads
Um navio é dividido em compartimentos estanques para que um buraco inunde um deles e não o casco. Um bulkhead dá a cada dependência (ou a cada tipo de trabalho) o seu próprio pool de threads, conexões ou slots de concorrência, de modo que uma dependência lenta só possa esgotar o seu próprio pool.
Testei com duas dependências: 30 chamadas a uma lenta (0,5 s cada) chegam juntas com 30 chamadas a uma rápida (0,01 s), com 10 slots disponíveis.
| Configuração | Latência mediana das chamadas rápidas | Chamada rápida mais lenta |
|---|---|---|
| Um pool compartilhado de 10 slots | 1523 ms | 1534 ms |
| Pools separados de 10 | 21 ms | 31 ms |
Com um pool compartilhado, as chamadas rápidas ficam na fila atrás das lentas e levam cerca de 70 vezes mais, embora a dependência rápida estivesse perfeitamente saudável. Com pools separados elas mal são afetadas. A mesma ideia vale em escala maior: pools de conexões separados por serviço a jusante, pools de workers separados para trabalho interativo e em lote e até deployments separados para tenants importantes e não importantes (veja sistemas multi-tenant).
O custo é uma capacidade que você não pode compartilhar: dez slots ociosos em um pool não ajudam o outro. Dimensione os pools pela concorrência real que cada dependência precisa (taxa de chegada vezes latência, pela lei de Little) e não por um número redondo.
6. Backpressure e load shedding
Um serviço que aceita mais trabalho do que consegue terminar não processa mais; ele forma uma fila, e as requisições na fila esperam. Duas ideias mantêm isso sob controle.
O backpressure empurra o limite de volta ao remetente: uma fila limitada, um pipe cheio que faz o write bloquear, um 429 Too Many Requests ou 503 com Retry-After, um consumidor que puxa no seu próprio ritmo em vez de ter trabalho empurrado. O remetente então desacelera ou escolhe o que fazer.
O load shedding é recusar de propósito algumas requisições para proteger as demais, por exemplo quando a fila passa de um limite, ou quando a CPU está acima de um limiar. Rejeitar cedo é barato; aceitar uma requisição e responder depois que o chamador já estourou o timeout é o resultado mais caro.
Simulei um serviço que consegue fazer 10 requisições por tick enquanto chegam 15 por tick, por 60 ticks:
| Fila | Requisições atendidas | Rejeitadas | Espera mediana | Maior espera |
|---|---|---|---|---|
| Ilimitada | 600 | 0 | 15,6 ticks | 31 ticks |
| Limitada a 20 | 600 | 290 | 1,5 ticks | 2 ticks |
O serviço fez a mesma quantidade de trabalho (600 requisições) nos dois casos. A fila ilimitada não ajudou ninguém: só fez todos esperarem até 31 ticks, provavelmente mais que seus timeouts, então boa parte desse trabalho teria sido para chamadores que já tinham ido embora. A fila limitada rejeitou 290 requisições na hora e atendeu o resto em cerca de dois ticks. Rejeitar parte do trabalho é o que mantém o resto útil. Escolha o que descartar: primeiro o tráfego de baixa prioridade, as requisições que já estão perto do deadline ou as requisições do cliente que mais envia. Para os algoritmos que limitam as taxas de requisição por cliente, veja projetando um rate limiter; e uma fila entre serviços é o assunto de filas de mensagens.
7. Juntando as peças
Diagram: Where each tool sits on a call
A ordem importa. O descarte de carga e os bulkheads decidem se o trabalho chega a começar. O breaker decide se vai chamar. O timeout limita a chamada. A política de retry fica fora do timeout e usa o breaker, de modo que, quando o breaker está aberto, um retry falha na hora em vez de esperar; e ela para quando o deadline da requisição se esgota.
Mais dois princípios amarram isso tudo.
- Falhe rápido, degrade com elegância. Para cada dependência, decida de antemão o que o usuário vê quando ela está indisponível: dados obsoletos, um recurso desligado, uma fila que aceita a requisição para depois. Isso é uma decisão de produto tanto quanto técnica.
- Teste os caminhos de falha. Um breaker que nunca abriu e um fallback que nunca rodou não estão provados. Injete latência e erros em staging (e com cuidado em produção: experimentos de caos), depois observe seus dashboards: o estado aberto/fechado dos breakers, as taxas de retry, a profundidade das filas, as requisições rejeitadas e a saturação de cada pool são as métricas deste guia.
8. Erros comuns
- Sem timeout, ou um padrão de 30 segundos ou mais em uma chamada no caminho de uma requisição.
- Retries em todas as camadas, multiplicando a carga pelo produto das contagens de retry.
- Repetir escritas não idempotentes sem uma chave de idempotência.
- Backoff sem jitter, de modo que a multidão continua junta.
- Repetir erros que não vão mudar: 400, 401, 403, 404 e 422 são problema do chamador e falharão de novo (veja "Quais erros repetir").
- Um timeout maior que o próprio timeout do chamador, de modo que o trabalho continua para ninguém.
- Uma fila ou pool de threads ilimitado "para que nada se perca": isso transforma uma rejeição rápida em uma falha lenta e total.
- Um circuit breaker sem fallback ou sem monitoramento, de modo que ninguém percebe quando está aberto, ou um cujos limiares nunca foram conferidos contra o tráfego de produção.
- Supor que um timeout cancela o trabalho. O chamador para de esperar; o servidor continua, a menos que o cancelamento seja propagado e verificado.
- Pools compartilhados para trabalho crítico e opcional.
- Tratar health checks como uma estratégia de resiliência. Um balanceador de carga que remove instâncias não saudáveis (veja balanceamento de carga) ajuda, mas também concentra a carga nas instâncias que restam.
9. Coisas a mencionar em uma entrevista
- Comece pelo modo de falha: uma dependência lenta esgota os workers do chamador, então você limita tempo, contagem e concorrência.
- Diga que um timeout limita o dano mas não conserta nada, que você o define a partir dos percentis de latência e repassa um deadline a jusante.
- Dê a fórmula do retry e a amplificação entre camadas, e diga que os retries precisam de idempotência e de backoff com jitter, um teto e um orçamento; que a decisão depende do tipo de erro; e que um orçamento por cliente precisa de limites no servidor e de um marcador de tentativa para funcionar em uma frota.
- Diga que um timeout não cancela o trabalho do outro lado, e como o cancelamento é propagado e verificado.
- Descreva os três estados do breaker e o seu fallback, que ele é por dependência (e muitas vezes por host) e que seus limiares devem vir do tráfego de produção medido, não de padrões.
- Explique o bulkhead com o exemplo do pool compartilhado, e o load shedding com "o mesmo trabalho é feito, mas com uma espera curta em vez de uma longa".
- Mencione as falhas metaestáveis e as tempestades de retries: um sistema pode continuar fora do ar depois que o gatilho foi embora.
Resumo rápido
- Uma dependência lenta é mais perigosa que uma morta; os timeouts limitam por quanto tempo você espera e os deadlines carregam o tempo restante a jusante.
- Os retries ajudam falhas transitórias e prejudicam as persistentes: com 90% de falhas e 3 retries a carga é 3,4 vezes maior, e as camadas multiplicam. Use idempotência, backoff, jitter, um teto e um orçamento de retries, escolha o que repetir pelo tipo de erro e aplique limites também no servidor.
- Um timeout para a espera do chamador, não o trabalho: no teste, um servidor que ignorou a conexão fechada fez 100% do trabalho abandonado, e um que conferiu fez 20%.
- Um circuit breaker (fechado, aberto, meio-aberto) falha rápido para proteger os dois lados, mas precisa de um fallback e de limiares ajustados com tráfego real (um breaker de 3 seguidas abriu cerca de 3 vezes por hora por acaso com 2% de erros de fundo).
- Os bulkheads isolam pools para que uma dependência lenta não leve as rápidas junto (1523 ms contra 21 ms no experimento).
- Backpressure e load shedding mantêm as filas curtas: as mesmas 600 requisições foram atendidas, com uma maior espera de 31 ticks contra 2.
Apêndice: o código dos experimentos
Os números deste guia vêm dos três scripts abaixo (Python 3, apenas a biblioteca padrão; os resultados de tempo usam sleeps reais do asyncio, então os milissegundos variam um pouco entre execuções, e as escolhas aleatórias usam sementes fixas). As duas animações são pequenos modelos determinísticos de um cliente e de um servidor, não medições: mostram a forma do comportamento, e a capacidade simulada e o ponto em que um servidor sobrecarregado deixa de atender qualquer um são suposições do modelo. O teste de cancelamento usa um serviço TCP local em uma máquina, e suas contagens de passos são exatas porque o trabalho é um número fixo de passos; a simulação do breaker é um modelo aleatório (20 execuções com semente) de uma taxa constante de erros de fundo, que o tráfego real não tem: os erros se agrupam, e essa é uma razão para medir o seu próprio.
Timeouts, retries, jitter, bulkheads e filas
import asyncio, random, time, math
# ---- 1. timeouts: without one, a slow dependency ties up every worker
async def slow_dep(delay): await asyncio.sleep(delay)
async def handler(sem, delay, timeout):
async with sem: # a worker slot
try:
await asyncio.wait_for(slow_dep(delay), timeout)
return "ok"
except asyncio.TimeoutError:
return "timeout"
async def exp_timeout(timeout):
sem = asyncio.Semaphore(10) # 10 workers
t0 = time.perf_counter()
# the dependency now takes 1.0 s; 50 requests arrive at once
res = await asyncio.gather(*[handler(sem, 1.0, timeout) for _ in range(50)])
return round(time.perf_counter() - t0, 2), res.count("ok"), res.count("timeout")
# ---- 2. retries multiply load: expected attempts when each attempt fails with probability p
def attempts(p, retries): # 1 + p + p^2 ... (retries extra tries)
return sum(p**i for i in range(retries + 1))
# ---- 3. backoff schedules
def schedule(kind, n, base=0.1, cap=10, rnd=None):
out = []
for k in range(n):
ceiling = min(cap, base * 2**k)
out.append({"fixed": base, "exp": ceiling, "full": rnd.uniform(0, ceiling),
"equal": ceiling/2 + rnd.uniform(0, ceiling/2)}[kind])
return out
def collisions(kind, clients=1000, n=6, bucket=0.05):
rnd = random.Random(7)
worst = []
times = [0.0]*clients
for k in range(n):
for c in range(clients):
times[c] += schedule(kind, k+1, rnd=rnd)[k]
counts = {}
for t in times: counts[int(t/bucket)] = counts.get(int(t/bucket), 0) + 1
worst.append(max(counts.values()))
return worst
# ---- 4. bulkhead: one slow dependency, two pools vs one shared pool
async def call(pool, delay):
async with pool:
await asyncio.sleep(delay)
async def exp_bulkhead(shared):
pools = {"slow": asyncio.Semaphore(10), "fast": asyncio.Semaphore(10)}
if shared: pools["fast"] = pools["slow"]
t0 = time.perf_counter()
# 30 slow calls (0.5 s) arrive together with 30 fast calls (0.01 s)
fast_lat = []
async def fast():
s = time.perf_counter(); await call(pools["fast"], 0.01); fast_lat.append(time.perf_counter()-s)
tasks = [asyncio.create_task(call(pools["slow"], 0.5)) for _ in range(30)]
await asyncio.sleep(0)
tasks += [asyncio.create_task(fast()) for _ in range(30)]
await asyncio.gather(*tasks)
fast_lat.sort()
return round(fast_lat[len(fast_lat)//2]*1000), round(fast_lat[-1]*1000)
# ---- 5. load shedding / queue: Little's law, bounded queue vs unbounded
def queue_sim(limit, ticks=60, arrivals=15, service=10):
q = 0; waits = []; shed = 0; served = 0
for t in range(ticks):
for _ in range(arrivals):
if limit is not None and q >= limit: shed += 1
else: q += 1; waits.append(q/service) # ticks until this one is served
s = min(q, service); q -= s; served += s
waits.sort()
return served, shed, round(waits[len(waits)//2],1), round(waits[-1],1)
if __name__ == "__main__":
for to in (None, 0.2):
print("timeout", to, asyncio.run(exp_timeout(to)))
for p in (0.1, 0.5, 0.9):
print("p", p, "3 retries ->", round(attempts(p, 3), 2), "attempts per request")
for kind in ("fixed","exp","full","equal"):
print(kind, "peak clients in one 50 ms bucket per round:", collisions(kind))
print("bulkhead shared (median, max fast ms):", asyncio.run(exp_bulkhead(True)))
print("bulkhead isolated(median, max fast ms):", asyncio.run(exp_bulkhead(False)))
for lim in (None, 20):
print("queue limit", lim, "(served, shed, median wait, max wait):", queue_sim(lim))
Cancelamento: o servidor continua trabalhando depois que o chamador desistiu?
"""When the caller gives up, does the server keep working? A tiny TCP service whose request takes 1 s (20 steps of 50 ms).
Clients time out after 0.2 s and close the connection. Variant A ignores that; variant B checks whether the client is
still connected before each step (cancellation propagation). Standard library only."""
import asyncio
STEPS, STEP_S, CLIENTS, TIMEOUT = 20, 0.05, 20, 0.2
async def run(check_client):
steps_done = 0
async def handle(reader, writer):
nonlocal steps_done
await reader.readline() # the request
for _ in range(STEPS):
if check_client and reader.at_eof(): # the client has hung up: stop working
break
await asyncio.sleep(STEP_S)
steps_done += 1
try: writer.write(b"done\n"); await writer.drain()
except Exception: pass
writer.close()
server = await asyncio.start_server(handle, "127.0.0.1", 0)
port = server.sockets[0].getsockname()[1]
async def client():
r, w = await asyncio.open_connection("127.0.0.1", port)
w.write(b"req\n"); await w.drain()
try: await asyncio.wait_for(r.readline(), TIMEOUT)
except asyncio.TimeoutError: pass
w.close() # give up
await asyncio.gather(*[client() for _ in range(CLIENTS)])
await asyncio.sleep(STEPS * STEP_S + 0.3) # let the server finish whatever it is still doing
server.close()
return steps_done
for check in (False, True):
done = asyncio.run(run(check))
total = CLIENTS * STEPS
print(f"server {'checks whether the client is still there' if check else 'ignores the closed connection '}: {done:>3} of {total} work steps executed ({done/total*100:.0f}%), "
f"{CLIENTS} callers had given up after {TIMEOUT} s")
Um breaker que abre por acaso
"""A breaker that opens after 3 failures in a row, on a dependency that is healthy except for a steady background error rate.
Counts how often it opens by chance alone, averaged over 20 random runs of one simulated hour each."""
import random
for p, rate in ((0.02, 100), (0.005, 100), (0.02, 5)):
calls = 3_600 * rate; total = 0
for seed in range(20):
r = random.Random(seed); run = 0
for _ in range(calls):
if r.random() < p:
run += 1
if run == 3: total += 1; run = 0 # the breaker opens, then counting starts again from zero
else: run = 0
print(f"background error rate {p*100:.1f}%, {rate:>3} calls/s: opens {total/20:.1f} times per hour by chance alone (calculation: {calls * (1-p) * p**3:.1f})")
Fontes
- Michael Nygard, Release It! (Pragmatic Bookshelf), a origem dos padrões circuit breaker e bulkhead nesta forma.
- Martin Fowler, CircuitBreaker.
- Marc Brooker, Timeouts, retries and backoff with jitter (Amazon Builders' Library), e a sua comparação Exponential Backoff And Jitter.
- Google, Site Reliability Engineering, capítulos Handling Overload e Addressing Cascading Failures.
- Nathan Bronson et al., Metastable Failures in Distributed Systems (HotOS 2021).
- Documentação do gRPC, Deadlines.
Pratique este tema: System Design System Design › Reliability and scale