Vilka resiliensmönster skyddar mikroservices (circuit breaker, retry, timeout, bulkhead)?

Question

Accepted Answer

I ett distribuerat system **misslyckas allting så småningom**. Resiliensmönster förhindrar att ett enda fel kaskadar in i ett totalt driftstopp.

## Kärnmönstren

- **Timeout** — vänta aldrig för alltid på ett svar.
- **Retry** — försök igen övergående fel, med backoff + jitter.
- **Circuit breaker** — sluta anropa en felande tjänst för att låta den återhämta sig.
- **Bulkhead** — isolera resurser så att ett långsamt beroende inte kan dränka resten.

## Circuit breaker-exempel

```js
const breaker = new CircuitBreaker(callPaymentService, {
  timeout: 3000,                 // fail the call after 3s
  errorThresholdPercentage: 50,  // open if >50% of calls fail
  resetTimeout: 10000            // after 10s, try one request (half-open)
});
breaker.fallback(() => ({ status: 'queued' })); // graceful degradation
```

## Circuit breaker-tillstånd

```text
CLOSED ──(failures exceed threshold)──▶ OPEN
  ▲                                       │ (after resetTimeout)
  │ (trial succeeds)                       ▼
  └────────────── HALF-OPEN ◀──────────────┘
                (one trial request)
```

## Bulkhead

```text
[ pool A: 10 threads ]  → payment calls
[ pool B: 10 threads ]  → search calls
If search hangs, it drains pool B only — payments keep working.
```

## Fallgrop

**Försök igen utan backoff** förstärker belastningen på en redan kämpande tjänst (en retry-storm). Lägg alltid till backoff, jitter och ett retry-tak.

## Varför det är viktigt

Dessa mönster är vad som förvandlar ett oundvikligt fel i en tjänst till en försämrad funktion i stället för ett totalfel på webbplatsen.

De fungerar tillsammans: timeout begränsar väntetiden, circuit breaker stoppar att hamra döda tjänster, bulkhead begränsar sprängradien, och retry återhämtar sig från korta avbrott — utelämna någon och fel kaskadar fortfarande.