Kif timplimenta rate limiting bil-Redis?

Question

Accepted Answer

**Rate limiting** (ir-restrizzjoni ta' kemm il-postijiet/azzjonijiet huma permessi f'window ta' ħin) huwa use case komuni tal-Redis — il-kontaturi atomiċi veloċi tal-Redis u t-TTLs jagħmluha ideali. Hemm algoritmi differenti (fixed window, sliding window, token bucket), kull waħda b'trade-offs.

## Fixed window (l-iktar sempliċi)

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

L-approċċ ta' **fixed window**: kontatur atomic per (user, time-window) b'TTL — inkrement għal kull request, irrifjuta meta tkun fuq il-limit. Sempliċi u effiċjenti, leveraging atomic `INCR` u auto-expiry.

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

## Sliding window (aktar 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 (jippermetti controlled 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
```

## Għaliex Redis huwa ideali għal dan

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

## Għaliex huwa importanti

L-implimentazzjoni ta' rate limiting bil-Redis huwa use case komuni u prattiku, għalhekk il-fehim tiegħu huwa għarfien validu — rate limiting (il-protezzjoni ta' APIs u servizzi mill-abbuż, li tiżgura l-użu ġust, li tipprevjeni l-overload) huwa bżonn kważi universali, u Redis huwa l-għodda standard għaliha.
/* il-fehim ta' **għaliex Redis huwa ideali** huwa essenzjali: il-**kontaturi atomiċi** tiegħu (`INCR`) jagħmlu r-rate counting korrett taħt concurrency (l-ebda race conditions/lost counts), il-**veloċità** tiegħu (in-memory) iżżid latency minimali għal kull request, **TTLs** jimmaniġġjaw il-window cleanup awtomatikament, u ċrucjalment huwa **shared across servers** — li jippermettu **distributed rate limiting** fejn il-servers tal-applikazzjoni kollha jonforzaw limitu wieħed konsistenti (essenzjali f'multi-server deployments, fejn il-limits in-memory per-server ma kienu jaħdmu).
/* il-fehim tal-**algoritmi** u t-trade-offs tagħhom jippermettulek tagħżel xierqa: **fixed window** (l-iktar sempliċi — kontatur atomic għal kull time-window b'TTL, iżda jippermetti boundary bursts), **sliding window** (aktar smooth u aktar eżatt bl-użu ta' sorted set ta' timestamped requests, b'kost ta' memoria ogħla), u **token bucket** (li jippermetti controlled bursts filwaqt li jillimita l-average rate, ħafna drabi via Lua script għall-atomicity).
/* il-għarfien ta' kif timplimenta dawn (speċjalment il-pattern sempliċi u komuni tal-fixed-window bl-`INCR` + `EXPIRE`) huwa skill praktiku u applikabbli.
/** Billi rate limiting huwa rekwiżit komuni għall-protezzjoni ta' servizzi, u billi Redis (b'il-kontaturi atomiċi tiegħu, il-veloċità, TTLs, u cross-server sharing) huwa l-għodda standard u ideali għall-distributed rate limiting, il-fehim ta' kif timplimenta dan bil-Redis — l-algoritmi, it-trade-offs tagħhom, u għaliex Redis jirriżulta tajjeb — huwa għarfien validu u applikabbli ta' ħafna drabi għall-bini ta' servizzi robust u protetti, waħda mill-iktar applikazzjonijiet prattici komuni tal-Redis lil hinn mill-caching.