आप Redis सह rate limiting कसे लागू करता?

Question

Accepted Answer

**Rate limiting** (विनिर्दिष्ट काळाच्या खिडकीत किती विनंत्या/क्रिया अनुमत आहेत हे प्रतिबंधित करणे) हा Redis चा सामान्य use case आहे — Redis चे जलद atomic counters आणि TTLs यामुळे हे आदर्श आहे. अनेक अल्गोरिदम अस्तित्वात आहेत (fixed window, sliding window, token bucket), प्रत्येकाचे फायदे-तोटे आहेत.

## 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** दृष्टिकोन: (user, time-window) प्रति atomic counter जिथे TTL आहे — प्रत्येक विनंतीसाठी increment करा, मर्यादा ओलांडल्यास reject करा. सोपे आणि कार्यक्षम, atomic `INCR` आणि auto-expiry चा लाभ घेऊन.

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

## Sliding window (अधिक गुळगुळीत)

```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 लागू करणे हा सामान्य, व्यावहारिक use case आहे, म्हणून याचे समजून घेणे हे मूल्यवान ज्ञान आहे — rate limiting (APIs आणि services ला दुर्व्यवहारापासून संरक्षित करणे, न्याय्य वापरास सुनिश्चित करणे, अधिभारापासून रोखणे) हे जवळजवळ सार्वत्रिक गरज आहे, आणि Redis हे त्यासाठी मानक साधन आहे.

**Redis हे का आदर्श आहे** हे समजून घेणे हे महत्त्वाचे आहे: त्यचे **atomic counters** (`INCR`) rate counting ला समवर्तिता अंतर्गत (कोणतीही race conditions/lost counts नसून) योग्य बनवते, त्यचा **गती** (in-memory) प्रत्येक विनंतीला किमान latency जोडते, **TTLs** window cleanup स्वयंचलितपणे हाताळते, आणि महत्त्वाचे म्हणून हे **सर्व servers मध्ये सामायिक** आहे — **distributed rate limiting** सक्षम करते जेथे सर्व application servers एक सुसंगत मर्यादा लागू करते (multi-server deployments मध्ये आवश्यक, जेथे per-server in-memory मर्यादा काम करणार नाहीत).

**अल्गोरिदम** आणि त्यांचे trade-offs समजून घेणे तुम्हाला योग्यरीत्या निवडण्यास सक्षम करते: **fixed window** (सर्वात सोपे — टाइम-विंडो प्रति atomic counter जिथे TTL आहे, परंतु boundary bursts अनुमत करते), **sliding window** (गुळगुळीत आणि अधिक अचूक timestamped requests च्या sorted set वापरून, उच्च memory cost वर), आणि **token bucket** (नियंत्रित bursts अनुमत करते तर सरासरी दर मर्यादित करते, अनेकदा atomicity साठी Lua script द्वारे).

हे कसे लागू करायचे हे जाणून घेणे (विशेषतः सोपा, सामान्य fixed-window pattern जो `INCR` + `EXPIRE` सह आहे) हे व्यावहारिक, लागू करण्यायोग्य कौशल्य आहे.

Rate limiting हे services संरक्षित करण्यासाठी सामान्य आवश्यकता असल्याने, आणि Redis (त्यचे atomic counters, गती, TTLs, आणि cross-server sharing सह) distributed rate limiting साठी मानक, आदर्श साधन असल्याने, Redis सह rate limiting कसे लागू करायचे हे समजून घेणे — अल्गोरिदम, त्यांचे trade-offs, आणि Redis हे का इतके योग्य आहे — हे मूल्यवान, वारंवार लागू करण्यायोग्य ज्ञान आहे robust, संरक्षित services तयार करण्यासाठी, caching व्यतिरिक्त Redis चे सर्वात सामान्य व्यावहारिक अनुप्रयोग.