Comment fonctionne le scripting Lua dans Redis ?

Question

Accepted Answer

Redis peut exécuter des **scripts Lua** côté serveur — en exécutant plusieurs commandes comme une seule opération **atomique**. Les scripts permettent une logique atomique complexe, réduisent les allers-retours réseau, et sont le moyen recommandé pour effectuer des opérations atomiques multi-étapes dans Redis.

## Exécuter un script 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
```

Les scripts utilisent `redis.call()` pour exécuter des commandes, avec `KEYS[]` (noms de clés) et `ARGV[]` (arguments) transmis. Le script entier s'exécute **atomiquement** comme une seule unité.

## Pourquoi les scripts sont atomiques et utiles

```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 — mise en cache des 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` exécute un script précédemment chargé par son hash — efficace pour les scripts fréquemment utilisés (le script est mis en cache côté serveur).

## Précautions

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

## Pourquoi c'est important

Comprendre le scripting Lua dans Redis est une connaissance de haut niveau précieuse pour **effectuer des opérations atomiques complexes**, ce qui est utile pour l'utilisation avancée de Redis.

La valeur essentielle est l'**atomicité pour la logique multi-étapes** : un script Lua s'exécute **entièrement comme une seule unité atomique** (aucune autre commande ne s'intercale), ce qui en fait le moyen recommandé pour effectuer des opérations lecture-modification-écriture qui doivent être atomiques — comme les mises à jour conditionnelles, la libération sécurisée de verrous (supprimer uniquement si le jeton correspond), la limitation de débit, et les compteurs complexes — souvent meilleur que `MULTI`/`EXEC` car les scripts supportent la **logique conditionnelle** (la transaction ne peut pas prendre de décisions basées sur les lectures intermédiaires, mais un script le peut).

Ceci résout un vrai besoin d'opérations atomiques plus complexes que des commandes uniques.

Un avantage secondaire est la **réduction des allers-retours réseau** (plusieurs opérations en un seul appel, réduisant la latence) et l'exécution de **logique personnalisée côté serveur** (près des données).

Comprendre **`EVALSHA`** (mise en cache des scripts par hash pour éviter de les renvoyer) est une technique d'efficacité pratique pour les scripts fréquemment utilisés.

Critiquement, comprendre les **précautions** est important : les scripts **bloquent le serveur single-thread** pendant l'exécution, ils doivent donc rester rapides et simples (un script lent bloque tous les clients — un vrai risque de performance), et les scripts doivent être déterministes avec les clés transmises via `KEYS[]` (pour la correction en cluster).

Cette prise de conscience prévient l'utilisation abusive de scripts pour des calculs lourds.

Comme les opérations atomiques complexes sont un vrai besoin (verrous, logique conditionnelle, mises à jour multi-étapes atomiques), et comme les scripts Lua fournissent une logique atomique, single-round-trip, côté serveur qui est l'approche recommandée pour les effectuer (avec des précautions importantes sur le blocage), comprendre le scripting Lua — comment il fonctionne, pourquoi il est atomique et utile, la mise en cache EVALSHA, et les précautions de maintenir-rapide — est une connaissance de haut niveau précieuse pour l'utilisation avancée de Redis, l'outil approprié pour la logique multi-étapes atomique et un sujet reflétant une expertise Redis plus profonde.