Como funciona o scripting Lua no Redis?

Question

Accepted Answer

O Redis pode executar **scripts Lua** no servidor — executando múltiplos comandos como uma única operação **atômica**. Scripts habilitam lógica atômica complexa, reduzem viagens de rede, e são a forma recomendada de fazer operações atômicas multi-etapas no Redis.

## Executando um 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
```

Scripts usam `redis.call()` para executar comandos, com `KEYS[]` (nomes de chaves) e `ARGV[]` (argumentos) passados. O script inteiro executa **atomicamente** como uma unidade.

## Por que scripts são atômicos e úteis

```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 — armazenando scripts em cache

```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` executa um script previamente carregado pelo seu hash — eficiente para scripts frequentemente usados (o script é armazenado em cache no servidor).

## Cuidados

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

## Por que isso importa

Compreender scripting Lua no Redis é conhecimento valioso de nível sênior para **realizar operações atômicas complexas**, então é útil para uso avançado do Redis.

O valor principal é **atomicidade para lógica multi-etapas**: um script Lua executa **inteiramente como uma unidade atômica** (nenhum outro comando se intercala), tornando-o a forma recomendada de fazer operações leitura-modificação-escrita que devem ser atômicas — como atualizações condicionais, liberação segura de locks (deletar apenas se o token corresponde), rate limiting e contadores complexos — frequentemente melhor que `MULTI`/`EXEC` porque scripts suportam **lógica condicional** (a transação não pode tomar decisões baseadas em leituras intermediárias, mas um script pode).

Isso resolve uma necessidade real de operações atômicas mais complexas que comandos únicos.

Um benefício secundário é **menos viagens de rede** (múltiplas operações em uma chamada, reduzindo latência) e executar **lógica customizada no servidor** (perto dos dados).

Compreender **`EVALSHA`** (armazenar scripts em cache pelo hash para evitar reenviá-los) é uma técnica prática de eficiência para scripts frequentemente usados.

Criticamente, compreender as **cuidados** é importante: scripts **bloqueiam o servidor single-threaded** durante a execução, então devem ser mantidos rápidos e simples (um script lento paralisa todos os clientes — um perigo real de desempenho), e scripts devem ser determinísticos com chaves passadas via `KEYS[]` (para correção em cluster).

Essa consciência previne o uso incorreto de scripts para computação pesada.

Como operações atômicas complexas são uma necessidade genuína (locks, lógica condicional, atualizações atômicas multi-etapas), e como scripts Lua fornecem lógica atômica, single-round-trip e no servidor que é a abordagem recomendada para elas (com cuidados importantes sobre bloqueio), compreender scripting Lua — como funciona, por que é atômico e útil, armazenamento EVALSHA em cache e os cuidados de mantê-lo rápido — é conhecimento valioso de nível sênior para uso avançado do Redis, a ferramenta correta para lógica atômica multi-etapas e um tópico refletindo expertise Redis mais profunda.