Welke resilience-patronen beschermen microservices (circuit breaker, retry, timeout, bulkhead)?

Question

Accepted Answer

In een gedistribueerd systeem **faalt alles uiteindelijk**. Resilience-patronen voorkomen dat een enkele fout zich uitbreidt tot een volledige storing.

## De kernpatronen

- **Timeout** — wacht nooit voor altijd op een respons.
- **Retry** — probeer voorbijgaande fouten opnieuw, met backoff + jitter.
- **Circuit breaker** — stop met het aanroepen van een falende service om deze herstel toe te staan.
- **Bulkhead** — isoleer resources zodat één trage afhankelijkheid de rest niet kan overbelasten.

## Circuit breaker voorbeeld

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

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

## Valkuil

**Retries zonder backoff** vergroten de belasting op een al overbelaste service (een retry storm). Voeg altijd backoff, jitter en een retry-limiet toe.

## Waarom het belangrijk is

Deze patronen transformeren een onvermijdelijke fout van één service in een verslechterde functie in plaats van een storing op sitebreedte.

Ze werken samen: timeouts beperken wachttijden, circuit breakers voorkomen dat slechte services worden bestookt, bulkheads beperken de effectomvang, en retries herstellen zich van kleine storing — laat er één achterwege en storingen verspreiden zich nog steeds.