Como funcionam circuit breakers e retentativas com backoff em sistemas distribuídos?

Question

Accepted Answer

Em sistemas distribuídos, chamadas falham. **Tentativas com backoff** recuperam de erros *transitórios*; um **circuit breaker** evita que você bombardeie uma dependência que está genuinamente *indisponível*. São complementares: tente novamente o lapso, interrompa na interrupção.

## Tentativa com backoff exponencial + jitter

Para falhas transitórias (timeouts, breves interrupções de rede, 503s), tente novamente — mas **recue exponencialmente e adicione jitter** para que as tentativas se espalhem em vez de se sincronizarem em um "thundering herd".

```text
attempt 1 → wait ~1s   (+ random jitter)
attempt 2 → wait ~2s   (+ random jitter)
attempt 3 → wait ~4s   (+ random jitter)
→ cap at maxRetries (e.g. 3) and a max delay → don't retry forever
```

Precauções principais:

- **Limite tentativas** — tentativas ilimitadas criam **retry storms** que sobrecarregam um serviço em recuperação.
- **Idempotência** — apenas tente novamente operações que são seguras para repetir (uma tentativa de pagamento não deve cobrar duas vezes).
- **Jitter** — sem ele, todos os clientes tentam novamente no mesmo instante e reforçam a carga.

## Circuit breaker

Um circuit breaker rastreia falhas em uma dependência e, após um limite, **abre** — falhando rapidamente (ou retornando um fallback) em vez de chamar um serviço inativo. Após um cooldown, ele fica **semi-aberto** para sondar a recuperação.

```text
CLOSED   → calls pass through; count failures
  too many failures → trip → OPEN
OPEN     → fail fast immediately (no call); start cooldown timer
  cooldown elapsed → HALF-OPEN
HALF-OPEN → allow a few probe calls
  success → CLOSED (recovered) ; failure → back to OPEN
```

## Quando cada um se aplica

```text
Retry           → transient, likely-to-succeed-soon errors (1 slow call)
Circuit breaker → repeated/sustained failures (the dependency is down)
→ use together: breaker prevents retries from piling onto a dead service
```

## Por que isso importa

Sem estes, uma dependência com falha leva o chamador com ela: as solicitações se acumulam em timeouts, as tentativas amplificam a carga e a falha cascata entre os serviços. Backoff exponencial com jitter se recupera de lapsos sem uma retry storm; o limite e a idempotência mantêm as tentativas seguras; e o circuit breaker impede o desperdício de recursos em uma dependência inativa e lhe dá espaço para se recuperar. Juntos, transformam uma falha de dependência em um evento contido e auto-curativo.