Hvordan fungerer Lua-scripting i Redis?

Question

Accepted Answer

Redis kan udføre **Lua-scripts** på serveren — køre flere kommandoer som en enkelt **atomær** operation. Scripts muliggør kompleks atomær logik, reducerer netværkstur-retur, og er den anbefalede måde at udføre multi-trins atomære operationer på i Redis.

## Kørsel af et Lua-script

```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 bruger `redis.call()` til at køre kommandoer, med `KEYS[]` (nøglenavne) og `ARGV[]` (argumenter) videregivet. Hele scriptet udføres **atomært** som en enhed.

## Hvorfor scripts er atomære og brugbare

```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 — caching af scripts

```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` kører et tidligere indlæst script efter dets hash — effektivt for hyppigt brugte scripts (scriptet caches på serveren).

## Advarsler

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

## Hvorfor det betyder noget

At forstå Lua-scripting i Redis er værdifuldt senior-niveau viden til **at udføre komplekse atomære operationer**, så det er brugbart til avanceret Redis-brug.

Kernepunktet er **atomaritet for multi-trins logik**: et Lua-script udføres **helt som en atomær enhed** (ingen andre kommandoer imellem), hvilket gør det til den anbefalede måde at udføre læs-modificer-skriv operationer på, der skal være atomære — som betingede opdateringer, sikker låsefrigivelse (slet kun hvis tokenet stemmer overens), rate limiting og komplekse tællere — ofte bedre end `MULTI`/`EXEC` fordi scripts understøtter **betinget logik** (transaktionen kan ikke træffe beslutninger baseret på mellemlande læsninger, men et script kan).

Dette løser et reelt behov for atomære operationer mere komplekse end enkeltkommandoer.

En sekundær fordel er **færre netværkstur-retur** (flere operationer i et kald, reducerer latens) og kørsel af **tilpasset logik på serveren** (tæt på dataene).

At forstå **`EVALSHA`** (caching af scripts efter hash for at undgå at gensende dem) er en praktisk effektivitetsteknik for hyppigt brugte scripts.

Kritisk set er det vigtigt at forstå **advarslerne**: scripts **blokerer den single-trådede server** mens de kører, så de skal holdes hurtige og enkle (et langsomt script bremser alle klienter — en reel performance-risiko), og scripts skal være deterministiske med nøgler videregivet via `KEYS[]` (for cluster-korrekthed).

Denne bevidsthed forhindrer misbrug af scripts til tung beregning.

Da komplekse atomære operationer er et ægte behov (låse, betinget logik, atomære multi-trins opdateringer), og da Lua-scripts giver atomær, enkelt-tur-retur, server-side logik, som er den anbefalede tilgang til dem (med vigtige advarsler om blocking), er forståelse af Lua-scripting — hvordan det fungerer, hvorfor det er atomært og brugbart, EVALSHA caching og advarsler om at holde det hurtigt — værdifuld senior-niveau viden til avanceret Redis-brug, det rigtige værktøj til atomær multi-trins logik og et emne, der afspejler dybere Redis-ekspertise.