Redis ఉపయోగించి రేట్ లిమిటింగ్‌ను ఎలా అమలు చేయాలి?

Question

Accepted Answer

**రేట్ లిమిటింగ్** (ఒక సమయ విండోలో ఎంత requests/actions అనుమతించాలో పరిమితం చేయడం) ఒక సాధారణ Redis ఉపయోగ కేసు — Redis యొక్క వేగవంతమైన అటామిక్ కౌంటర్‌లు మరియు TTLలు దీనికి ఆదర్శమైనవి. అనేక అల్గారిథమ్‌లు ఉన్నాయి (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)కు అటామిక్ కౌంటర్ TTLతో — ప్రతి request కోసం increment చేయండి, limit కంటే ఎక్కువైనప్పుడు reject చేయండి. సరళమైనది మరియు సమర్థవంతమైనది, అటామిక్ `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 ఉపయోగించి రేట్ లిమిటింగ్‌ను అమలు చేయడం ఒక సాధారణ, ఆచరణాత్మక ఉపయోగ కేసు, కాబట్టి దీనిని అర్థం చేసుకోవడం విలువైన జ్ఞానం — రేట్ లిమిటింగ్ (APIs మరియు సేవలను남용నుండి రక్షించడం, న్యాయమైన ఉపయోగం నিఇచ్చడం, ఓవర‌లోడ్ నిరోధించడం) దాదాపు సార్వత్రిక అవసరం, మరియు Redis దీనికి ప్రామాణిక సాధనం.

**Redis ఎందుకు ఆదర్శమైనది** అర్థం చేసుకోవడం కీలకం: దీని **అటామిక్ కౌంటర్‌లు** (`INCR`) రేట్ కౌంటింగ్‌ను సమకాలీనత కింద సరైనవిగా చేస్తాయి (race conditions/lost counts లేకుండా), దీని **వేగం** (in-memory) ప్రతి requestకు కనిష్ఠ latency జోడిస్తుంది, **TTLలు** విండో cleanup ను స్వయంచాలకంగా నిర్వహిస్తాయి, మరియు కీలకంగా ఇది **సర్వర్‌ల అంతటా సంస్కరించబడుతుంది** — **విభిన్న రేట్ లిమిటింగ్** ఎందుకంటే అన్ని application servers ఒక సంపూర్ణ సరిహద్దు (multi-server deployments లో అత్యవసరం, ఇక్కడ per-server in-memory limits పనిచేయవు).

**అల్గారిథమ్‌లు** మరియు వాటి ట్రేడ్‌ఆఫ్‌ల అర్థం చేసుకోవడం సరిగ్గా ఎంచుకోవడానికి అనుమతిస్తుంది: **fixed window** (సరళమైనది — ప్రతి time-window కు అటామిక్ కౌంటర్ TTLతో, కానీ boundary bursts అనుమతిస్తుంది), **sliding window** (మరింద మృదువైనది మరియు సరిగ్గా ఉన్నది timestamped requestల sorted set ఉపయోగించి, ఎక్కువ memory cost వద్ద), మరియు **token bucket** (సగటు రేట్ పరిమితం చేస్తూ నియంత్రిత bursts అనుమతిస్తుంది, తరచుగా atomicity కోసం Lua script ద్వారా).

ఇవిధంగా అమలు చేయడం (ముఖ్యంగా సరళమైన, సాధారణ fixed-window నమూనా `INCR` + `EXPIRE`తో) ఆచరణాత్మక, వర్తించే నైపుణ్యం.