Padrões de resiliência
Impeça que um serviço com falha derrube os outros com timeouts, novas tentativas com backoff, circuit breakers, bulkheads e fallbacks.
- Explicar as falhas em cascata e como elas se espalham por chamadas síncronas
- Combinar timeouts, novas tentativas com backoff exponencial e jitter, e fallbacks
- Implementar um circuit breaker e isolar dependências com bulkheads
Sexta à noite, horário de pico do lámen. O serviço de Pontos de Fidelidade fica lentíssimo. Pedidos o chama a cada pedido e espera... e espera. As threads de Pedidos se esgotam, então ele para de responder ao gateway; as conexões do gateway se esgotam; o app inteiro cai - por causa dos pontos de fidelidade. Isso é uma falha em cascata.
O kit de resiliência (a trilha de Sistemas Distribuídos aprofunda novas tentativas e idempotência):
| Padrão | Ideia |
|---|---|
| Timeout | nunca espere para sempre; desista depois de um orçamento de tempo |
| Nova tentativa com backoff e jitter | tente de novo as falhas passageiras, esperando mais a cada vez (e de forma aleatória), para não sobrecarregar um serviço com dificuldades |
| Circuit breaker | depois de falhas repetidas, pare de chamar por um tempo e falhe rápido; depois teste com uma chamada de prova |
| Bulkhead | pools separados (threads, conexões) por dependência, para que uma dependência lenta não use todos |
| Fallback | uma resposta degradada em vez de um erro: o cardápio em cache, “os pontos vão aparecer depois” |
| Load shedding | sob sobrecarga, rejeite algumas requisições rapidamente para continuar atendendo as outras |
O circuit breaker
Um circuit breaker envolve as chamadas a uma dependência e tem três estados:
- Fechado (normal): as chamadas passam; as falhas são contadas. Depois de N falhas seguidas, ele abre.
- Aberto: as chamadas falham na hora, sem tocar na dependência - dando espaço para ela se recuperar e liberando as suas threads. Depois de um tempo de espera, ele fica meio aberto.
- Meio aberto: uma chamada de prova passa. Sucesso → fechado; falha → aberto de novo.
Com um fallback, Pedidos continua aceitando pedidos enquanto Fidelidade se recupera, e os clientes recebem os pontos um pouco depois.
1class CircuitBreaker:
2 def __init__(self, threshold, cooldown):
3 self.threshold, self.cooldown = threshold, cooldown
4 self.state, self.failures, self.opened_at = "closed", 0, None
5
6 def call(self, now, succeeds):
7 if self.state == "open":
8 if now - self.opened_at < self.cooldown:
9 return "fast fail (open)"
10 self.state = "half-open"
11 if succeeds:
12 self.state, self.failures = "closed", 0
13 return "ok"
14 self.failures += 1
15 if self.state == "half-open" or self.failures >= self.threshold:
16 self.state, self.opened_at = "open", now
17 return "failed"
18
19breaker = CircuitBreaker(threshold=3, cooldown=10)
20for now, succeeds in [(0, True), (1, False), (2, False), (3, False), (4, True), (9, True), (14, True), (15, True)]:
21 print(f"t={now:>2} {breaker.call(now, succeeds):<16} state={breaker.state}")t= 0 ok state=closed t= 1 failed state=closed t= 2 failed state=closed t= 3 failed state=open t= 4 fast fail (open) state=open t= 9 fast fail (open) state=open t=14 ok state=closed t=15 ok state=closed
Experimente
Até 15 XPQual padrão ajuda?
Associe cada incidente da Galactic Noodle Express ao padrão que mais teria ajudado.
“Uma chamada a Fidelidade ficou travada por 10 minutos antes de falhar”
“Uma instabilidade rápida na rede fez 1 em cada 1.000 chamadas de pagamento falhar; uma segunda tentativa teria funcionado”
“Fidelidade ficou fora do ar por 20 minutos, e cada pedido ainda esperava 2 segundos pelo timeout dela”
“Um redimensionamento de imagens lento consumiu todas as threads do serviço de Cardápio, então até leituras simples do cardápio falharam”
“O serviço de recomendações está fora do ar; a página inicial mostrou um erro em vez do cardápio”
Principais conclusões
Uma única dependência lenta pode se espalhar em cascata pelas chamadas síncronas e derrubar tudo.
Timeouts em todas as chamadas; novas tentativas só para falhas passageiras, com backoff, jitter e limites.
Circuit breakers falham rápido enquanto uma dependência se recupera; bulkheads impedem que uma dependência esgote recursos compartilhados.
Fallbacks e load shedding mantêm o sistema útil num estado degradado.
Quiz da aula
7 perguntas · aprovação com 5 acertos · até 50 XP
Ao passar, você conclui a aula e mantém sua sequência. As perguntas erradas voltarão em sessões de revisão.
Pratique: simule padrões de microsserviços com Python
Crie pequenas simulações em Python dos padrões, como roteadores, sagas, outboxes, circuit breakers e traces, e execute-as com entradas de exemplo. Elas rodam localmente no navegador; não é preciso ter servidores nem contêineres.
Construa um circuit breaker
A primeira linha da entrada é threshold cooldown. Cada linha seguinte é uma chamada time ok|fail (o que a dependência faria). Implemente o breaker: fechado → aberto depois de threshold falhas seguidas; com ele aberto, as chamadas falham rápido até passarem cooldown segundos desde que ele abriu; depois, uma prova meio aberta: sucesso o fecha (e zera a contagem), falha o reabre. Imprima t=3 failed (closed -> open), t=4 fast fail ou t=0 ok - mostrando uma transição entre parênteses quando a chamada muda o estado (uma chamada de prova depois do tempo de espera mostra half-open -> closed ou half-open -> open). Termine com calls reaching the dependency: N of M.
- Queda e recuperação
O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.
Novas tentativas dentro de um prazo
A primeira linha da entrada é base cap max_attempts deadline (em segundos). Os intervalos entre tentativas crescem de forma exponencial: depois da tentativa n (contando a partir de 1), espere min(cap, base * 2**(n-1)) antes da próxima. Cada tentativa leva 1 segundo. Cada linha seguinte é uma chamada: os resultados das tentativas dela (fail fail ok). Para cada chamada, tente até dar certo, até atingir max_attempts ou até a próxima tentativa não conseguir terminar antes do prazo. Imprima call 1: ok after 3 attempts at 6.0s, call 2: gave up after 4 attempts at 11.0s ou ... (deadline).
- Três chamadas
- Prazo apertado
O Python é executado em um ambiente isolado no navegador, com limite de 60 segundos. O runtime é carregado pelo CDN do Pyodide; seu código permanece neste navegador.
Dúvidas sobre esta lição
Travou em algum ponto? Pergunte. Descobriu algo? Compartilhe. Explicar também é uma ótima forma de aprender.
Carregando publicações…