Carregando
0x90Lição 10 de 15

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.

30 min Questionário com 7 perguntas 2 exercícios de código
Ao final desta lição, você saberá
  • 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ãoIdeia
Timeoutnunca espere para sempre; desista depois de um orçamento de tempo
Nova tentativa com backoff e jittertente 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 breakerdepois de falhas repetidas, pare de chamar por um tempo e falhe rápido; depois teste com uma chamada de prova
Bulkheadpools separados (threads, conexões) por dependência, para que uma dependência lenta não use todos
Fallbackuma resposta degradada em vez de um erro: o cardápio em cache, “os pontos vão aparecer depois”
Load sheddingsob 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.

circuit_breaker.py
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}")
Saída
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 XP

Qual padrão ajuda?

Associe cada incidente da Galactic Noodle Express ao padrão que mais teria ajudado.

0 de 5 classificadosPontuação 0/0
  • “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.

Exercício 1

Construa um circuit breaker

+25 XP

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
main.py
Carregando editor…

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.

Exercício 2

Novas tentativas dentro de um prazo

+25 XP

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
main.py
Carregando editor…

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…