Bagaimana cara scripting Lua bekerja di Redis?

Question

Accepted Answer

Redis dapat menjalankan **script Lua** di sisi server — menjalankan beberapa perintah sebagai satu operasi **atomic**. Script memungkinkan logika atomic yang kompleks, mengurangi round-trip jaringan, dan merupakan cara yang direkomendasikan untuk melakukan operasi atomic multi-langkah di Redis.

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

Script menggunakan `redis.call()` untuk menjalankan perintah, dengan `KEYS[]` (nama kunci) dan `ARGV[]` (argumen) yang diteruskan masuk. Seluruh script dijalankan **secara atomic** sebagai satu unit.

## Mengapa script atomic dan berguna

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

```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` menjalankan script yang sebelumnya dimuat berdasarkan hashnya — efisien untuk script yang sering digunakan (script di-cache di sisi server).

## Peringatan

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

## Mengapa ini penting

Memahami scripting Lua di Redis adalah pengetahuan tingkat senior yang berharga untuk **melakukan operasi atomic yang kompleks**, sehingga berguna untuk penggunaan Redis tingkat lanjut.

Nilai inti adalah **atomicity untuk logika multi-langkah**: script Lua dijalankan **sepenuhnya sebagai satu unit atomic** (tidak ada perintah lain yang tersisip), menjadikannya cara yang direkomendasikan untuk melakukan operasi read-modify-write yang harus atomic — seperti update bersyarat, release lock yang aman (hapus hanya jika token cocok), rate limiting, dan counter kompleks — sering kali lebih baik daripada `MULTI`/`EXEC` karena script mendukung **logika bersyarat** (transaksi tidak dapat membuat keputusan berdasarkan pembacaan intermediate, tetapi script dapat).

Ini mengatasi kebutuhan nyata untuk operasi atomic yang lebih kompleks dari perintah tunggal.

Manfaat sekunder adalah **lebih sedikit round-trip jaringan** (beberapa operasi dalam satu panggilan, mengurangi latensi) dan menjalankan **logika custom di sisi server** (dekat dengan data).

Memahami **`EVALSHA`** (caching script berdasarkan hash untuk menghindari pengiriman ulang) adalah teknik efisiensi praktis untuk script yang sering digunakan.

Secara kritis, memahami **peringatan** adalah penting: script **memblokir server single-threaded** saat berjalan, jadi script harus dijaga tetap cepat dan sederhana (script yang lambat menghentikan semua klien — bahaya performa nyata), dan script harus deterministic dengan kunci yang diteruskan melalui `KEYS[]` (untuk kebenaran cluster).

Kesadaran ini mencegah penyalahgunaan script untuk komputasi berat.

Karena operasi atomic yang kompleks adalah kebutuhan nyata (lock, logika bersyarat, update atomic multi-langkah), dan karena script Lua menyediakan logika atomic, single-round-trip, dan di sisi server yang merupakan pendekatan yang direkomendasikan untuk mereka (dengan peringatan penting tentang blocking), memahami scripting Lua — cara kerjanya, mengapa atomic dan berguna, caching EVALSHA, dan peringatan keep-it-fast — adalah pengetahuan tingkat senior yang berharga untuk penggunaan Redis tingkat lanjut, alat yang tepat untuk logika atomic multi-langkah dan topik yang mencerminkan keahlian Redis yang lebih dalam.