როგორ მიერთებთ ნაკადის შეზღუდვას Redis-ით?

Question

Accepted Answer

**ნაკადის შეზღუდვა** (მოთხოვნების/ქმედებების რაოდენობის შეზღუდვა დროის ფანჯარაში) არის Redis-ის გავრცელებული გამოყენების შემთხვევა — Redis-ის სწრაფი ატომური მრიცხველები და TTL-ები მას იდეალურ ხდის. რამდენიმე ალგორითმი არსებობს (ფიქსირებული ფანჯარა, მცურავი ფანჯარა, ტოკენების თასი), თითოეულს აქვს სპეციფიკური უპირატესობა და ნაკლი.

## ფიქსირებული ფანჯარა (უმარტივესი)

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

**ფიქსირებული ფანჯარის** მიდგომა: ატომური მრიცხველი თითოეული (მომხმარებელი, დროის-ფანჯარა) წყვილისთვის TTL-ით — ზღვარი იზრდება თითოეული მოთხოვნის დროს, უარყოფილი ხდება ლიმიტის გადაჭარბებაზე. მარტივი და ეფექტური, ატომური `INCR`-ის და ავტომატური ვადის გამოყენებით.

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

## მცურავი ფანჯარა (უფრო შენიერი)

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

## ტოკენების თასი (კონტროლირებული ზემოქმედების დაშვება)

```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-ით არის გავრცელებული, პრაქტიკული გამოყენების შემთხვევა, ამიტომ მისი გაგება ღირებული ცოდნაა — ნაკადის შეზღუდვა (API-დებისა და სერვისების დაცვა ბოროტად გამოყენებისგან, სამართლიანი გამოყენების უზრუნველყოფა, გადატვირთვის თავიდან აცილება) თითქმის უნივერსალური საჭიროებაა, და Redis აკეთებს სტანდარტულ ხელსაწყოს ამისთვის.

**Redis რატომ არის იდეალური** გაგება მთავარია: მისი **ატომური მრიცხველები** (`INCR`) ხდის ნაკადის დათვლას სწორ მონაკვეთებში (რეისის პირობებში — არ აქვს კორუფციები/დაკარგული დათვლები), მისი **სიჩქარე** (მეხსიერების მეშვეობით) ამატებს მინიმალურ ცდომილებას თითოეულ მოთხოვნაზე, **TTL-ები** ზე არის ფანჯარის გაწმენდა ავტომატურად, და აუცილებელი რაც არის **დაზიარებული სერვერებზე** — მათ შორის **განაწილებული ნაკადის შეზღუდვა** სადაც ყველა აპლიკაციის სერვერი იკრძალება ერთი თანმიმდევრული ლიმიტი (აუცილებელი მრავალ-სერვერ განლაგებებში, სადაც თითოეული-სერვერ მეხსიერების ლიმიტი არ იყო საჭირო).

**ალგორითმების** და მათი სპეციფიკის გაგება საშუალებას გიძლევთ თანაბრად აირჩიოთ: **ფიქსირებული ფანჯარა** (უმარტივესი — ატომური მრიცხველი დროის-ფანჯარაზე TTL-ით, მაგრამ ზღვარი ზღვარზე ზემოქმედების დაშვებით), **მცურავი ფანჯარა** (უფრო შენიერი და ზუსტი დროებული მოთხოვნების სორტირებული კომპლექტის გამოყენებით, უფრო მაღალი მეხსიერების ღირებულებით), და **ტოკენების თასი** (დაშვება კონტროლირებული ზემოქმედების დროს საშუალო ფასის შეზღუდვით, ხშირად Lua სკრიპტის საშუალებით ატომურობისთვის).

ცოდნა თუ როგორ უნდა დანერგოთ ეს (განსაკუთრებით მარტივი, გავრცელებული ფიქსირებული-ფანჯარის ნიმუში `INCR` + `EXPIRE`-ით) არის პრაქტიკული, გამოყენებული უნარი.

ვინაიდან ნაკადის შეზღუდვა არის გავრცელებული მოთხოვნა სერვისების დაცვისთვის, და რადგან Redis (მისი ატომური მრიცხველები, სიჩქარე, TTL-ები, და სხვა სერვერზე გაზიარება) არის სტანდარტული, იდეალური ხელსაწყო განაწილებული ნაკადის შეზღუდვისთვის, გაგება თუ როგორ უნდა დანერგოთ იგი Redis-ით — ალგორითმები, მათი სპეციფიკა, და რატომ სრულდება Redis თანაბრად — ღირებული, ხშირად-გამოყენებული ცოდნა ძლიერი, დაცული სერვისების დასამუშავებლად, Redis-ის ერთ-ერთი ყველაზე გავრცელებული პრაქტიკული გამოყენება ფარგლებში ფარად.