Kaip implementuoti greitaveiką ribojimą naudojant Redis?

Question

Accepted Answer

**Greitis limitavimas** (žinomų užklausų/veiksmų skaičiaus ribojimas per laiko langą) yra dažnas Redis panaudojimas — Redis greiti atominiai skaitikliai ir TTL-ai tai daro idealiu. Egzistuoja keli algoritmai (fiksuotas langas, slankus langas, žeton malūnas), kiekvienas turi savus privalumus ir trūkumus.

## Fiksuotas langas (paprasčiausias)

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

**Fiksuoto lango** metodas: atominis skaitiklis kiekvienai (vartotojui, laiko-langui) su TTL — padidinti per kiekvieną užklausą, atmetimas kai viršijamas limitas. Paprastas ir efektyvus, naudojantis atominius `INCR` ir automatinį baigiamąjį laiką.

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

## Slankus langas (sklandesnė)

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

## Žeton malūnas (leidžia kontroliuojamus šuolius)

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

## Kodėl Redis yra idealus tam

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

## Kodėl tai svarbu

Implementuoti greitaveikį ribojimą naudojant Redis yra dažnas, praktinis panaudojimas, todėl jo supratimas yra vertingos žinios — greitaveikis ribojimas (API ir paslaugų apsauga nuo piktnaudžiavimo, sklandaus naudojimo garantija, perkrovos prevencija) yra beveik universali poreikis, o Redis yra standartinis tam naudojamas įrankis.

Supratimas **kodėl Redis yra idealus** yra pagrindinė: jos **atominiai skaitikliai** (`INCR`) daro skaičiavimą teisingą esant sudarbiavimui (be lenktynių sąlygų/prarastų skaičiavimų), jos **greitis** (atmintyje) prideda minimalią latenciją kiekvienai užklausai, **TTL-ai** automatiškai tvarkosi lango valymu, ir sprendžiant tai ji yra **dalijama tarp serverių** — įgalinant **paskirstytą greitaveikį ribojimą** kur visi programos serveriai privalo vieną nuoseklų limitą (esminė daugiaserverinuose dieginiuose, kuriuose per-serverinis atmintinis limitai neveiktų).

Supratimas **algoritmų** ir jų kompromisų leidžia jums pasirinkti atitinkamai: **fiksuotas langas** (paprasčiausias — atominis skaitiklis per laiko-langą su TTL, bet leidžiant ribinės vietos šuolius), **slankus langas** (sklandesnė ir tikslesnė naudojant sutvarkytą laiko žymi ūkinių užklausų aibę, aukštesnėje atminties kainoje), ir **žeton malūnas** (leidžiant kontroliuojamus šuolius ribinant vidutinį greitį, dažnai per Lua scenarų atomiškumui).

Žinojimas kaip implementuoti šias (ypatingai paprastą, dažnąjį fiksuoto-lango šabloną su `INCR` + `EXPIRE`) yra praktinis, taikomasis įgūdis.

Kadangi greitaveikis ribojimas yra dažnas reikalavimas paslaugų apsaugai, ir kadangi Redis (su savo atominiais skaitikliais, greitumu, TTL-ais ir tarp-serverio bendravymu) yra standartinis, idealus įrankis paskirstytam greitaveikio ribojimui, supratimas kaip jį implementuoti su Redis — algoritmai, jų kompromisai, ir kodėl Redis taip gerai tinka — yra vertingos, dažnai taikomos žinios patiklioms, apsaugotoms paslaugoms kurti, viena dažniausių praktinių Redis programų išskyrus talpintuvą.