आप Redis के साथ rate limiting कैसे implement करते हैं?

Question

Accepted Answer

**Rate limiting** (एक time window में कितने requests/actions की अनुमति है, इसे सीमित करना) Redis का एक आम use case है — Redis के तेज़ atomic counters और TTLs इसे आदर्श बनाते हैं। कई algorithms मौजूद हैं (fixed window, sliding window, token bucket), जिनमें से हर एक के अपने trade-offs हैं।

## Fixed window (सबसे सरल)

```js
// allow N requests per time window using an atomic counter with a TTL
async function rateLimit(userId, limit = 100, windowSec = 60) {
  const key = `rate:${userId}:${Math.floor(Date.now() / 1000 / windowSec)}`;
  const count = await redis.incr(key);     // atomic increment
  if (count === 1) await redis.expire(key, windowSec);  // set TTL on first request
  return count <= limit;                    // allowed if under the limit
}
// → INCR is atomic (correct under concurrency); the key auto-expires each window
```

**Fixed window** approach: प्रति (user, time-window) एक atomic counter जिसमें TTL हो — प्रति request increment करें, limit से अधिक होने पर reject करें। सरल और efficient, atomic `INCR` और auto-expiry का लाभ उठाते हुए।

```text
✗ Limitation: bursts at window boundaries (2x limit possible across two adjacent windows)
```

## Sliding window (अधिक smooth)

```text
SLIDING WINDOW → tracks requests over a rolling time period (no boundary bursts)
  → often uses a SORTED SET: add each request with a timestamp score,
    remove old entries (ZREMRANGEBYSCORE), count remaining (ZCARD)
  ✓ More accurate/smooth  ✗ More memory and complexity
```

## Token bucket (नियंत्रित bursts की अनुमति देता है)

```text
TOKEN BUCKET → tokens refill at a steady rate; each request consumes a token
  → allows bursts (up to the bucket size) while limiting the average rate
  → often implemented with a Lua SCRIPT for atomic check-and-consume
```

## Redis इसके लिए आदर्श क्यों है

```text
✓ ATOMIC counters (INCR) → correct under concurrency, no race conditions
✓ Fast (in-memory) → minimal latency added to each request
✓ TTL → automatic window cleanup (no manual expiry management)
✓ SHARED across servers → distributed rate limiting (all app servers use one Redis)
→ Redis is the standard tool for distributed rate limiting.
```

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

Redis के साथ rate limiting implement करना एक आम, व्यावहारिक use case है, इसलिए इसे समझना मूल्यवान ज्ञान है — rate limiting (APIs और services को abuse से बचाना, उचित usage सुनिश्चित करना, overload रोकना) एक लगभग सार्वभौमिक आवश्यकता है, और Redis इसके लिए standard tool है।

**Redis क्यों आदर्श है** यह समझना महत्वपूर्ण है: इसके **atomic counters** (`INCR`) rate counting को concurrency के तहत सही बनाते हैं (कोई race conditions/lost counts नहीं), इसकी **speed** (in-memory) प्रत्येक request में न्यूनतम latency जोड़ती है, **TTLs** window cleanup को स्वचालित रूप से संभालते हैं, और महत्वपूर्ण रूप से यह **servers के बीच shared** है — जो **distributed rate limiting** को सक्षम बनाता है जहाँ सभी application servers एक सुसंगत limit लागू करते हैं (multi-server deployments में आवश्यक, जहाँ per-server in-memory limits काम नहीं करेंगी)।

**Algorithms** और उनके trade-offs को समझने से आप उपयुक्त रूप से चुन सकते हैं: **fixed window** (सबसे सरल — प्रति time-window एक atomic counter जिसमें TTL हो, लेकिन boundary bursts की अनुमति देता है), **sliding window** (timestamped requests के sorted set का उपयोग करके अधिक smooth और सटीक, अधिक memory cost पर), और **token bucket** (average rate को सीमित करते हुए नियंत्रित bursts की अनुमति, अक्सर atomicity के लिए Lua script के माध्यम से)।

इन्हें कैसे implement किया जाए यह जानना (विशेषकर सरल, आम fixed-window pattern जिसमें `INCR` + `EXPIRE` हो) एक व्यावहारिक, लागू करने योग्य skill है।

चूँकि rate limiting services की सुरक्षा के लिए एक आम आवश्यकता है, और चूँकि Redis (अपने atomic counters, speed, TTLs, और cross-server sharing के साथ) distributed rate limiting के लिए standard, आदर्श tool है, Redis के साथ इसे implement करना कैसे समझना — algorithms, उनके trade-offs, और Redis इतना अच्छा क्यों fit होता है — robust, protected services बनाने के लिए मूल्यवान, बार-बार लागू होने योग्य ज्ञान है, जो caching से परे सबसे आम व्यावहारिक Redis applications में से एक है।