Hogyan működik a Lua scripting a Redisben?

Question

Accepted Answer

A Redis képes **Lua scripteket** kiszolgálói oldalon végrehajtani — több parancsot egy **atomi** operációként futtat. A scriptek összetett atomi logikát tesznek lehetővé, csökkentik a hálózati oda-vissza utazásokat, és az ajánlott módja a multi-lépéses atomi operációknak a Redisben.

## Lua script futtatása

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

A scriptek a `redis.call()` függvényt használják parancsok futtatásához, a `KEYS[]` (kulcsnevek) és `ARGV[]` (argumentumok) átadott paraméterekkel. Az egész script **atomikusan** végrehajtódik egy egységként.

## Miért atomikusak és hasznosak a scriptek

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

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

Az `EVALSHA` egy korábban betöltött scriptet futtat annak hash-je alapján — hatékony a gyakran használt scriptek számára (a script kiszolgálói oldalon cachelegelve).

## Figyelmeztetések

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

## Miért fontos

A Lua scripting megértése a Redisben értékes senior szintű tudás az **összetett atomi operációk végrehajtásához**, így hasznos a fejlett Redis használathoz.

Az alapvető érték az **atomi multi-lépéses logika**: egy Lua script **teljesen atomi egységként** hajt végre (egyetlen parancs sem szólhat közbe), ami az ajánlott módja az olyan read-modify-write operációknak, amelyeknek atomikusnak kell lenniük — mint a feltételes frissítések, biztonságos zár feloldása (törlés csak akkor, ha a token egyezik), sebességkorlát és összetett számlálók — gyakran jobb, mint a `MULTI`/`EXEC`, mert a scriptek támogatják a **feltételes logikát** (a tranzakció nem tud döntéseket hozni a közbenső olvasások alapján, de egy script igen).

Ez egy valós szükséglethez nyújt megoldást — az olyan atomi operációkhoz, amelyek összetettebb, mint az egyes parancsok.

A másodlagos előny az **kevesebb hálózati oda-vissza utazás** (több operáció egy hívásban, csökkentve a késleltetést) és az **egyéni logika futtatása kiszolgálói oldalon** (az adatok közelében).

Az **`EVALSHA`** megértése (scriptek cacheing hash alapján, hogy elkerüljük az újraküldést) a gyakran használt scriptek praktikus hatékonysági technikája.

Kritikusan fontos az **figyelmeztetések** megértése: a scriptek **blokkolják az egyszálú szervert** futás közben, így gyorsnak és egyszerűnek kell lenniük (egy lassú script az összes klienst megállítja — valós teljesítménykockázat), és a scripteknek deterministikusaknak kell lenniük a `KEYS[]` alapján átadott kulcsokkal (fürt helyessége miatt).

Ez a tudatosság megakadályozza a scripteket nehéz számításokhoz történő helytelen felhasználásában.

Mivel az összetett atomi operációk valós szükséglet (zárak, feltételes logika, atomi multi-lépéses frissítések), és mivel a Lua scriptek atomi, egyetlen körút, kiszolgálói oldalon futó logikát biztosítanak, amely az ajánlott megközelítés rájuk (a gyorsnak tartani szükséges figyelmeztetésekkel), a Lua scripting megértése — hogyan működik, miért atomi és hasznos, az EVALSHA cacheing és a gyorsnak tartás figyelmeztetései — értékes senior szintű tudás a fejlett Redis használathoz, az atomi multi-lépéses logika megfelelő eszköze, és egy olyan témakör, amely mélyebb Redis szakértelmet tükröz.