Distributed systems ਵਿੱਚ circuit breakers ਅਤੇ backoff ਦੇ ਨਾਲ retries ਕਿਵੇਂ ਕੰਮ ਕਰਦੇ ਹਨ?

Question

Accepted Answer

Distributed systems ਵਿੱਚ, ਕਾਲਾਂ ਅਸਫਲ ਹੋ ਜਾਂਦੀਆਂ ਹਨ। **Backoff ਦੇ ਨਾਲ Retries** *ਅਸਥਾਈ* ਗਲਤੀਆਂ ਤੋਂ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਨ; ਇੱਕ **circuit breaker** ਤੁਹਾਨੂੰ ਇੱਕ ਨਿਰਭਰਤਾ ਜੋ ਸੱਚਮੁੱਚ *ਹੇਠਲੀ* ਹੈ, ਨੂੰ ਹਥੌੜਾ ਮਾਰਨ ਤੋਂ ਬਚਾਉਂਦਾ ਹੈ। ਉਹ ਪੂਰਕ ਹਨ: blip ਨੂੰ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰੋ, outage ਤੋਂ ਬ੍ਰੇਕ ਕਰੋ।

## Exponential backoff + jitter ਦੇ ਨਾਲ Retry

ਅਸਥਾਈ ਅਸਫਲਤਾ ਲਈ (timeouts, ਸੰਖੇਪ ਨੈੱਟਵਰਕ blips, 503s), ਮੁੜ ਕੋਸ਼ਿਸ਼ ਕਰੋ — ਪਰ **exponentially back off ਕਰੋ ਅਤੇ jitter ਜੋੜੋ** ਤਾਂ ਜੋ retries ਇੱਕ thundering herd ਵਿੱਚ ਸਿੰਕਰੋਨਾਈਜ਼ ਹੋਣ ਦੀ ਬਜਾਏ ਫੈਲ ਜਾਣ।

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

ਮੁੱਖ ਸਾਵਧਾਨੀਆਂ:

- **Cap retries** — unbounded retries ਇੱਕ ਪ੍ਰਾਪਤ ਕਰਨ ਵਾਲੀ ਸੇਵਾ ਨੂੰ **retry storms** ਓਵਰਲੋਡ ਕਰਦੇ ਹਨ।
- **Idempotency** — ਸਿਰਫ਼ ਉਹ ਕਾਰਜ ਮੁੜ ਕੋਸ਼ਿਸ਼ ਕਰੋ ਜੋ ਦੁਹਰਾਉਣ ਲਈ ਸੁਰੱਖਿਅਤ ਹਨ (ਇੱਕ ਮੁੜ ਕੋਸ਼ਿਸ਼ ਕੀਤਾ ਭੁਗਤਾਨ ਦੁ ਵਾਰ ਚਾਰਜ ਨਹੀਂ ਕਰਨਾ ਚਾਹੀਦਾ)।
- **Jitter** — ਇਸ ਤੋਂ ਬਿਨਾਂ, ਸਾਰੇ ਕਲਾਇੰਟ ਇੱਕੋ ਸਮੇਂ ਮੁੜ ਕੋਸ਼ਿਸ਼ ਕਰਦੇ ਹਨ ਅਤੇ ਲੋਡ ਨੂੰ ਮੁੜ-ਸਪਾਈਕ ਕਰਦੇ ਹਨ।

## Circuit breaker

ਇੱਕ circuit breaker ਇੱਕ ਨਿਰਭਰਤਾ ਵਿੱਚ ਅਸਫਲਤਾਵਾਂ ਨੂੰ ਟ੍ਰੈਕ ਕਰਦਾ ਹੈ ਅਤੇ, ਇੱਕ ਥ੍ਰੈਸ਼ਹੋਲਡ ਦੇ ਬਾਅਦ, **trips open** — fast ਅਸਫਲ (ਜਾਂ ਇੱਕ fallback ਵਾਪਸ ਕਰ) ਇੱਕ ਮਰੇ ਹੋਏ ਸੇਵਾ ਨੂੰ ਕਾਲ ਕਰਨ ਦੀ ਬਜਾਏ। ਇੱਕ cooldown ਦੇ ਬਾਅਦ ਇਹ **half-open** ਜਾਂਚ ਰਿਕਵਰੀ ਕਰਨ ਲਈ ਜਾਂਦਾ ਹੈ।

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

## ਜਦੋਂ ਹਰ ਲਾਗੂ ਹੁੰਦਾ ਹੈ

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

## ਇਹ ਮਾਇਨੇ ਕਿਉਂ ਰੱਖਦਾ ਹੈ

ਇਨ੍ਹਾਂ ਤੋਂ ਬਿਨਾਂ, ਇੱਕ ਅਸਫਲ ਨਿਰਭਰਤਾ ਕਾਲ ਕਰਨ ਵਾਲੇ ਨੂੰ ਇਸ ਦੇ ਨਾਲ ਹੇਠ ਲੈ ਜਾਂਦੀ ਹੈ: requests timeouts ਉੱਤੇ ਪਾਈਲ ਹੋ ਜਾਂਦੇ ਹਨ, retries ਲੋਡ ਨੂੰ ਵਧਾਉਂਦੇ ਹਨ, ਅਤੇ ਅਸਫਲਤਾ ਸੇਵਾਵਾਂ ਵਿੱਚ cascade ਹੋ ਜਾਂਦੀ ਹੈ। Exponential backoff with jitter ਇੱਕ retry storm ਤੋਂ ਬਿਨਾਂ blips ਤੋਂ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ; capping ਅਤੇ idempotency retries ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਦੇ ਹਨ; ਅਤੇ circuit breaker ਇੱਕ ਮਰੇ ਹੋਏ ਨਿਰਭਰਤਾ ਉੱਤੇ ਸਰੋਤ ਬਰਬਾਦ ਕਰਨ ਤੋਂ ਰੋਕਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਮੁੜ ਸੁਸਥ ਕਰਨ ਲਈ ਥਾਂ ਦਿੰਦਾ ਹੈ। ਇਕੱਠੇ ਉਹ ਇੱਕ ਨਿਰਭਰਤਾ ਅਸਫਲਤਾ ਨੂੰ ਇੱਕ contained, self-healing event ਵਿੱਚ ਬਦਲ ਦਿੰਦੇ ਹਨ।