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íticaTempo para responder as 50Resultado
Sem timeout5,0 s (cinco rodadas de 10)as 50 têm sucesso, mas o último usuário esperou cinco segundos
Timeout de 0,2 s1,0 sas 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.

  1. 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.
  2. 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.
  3. 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 servidorPassos de trabalho executados (de 400 se toda requisição fosse até o fim)
ignora a conexão fechada400 (100%), tudo para chamadores que já tinham ido embora
confere antes de cada passo se o cliente ainda está conectado80 (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:

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 pTentativas por requisição (3 retries)
0,11,11
0,51,88
0,93,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 aconteceuRepetir?Por quê e como
Conexão recusada, falha de DNS, conexão resetada antes de a requisição ser enviadaSimA 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 enviadaSó 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_EXHAUSTEDSim, depois da espera que o servidor pede (Retry-After), com backoffO servidor está dizendo para você desacelerar. Repetir antes piora, e um orçamento de retries deve contá-los.
503 Service Unavailable, gRPC UNAVAILABLESim, com backoff e jitter, dentro do orçamentoEm geral transitório (reinício, sobrecarga, failover). Respeite o Retry-After.
502 Bad Gateway, 504 Gateway TimeoutComo um timeoutUm proxy falhou ou desistiu; o upstream ainda pode ter processado a requisição.
500 Internal Server Error, gRPC INTERNAL, UNKNOWNRaramente, uma ou duas vezes, e só para requisições idempotentesMuitas vezes um bug determinístico que falhará de novo; repetições são só carga.
408 Request TimeoutSim (idempotente)O servidor não recebeu a requisição inteira a tempo.
409 Conflict, 412 Precondition FailedNã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_FOUNDNãoA 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 acabouO 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égiaMaior multidão em uma janela de 50 ms, rodadas 1 a 6
Atraso fixo1000, 1000, 1000, 1000, 1000, 1000
Exponencial, sem jitter1000, 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:

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

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:

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:

  1. 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).
  2. 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.
  3. 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).
  4. 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.
  5. 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.
  6. 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.
  7. 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çãoLatência mediana das chamadas rápidasChamada rápida mais lenta
Um pool compartilhado de 10 slots1523 ms1534 ms
Pools separados de 1021 ms31 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:

FilaRequisições atendidasRejeitadasEspera medianaMaior espera
Ilimitada600015,6 ticks31 ticks
Limitada a 206002901,5 ticks2 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.

8. Erros comuns

9. Coisas a mencionar em uma entrevista

Resumo rápido

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

Pratique este tema: System Design System Design › Reliability and scale

Mais guias