कौन से resilience पैटर्न माइक्रोसर्विसेज (circuit breaker, retry, timeout, bulkhead) की सुरक्षा करते हैं?

Question

Accepted Answer

एक distributed system में, **सब कुछ अंततः विफल हो जाता है**। Resilience पैटर्न एक एकल विफलता को पूर्ण आउटेज में फैलने से रोकते हैं।

## मुख्य पैटर्न

- **Timeout** — कभी भी किसी प्रतिक्रिया के लिए हमेशा इंतजार न करें।
- **Retry** — अस्थायी विफलताओं को पुनः प्रयास करें, backoff + jitter के साथ।
- **Circuit breaker** — विफल सेवा को कॉल करना बंद करें ताकि वह ठीक हो सके।
- **Bulkhead** — संसाधनों को अलग करें ताकि एक धीमी निर्भरता बाकी सब को डुबो न सके।

## Circuit breaker उदाहरण

```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 स्थिति

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

## नुकसान

**Backoff के बिना Retries** पहले से ही संघर्ष कर रही सेवा पर लोड बढ़ाते हैं (एक retry storm)। हमेशा backoff, jitter, और retry cap जोड़ें।

## यह क्यों महत्वपूर्ण है

ये पैटर्न एक अनिवार्य एकल-सेवा विफलता को साइट-व्यापी आउटेज के बजाय एक खराब सुविधा में बदल देते हैं।

ये एक साथ काम करते हैं: timeouts प्रतीक्षा को बाध्य करते हैं, circuit breakers मृत सेवाओं को हथौड़ा मारने से रोकते हैं, bulkheads विस्फोट त्रिज्या को रोकते हैं, और retries blips से पुनः प्राप्त करते हैं — एक को भी छोड़ें और विफलताएं अभी भी cascade होती हैं।