როგორ მუშაობს Lua სკრიპტირება Redis-ში?

Question

Accepted Answer

Redis შეუძლია შეასრულოს **Lua სკრიპტები** სერვერის მხარეს — რამდენიმე ბრძანების შესრულება როგორც ერთი **ატომური** ოპერაცია. სკრიპტები საშუალებას აძლევს რთული ატომური ლოგიკა, აკლებს ქსელის გარშემო მოსახლეობას და არის რეკომენდებული გზა მრავალ-საფეხურიანი ატომური ოპერაციებისთვის Redis-ში.

## Lua სკრიპტის შესრულება

```bash
# EVAL runs a Lua script; KEYS[] and ARGV[] pass keys and arguments
EVAL "return redis.call('SET', KEYS[1], ARGV[1])" 1 mykey myvalue

# a script can run multiple commands and logic atomically
EVAL "
  local current = redis.call('GET', KEYS[1])
  if current == ARGV[1] then
    return redis.call('DEL', KEYS[1])   -- delete only if value matches (atomic check-and-delete)
  end
  return 0
" 1 lock:resource mytoken
```

სკრიპტები იყენებენ `redis.call()`-ს ბრძანებების შესასრულებლად, `KEYS[]`-ით (გასაღების სახელები) და `ARGV[]`-ით (არგუმენტები) გადაწოდილი. მთელი სკრიპტი შესრულდება **ატომურად** როგორც ერთი ერთეული.

## რატომ არის სკრიპტები ატომური და სასარგებლო

```text
✓ ATOMICITY — the ENTIRE script runs as one unit, no other commands interleave
  → perfect for read-modify-write logic that must be atomic (locks, conditional updates,
    rate limiting, complex counters) — better than MULTI/EXEC for conditional logic
✓ FEWER ROUND-TRIPS — multiple operations in ONE call to Redis (less network latency)
✓ Custom LOGIC server-side — conditionals, loops, computations near the data
```

## EVALSHA — სკრიპტების ქეშირება

```bash
# load a script once, then call by its SHA hash (avoids resending the script each time)
SCRIPT LOAD "return redis.call('GET', KEYS[1])"   # => returns a SHA1 hash
EVALSHA <sha> 1 mykey                              # run the cached script by hash
```

`EVALSHA` ახორციელებს წინათ ჩატვირთულ სკრიპტს მისი ჰეშის მიხედვით — ეფექტური ხშირად გამოყენებული სკრიპტებისთვის (სკრიპტი კეშირებულია სერვერის მხარეს).

## გაფრთხილებები

```text
⚠️ Scripts BLOCK the server while running (Redis is single-threaded) → keep them FAST
   and simple (no slow loops/operations — they'd stall ALL clients)
⚠️ Scripts should be deterministic; pass keys via KEYS[] (for cluster correctness)
→ Use scripts for short, atomic logic — not heavy computation.
```

## რატომ არის ეს მნიშვნელოვანი

Lua სკრიპტირების გაგება Redis-ში ღირებული უფროსი დონის ცოდნა არის **რთული ატომური ოპერაციების შესასრულებლად**, ამიტომ სასარგებლო არის მაღალი დონის Redis გამოყენებისთვის.

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

ეს ხსნის რეალურ საჭიროებას ატომური ოპერაციებისთვის რომელიც უფრო რთულია ვიდრე ერთეული ბრძანებები.

მეორადი უპირატესობა არის **ნაკლები ქსელი რაუნდი-ტრიპი** (რამდენიმე ოპერაცია ერთ გამოძახებაში, ლატენტობის შემცირება) და **ჩაშენებული ლოგიკის შესრულება სერვერის მხარეს** (მონაცემთან ახლოს).

გაგება **`EVALSHA`** (სკრიპტების ქეშირება ჰეშის მიხედვით რათა თავიდან არ გადაწოდოთ) არის პრაქტიკული ეფექტურობის ტექნიკა ხშირად გამოყენებული სკრიპტებისთვის.

კრიტიკულად, გაგება **გაფრთხილებების** მნიშვნელოვანია: სკრიპტები **ზღვრავენ ერთი ნიტიან სერვერს** შესრულების დროს, ასე რომ ისინი უნდა იყოს სწრაფი და მარტივი (ნელი სკრიპტი ჩერდება ყველა კლიენტი — რეალური ქმედების ზიანი), და სკრიპტები უნდა იყოს დეტერმინისტული გასაღებებით გადაწოდილი `KEYS[]`-ის მეშვეობით (კლასტერის სისწორისთვის).

ეს ცნობიერება აკვეფ მდელი სკრიპტების მოხმარება მძიმე გამოთვლებისთვის.

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