Redis உடன் rate limiting ஐ எவ்வாறு செயல்படுத்துவீர்கள்?

Question

Accepted Answer

**Rate limiting** (ஒரு நேர கண்ணாடியில் எத்தனை requests/actions அனுமதிக்கப்படுகிறது என்பதைக் கட்டுப்படுத்துதல்) என்பது Redis இன் பொதுவான பயன்பாடு — 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
```

The **fixed window** approach: atomic counter per (user, time-window) with a TTL — increment per request, reject when over the limit. Simple and efficient, leveraging atomic `INCR` and 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 ஐ செயல்படுத்துவது ஒரு பொதுவான, நடைமுறை பயன்பாடு, எனவே இதைப் புரிந்துகொள்வது மূல்யமான அறிவு — rate limiting (APIs மற்றும் services ஐ दुरुपयोग से பாதுகாத்தல், நியாய பயன்பாடு உறுதி செய்தல், overload தடுத்தல்) ஒரு near-universal தேவை, மற்றும் Redis இது தற்குத் தரமான tool.

Redis ஏன் சிறந்தது என்பதைப் புரிந்துகொள்வது முக்கியம்: அதன் **atomic counters** (`INCR`) concurrency இல் rate counting சரியாக செய்கிறது (race conditions/lost counts இல்லை), அதன் **speed** (in-memory) ஒவ்வொரு request க்கும் minimal latency சேர்க்கிறது, **TTLs** window cleanup தானாகவே கையாளுகிறது, மற்றும் முக்கியமாக இது **servers முழுவதும் பகிரப்பட்டது** — enabling **distributed rate limiting** எங்கு அனைத்து application servers ஒரு일관된 limit enforce செய்கிறது (essential in multi-server deployments, அங்கு per-server in-memory limits வேலை செய்யாது).

**Algorithms** மற்றும் அவற்றின் trade-offs ஐ புரிந்துகொள்வது உங்களை appropriately தேர்வு செய்ய அனுமதிக்கிறது: **fixed window** (எளிமையான — atomic counter per time-window with a TTL, ஆனால் boundary bursts அனுமதிக்கிறது), **sliding window** (மென்மையான மற்றும் கூடுதல் நம்பிக்கையான sorted set of timestamped requests பயன்படுத்தி, அதிக memory cost இல்), மற்றும் **token bucket** (கட்டுப்படுத்தப்பட்ட bursts அனுமதிக்கிறது average rate limiting இல், பெரும்பாலும் Lua script வழியாக atomicity க்கு).

இவற்றை செயல்படுத்த எவ்வாறு தெரிந்துகொள்வது (குறிப்பாக simple, common fixed-window pattern with `INCR` + `EXPIRE`) நடைமுறை, applicable skill.

Rate limiting ஒரு பொதுவான தேவை services பாதுகாக்க, மற்றும் Redis (atomic counters, speed, TTLs, மற்றும் cross-server sharing உடன்) distributed rate limiting க்கு தரமான, ideal tool என்பதால், Redis உடன் இதை செயல்படுத்த எவ்வாறு தெரிந்துகொள்வது — algorithms, அவற்றின் trade-offs, மற்றும் Redis ஏன் கொடுக்கும் — valuable, frequently-applicable knowledge robust, protected services கட்டுவதற்கு, caching தவிர most common practical Redis applications ல் ஒன்று.