Hoe werkt Lua-scripting in Redis?

Question

Accepted Answer

Redis kan **Lua-scripts** server-side uitvoeren — waarbij meerdere commando's als één enkele **atomaire** operatie worden uitgevoerd. Scripts maken complexe atomaire logica mogelijk, verminderen netwerkrondreizen, en zijn de aanbevolen manier om multi-stap atomaire operaties in Redis uit te voeren.

## Scripts uitvoeren

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

Scripts gebruiken `redis.call()` om commando's uit te voeren, met `KEYS[]` (sleutelnamen) en `ARGV[]` (argumenten) die worden doorgegeven. Het hele script wordt **atomair** als één unit uitgevoerd.

## Waarom scripts atomair zijn en nuttig

```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 — scripts cachen

```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` voert een eerder geladen script uit op basis van zijn hash — efficiënt voor veelgebruikte scripts (het script wordt server-side gecached).

## Voorzorgsmaatregelen

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

## Waarom het belangrijk is

Begrip van Lua-scripting in Redis is waardevol kennis op hoger niveau voor **het uitvoeren van complexe atomaire operaties**, dus nuttig voor geavanceerd Redis-gebruik.

De kernwaarde is **atomariteit voor multi-stap logica**: een Lua-script wordt **volledig als één atomaire eenheid** uitgevoerd (geen andere commando's grijpen in), waardoor het de aanbevolen manier is om read-modify-write operaties uit te voeren die atomair moeten zijn — zoals voorwaardelijke updates, veilige lock-release (verwijderen alleen als het token overeenkomt), rate limiting, en complexe tellers — vaak beter dan `MULTI`/`EXEC` omdat scripts **voorwaardelijke logica** ondersteunen (de transactie kan geen beslissingen nemen op basis van tussenliggende reads, maar een script kan).

Dit lost een echte behoefte op voor atomaire operaties die complexer zijn dan enkele commando's.

Een secundair voordeel is **minder netwerkrondreizen** (meerdere operaties in één aanroep, wat latentie vermindert) en **aangepaste logica server-side uitvoeren** (dicht bij de gegevens).

Begrip van **`EVALSHA`** (scripts cachen op hash om te voorkomen dat ze opnieuw worden verzonden) is een praktische efficiëncy-techniek voor veelgebruikte scripts.

Criticaal is dat het begrijpen van de **voorzorgsmaatregelen** belangrijk is: scripts **blokkeren de single-threaded server** tijdens het uitvoeren, dus ze moeten snel en eenvoudig blijven (een traag script stagneert alle clients — een echt prestatierisico), en scripts moeten deterministisch zijn met sleutels die via `KEYS[]` worden doorgegeven (voor cluster-correctheid).

Deze bewustzijn voorkomt misbruik van scripts voor zware berekeningen.

Omdat complexe atomaire operaties een echte behoefte zijn (locks, voorwaardelijke logica, atomaire multi-stap updates), en omdat Lua-scripts atomaire, single-round-trip, server-side logica bieden die de aanbevolen benadering hiervoor is (met belangrijke voorzorgsmaatregelen over blocking), is het begrijpen van Lua-scripting — hoe het werkt, waarom het atomair en nuttig is, EVALSHA-caching, en de voorzorgsmaatregelen om het snel te houden — waardevol kennis op hoger niveau voor geavanceerd Redis-gebruik, het juiste gereedschap voor atomaire multi-stap logica en een onderwerp dat dieper Redis-expertise weerspiegelt.