Hur fungerar circuit breakers och retries med backoff i distribuerade system?

Question

Accepted Answer

I distribuerade system misslyckas anrop. **Retries med backoff** återställer från *tillfälliga* fel; en **circuit breaker** hindrar dig från att bombardera ett beroende som verkligen är *nere*. De är komplementära: försök igen när det är en blip, bryt när det är ett avbrott.

## Retry med exponentiell backoff + jitter

För tillfälliga fel (timeouts, kortare nätverksstörningar, 503:or), försök igen — men **backa av exponentiellt och lägg till jitter** så att försöken sprids ut istället för att synkroniseras till en vildsint skara.

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

Viktiga varningar:

- **Begränsa retries** — obegränsade retries skapar **retry storms** som överbelastar en återhämtande tjänst.
- **Idempotens** — försök bara igen operationer som är säkra att upprepa (ett försökt försök att betala får inte debitera två gånger).
- **Jitter** — utan det försöker alla klienter på samma sekund och skapar en ny belastningstoppar.

## Circuit breaker

En circuit breaker spårar fel på ett beroende och, efter en gräns, **öppnas** — misslyckas snabbt (eller returnerar ett fallback) istället för att anropa en död tjänst. Efter en nedkylning går den till **half-open** för att testa återhämtning.

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

## När varje gäller

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

## Varför det är viktigt

Utan dessa tar ett misslyckat beroende den som ringer med sig: förfrågningar ansamlas vid timeouts, retries förstärker belastningen och felet kaskaderas över tjänster. Exponentiell backoff med jitter återhämtar sig från blips utan en retry storm; begränsning och idempotens gör retries säkra; och circuit breakern slutar slösa resurser på ett dödt beroende och ger det utrymme att återhämta sig. Tillsammans förvandlar de ett beroende fel till en innesluten, självreparerande händelse.