Pindho cara Lua scripting makarya ing Redis?

Question

Accepted Answer

Redis bisa nglakoni **Lua scripts** ing server-side — njalanake akeh command minangka **atomic** operation tunggal. Scripts ngidini logika atomic sing kompleks, nyuduk round-trip jaringan, lan dadi cara sing diarep-arepake kanggo nindakake operasi atomic multi-step ing Redis.

## Njalanake 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 nggunakake `redis.call()` kanggo njalanake command, karo `KEYS[]` (jeneng kunci) lan `ARGV[]` (argument) dikirim mlebu. Script kabeh nglaksana **atomically** minangka unit siji.

## Wenehane scripts atomic lan guna

```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 — nyimpen 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` njalanake script sing wis dimuat sadurungé miturut hash-e — efisien kanggo scripts sing asring digunakake (script iki disimpan cache ing server-side).

## Waspada

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

## Menapa iki penting

Paham Lua scripting ing Redis minangka kawruh tingkat senior sing berharga kanggo **nindakake operasi atomic sing kompleks**, mulane guna kanggo Redis tingkat lanjut.

Nilai inti yaiku **atomicity kanggo logika multi-step**: Lua script nglaksana **sakabèhé minangka unit atomic tunggal** (ora ana command liya sing nyelepi), ndadekake dadi cara sing diarep-arepake kanggo operasi read-modify-write sing kudu atomic — kaya update kondisional, bebas kunci sing aman (hapus mung yen token cocok), rate limiting, lan counter kompleks — asring luwih apik tinimbang `MULTI`/`EXEC` amarga scripts ndhukung **conditional logic** (transaksi ora bisa nggawa keputusan adhedhapon baca perantara, nanging script bisa).

Iki ngrampungake kabutuhan nyata kanggo operasi atomic sing luwih kompleks tinimbang single command.

Benefits sekunder yaiku **round-trip jaringan luwih sithik** (operasi pirang-pirang ing siji panggilan, nyuduk latency) lan njalanake **logika khusus server-side** (cedhak data).

Paham **`EVALSHA`** (nyimpen scripts miturut hash kanggo ora ngirim maneh) minangka teknik efisiensi praktis kanggo scripts sing asring digunakake.

Kritis, paham **cautions** penting: scripts **blokir server single-threaded** nalika njalanake, mulane kudu dijaga cepet lan prasaja (script alon ngalangi kabeh klien — hazard kinerja nyata), lan scripts kudu deterministic karo kunci dikirim via `KEYS[]` (kanggo cluster correctness).

Awareness iki nyegah misusing scripts kanggo komputasi heavy.

Sakwise operasi atomic kompleks minangka kabutuhan asli (kunci, logika kondisional, update multi-step atomic), lan sakwise Lua scripts nyedhiyakake logika atomic, single-round-trip, server-side sing dadi cara sing diarep-arepake kanggo iku (karo cautions penting bab keep-it-fast), paham Lua scripting — cara dadi gawé, apa iki atomic lan guna, EVALSHA caching, lan cautions keep-it-fast — minangka kawruh tingkat senior sing berharga kanggo Redis lanjut, alat sing tepat kanggo logika atomic multi-step lan topik sing nggambarake expertise Redis luwih jujur.