माइक्रोसर्भिसहरू कुन लचिलोपन ढाँचाहरूद्वारा सुरक्षित हुन्छन् (circuit breaker, retry, timeout, bulkhead)?

Question

Accepted Answer

वितरित प्रणालीमा, **सबै कुरा अन्ततः असफल हुन्छ**। लचिलोपन ढाँचाहरूले एकल असफलतालाई पूर्ण विघ्नमा फैलिनबाट रोक्छन्।

## मूल ढाँचाहरू

- **Timeout** — कहिले पनि प्रतिक्रियाको लागि सदैव प्रतीक्षा गर्नुहोस्।
- **Retry** — transient असफलताहरू पुन: प्रयास गर्नुहोस्, 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 क्याप जोड्नुहोस्।

## यो किन महत्त्वपूर्ण छ

यी ढाँचाहरू अनिवार्य एकल-सेवा असफलतालाई साइट-व्यापी विघ्नको सट्टामा एक अवनत विशेषतामा परिणत गर्छन्।

तिनीहरू एकसाथ काम गर्छन्: timeouts प्रतीक्षा बाउन्ड गर्छन्, circuit breakers मृत सेवाहरूलाई हथौड़ा गर्नबाट रोक्छन्, bulkheads blast radius समावेश गर्छन्, र retries blips बाट पुनरुद्धार गर्छन् — कुनै पनि एक हटाउनु हुँदैन र असफलताहरू अझै पनि फैलिन्छन्।