distributed systems-ல் circuit breakers மற்றும் backoff உடன் retries எப்படி வேலை செய்கிறது?

Question

Accepted Answer

Distributed systems-ல், calls fail செய்கிறது. **Retries with backoff** *transient* errors-லிருந்து recover செய்கிறது; **circuit breaker** genuinely *down* இருக்கும் ஒரு dependency-ஐ hammer செய்வதிலிருந்து உன்னைத் தடுக்கிறது. அவை complementary: blip-ஐ retry செய், outage-ல் break செய்.

## Retry with exponential backoff + jitter

Transient failures (timeouts, brief network blips, 503s)-க்கு, retry செய் — ஆனால் **exponentially back off செய்து jitter add செய்** அதனால் retries synchronize ஆகாமல் spread ஆகும் 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
```

Key cautions:

- **Cap retries** — unbounded retries **retry storms** உருவாக்கும் அவை recovering service-ஐ overload செய்கிறது.
- **Idempotency** — safe-ஆக repeat செய்யக்கூடிய operations-ஐ மட்டுமே retry செய் (ஒரு retried payment இரண்டு முறை charge செய்யக்கூடாது).
- **Jitter** — அதில்லாமல், அனைத்து clients ஒரே instant-ல் retry செய்துவிடுகிறது மற்றும் load-ஐ re-spike செய்கிறது.

## Circuit breaker

ஒரு circuit breaker ஒரு dependency-க்கு failures track செய்கிறது மற்றும், ஒரு threshold-ற்குப் பிறகு, **trips open** செய்கிறது — fast fail (அல்லது ஒரு fallback return) செய்து dead service-ஐ call செய்வதற்கு பதிலாக. Cooldown-ற்குப் பிறகு அது **half-open** ஆகிறது recovery-ஐ probe செய்ய.

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

## ஏன் அது முக்கியமானது

இவற்றில்லாமல், ஒரு failing dependency caller-ஐ அதனுடன் கீழே கொண்டு செல்கிறது: requests timeouts-ல் pile up, retries load-ஐ amplify செய்து, அந்த failure services-ல் cascade செய்கிறது. Exponential backoff with jitter blips-லிருந்து recover செய்கிறது retry storm-ஐ இல்லாமல்; capping மற்றும் idempotency retries-ஐ safe வைக்கிறது; மற்றும் circuit breaker dead dependency-ல் resources-ஐ வீணாவதை தடுக்கிறது மற்றும் recovery-க்கு அதற்கு room கொடுக்கிறது. Together அவை ஒரு dependency failure-ஐ contained, self-healing event-ஆக மாற்றுகிறது.