Pija carane nglakokake rate limiting karo Redis?

Question

Accepted Answer

**Rate limiting** (matesi pirang request/aksi sing diidini ing jangka wektu) minangka use case Redis sing umum — kacepetane Redis ing atomic counters lan TTL ndadekake dadi ideal. Sawetara algoritma ana (fixed window, sliding window, token bucket), saben duwe trade-offs.

## Fixed window (paling sederhana)

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

Pendekatan **fixed window**: atomic counter per (user, time-window) karo TTL — naik per request, nolak nalika luwih saka batas. Prasaja lan efisien, ngungkuli atomic `INCR` lan auto-expiry.

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

## Sliding window (luwih lembut)

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

## Kenapa Redis ideal kanggo iki

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

## Mengapa penting

Nglakokake rate limiting karo Redis minangka use case umum lan praktis, mula mangerti iku pengetahuan sing berharga — rate limiting (nglindhungi API lan layanan saka penyalahgunaan, niyatake panggunaan sing adil, nyegah beban berlebihan) minangka kabutuhan sing meh universal, lan Redis minangka alat standar kanggo iku.

Mangerti **mengapa Redis ideal** minangka kunci: **atomic counters** (`INCR`) ndadekake penghitungan rate leres ing ngisor konkurensi (ora ana race conditions/hilang counts), **kacepetane** (in-memory) nambahe latency minimal ing saben request, **TTL** nangani pembersihan window kanthi otomatis, lan penting banget iku **dibagekake njalari server** — ngidini **distributed rate limiting** ing endi kabeh application server nglakokake siji batas konsisten (penting ing multi-server deployments, ing endi per-server in-memory limits ora bisa akeh).

Mangerti **algoritma** lan trade-offs ndadekake sampeyan bisa pilih kanthi pas: **fixed window** (paling sederhana — atomic counter per time-window karo TTL, nanging ngidini boundary bursts), **sliding window** (luwih lembut lan akurat nggunakake sorted set saka timestamped requests, ing biaya memory sing luwih dhuwur), lan **token bucket** (ngidini controlled bursts nalika matesi rate rata-rata, asring liwat Lua script kanggo atomicity).

Mangerti carane nglakokake iki (utamane pola fixed-window sing prasaja lan umum karo `INCR` + `EXPIRE`) minangka skill praktis lan bisa diterapake.

Amarga rate limiting minangka kabutuhan umum kanggo nglindhungi layanan, lan amarga Redis (karo atomic counters, kacepetan, TTL, lan cross-server sharing) minangka alat standar lan ideal kanggo distributed rate limiting, mangerti carane nglakokake karo Redis — algoritma, trade-offs, lan mengapa Redis pas — minangka pengetahuan sing berharga lan asring diterapake kanggo mbangun layanan sing kuwat lan dilindungi, salah siji aplikasi praktis Redis sing paling umum adhedhasar caching.