Hoe werken circuit breakers en retries met backoff in gedistribueerde systemen?

Question

Accepted Answer

In gedistribueerde systemen mislukken oproepen. **Retries met backoff** herstellen van *voorbijgaande* fouten; een **circuit breaker** voorkomt dat je een afhankelijkheid die werkelijk *uit* is, blijft bombarderen. Ze zijn complementair: de kleine storing opnieuw proberen, onderbreken bij de onderbreking.

## Retry met exponentiële backoff + jitter

Voor voorbijgaande fouten (timeouts, korte netwerkonderbrekingen, 503s), opnieuw proberen — maar **exponentieel teruggaan en jitter toevoegen** zodat retries zich verspreiden in plaats van synchroniseren in een 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
```

Belangrijke waarschuwingen:

- **Cap retries** — onbeperkte retries veroorzaken **retry storms** die een herstel service overbelasten.
- **Idempotency** — alleen opnieuw proberen bewerkingen die veilig kunnen worden herhaald (een opnieuw geprobeerde betaling mag niet twee keer in rekening worden gebracht).
- **Jitter** — zonder het, proberen alle clients op hetzelfde moment opnieuw en pieken de belasting opnieuw.

## Circuit breaker

Een circuit breaker houdt mislukkingen bij een afhankelijkheid bij en schakelt na een drempel **open** — snel mislukken (of een fallback retourneren) in plaats van een dode service aan te roepen. Na een cooldown gaat het **half-open** om herstel te controleren.

```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
```

## Wanneer elk van toepassing is

```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
```

## Waarom het belangrijk is

Zonder deze zaken sleurt een mislukte afhankelijkheid de beller met zich mee: verzoeken stapelen zich op bij timeouts, retries versterken de belasting, en het falen verspreidt zich over services. Exponentiële backoff met jitter herstelt van kleine storingen zonder een retry storm; capping en idempotency houden retries veilig; en de circuit breaker stopt met het verspillen van bronnen op een dode afhankelijkheid en geeft deze ruimte om te herstellen. Samen zetten zij een afhankelijkheidsuitval om in een begrepen, zelf-genezend gebeuren.