Yaya kuke aiwatar da iyakacin ɗarɓe tare da Redis?

Question

Accepted Answer

**Iyakacin ɗarɓe** (iyakance nawa bubuwa/ayyuka da aka ba da izini a lokacin) shine abin da ake amfani da shi da Redis - saurin ɗarɓe na Redis da TTLs suna dace sosai. Algorithms da dama sun wanzu (gida na kafa, gida mai zumudi, jaka na ɗaba), kowanne yana da abubuwa da aka gano.

## Gida na kafa (mafi sauƙ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
```

**Gida na kafa** hanya: atomic counter gida ga (mai amfani, gida lokacin) tare da TTL — kari sau da sau bubuwa, ƙi lokacin da aka wuce iyaka. Sauƙi da kusuri, suna amfani da atomic `INCR` da auto-expiry.

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

## Gida mai zumudi (mafi kyau)

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

## Jaka na ɗaba (yana ba da damar kulli da kulli)

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

## Yagwan Redis ya dace ga wannan

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

## Yagwan haka ya cancanta

Aiwatarwa iyakacin ɗarɓe tare da Redis shine abin da ake amfani da shi a yau-yau, aiki na amfani, saboda haka gane shi yana da mahimmanci - iyakacin ɗarɓe (kariya APIs da ayyuka daga ware, tabbatar da gida amfani, kawar da cukuki) shine buhuwa da ba san ƙarfi - kuma Redis shine kayan saita don haka.
"];Gane **yagwan Redis ya dace** yana da mahimmanci: **atomic counters** tasa (`INCR`) suna dace karanta a ƙarƙashin tawowa (babu guguwar aiki/karfi da aka rasa), **saurin** tasa (a cikin ajiya) yana ƙari kaɗan latency zuwa kowane bubuwa, **TTLs** suna daidaita gida tsaftsa ta otomatik, kuma mahimmanci **shareware a jiya servers** — yana ba da damar **yayyaddar iyakacin ɗarɓe** inda duk software servers suna aiwatar iyaka gida mai jiya (mahimmanci a yayyaddar servers, inda kura ajiya iyaka ba zai aiki ba).

Gane **algorithms** da su gano trade-offs yana ba da damar ka zaɓi da gida: **gida na kafa** (mafi sauƙi — atomic counter gida ga gida lokacin tare da TTL, amma ba da damar guguwar iyaka), **gida mai zumudi** (mafi kyau kuma mafi daidai suna amfani da tsarin ajiya na ɗaba na bubuwa da saman lokaci, a karɓa ajiya mahimmanci), kuma **jaka na ɗaba** (yana ba da damar kulli da kulli yayin kawar da average ɗarɓe, sau da sau ta Lua rubuce don atomicity).

Sanin yaya za mu aiwata waɗannan (lallai mafi sauƙi, common gida na kafa tsarin tare da `INCR` + `EXPIRE`) shine aiki na amfani.

Tun da iyakacin ɗarɓe shine buhuwa ta kowa domin kariya ayyuka, kuma tun da Redis (tare da su atomic counters, saurin, TTLs, kuma yayyaddar shares) shine saita, cikakke kayan domin yayyaddar iyakacin ɗarɓe, gane yaya za mu aiwata shi tare da Redis — algorithms, su gano trade-offs, kuma yagwan Redis ya dace — shine mahimmanci, sau da sau sano domin gina kariya, kaucewa, ayyuka, ɗaya daga cikin mafi yau-yau aiki Redis shafinsa gida jiya cokali.