Bagaimana skrip Lua berfungsi dalam Redis?

Question

Accepted Answer

Redis boleh melaksanakan **skrip Lua** di sebelah pelayan (server-side) — menjalankan berbilang arahan sebagai satu operasi **atomik**. Skrip membolehkan logik atomik yang kompleks, mengurangkan perjalanan ulang-alik rangkaian (round-trip), dan merupakan cara yang disyorkan untuk melakukan operasi atomik berbilang langkah dalam Redis.

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

Skrip menggunakan `redis.call()` untuk menjalankan arahan, dengan `KEYS[]` (nama kunci) dan `ARGV[]` (argumen) yang dihantar masuk. Keseluruhan skrip dilaksanakan secara **atomik** sebagai satu unit.

## Mengapa skrip adalah atomik 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 skrip

```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 skrip yang telah dimuatkan sebelum ini melalui hash-nya — cekap untuk skrip yang kerap digunakan (skrip di-cache di sebelah pelayan).

## 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 ia penting

Memahami skrip Lua dalam Redis merupakan pengetahuan peringkat senior yang berharga untuk **melaksanakan operasi atomik yang kompleks**, jadi ia berguna untuk penggunaan Redis lanjutan.

Nilai terasnya ialah **atomicity untuk logik berbilang langkah**: skrip Lua dilaksanakan **sepenuhnya sebagai satu unit atomik** (tiada arahan lain berselang-seli), menjadikannya cara yang disyorkan untuk melakukan operasi read-modify-write yang mesti atomik — seperti kemas kini bersyarat, pelepasan lock yang selamat (padam hanya jika token sepadan), rate limiting, dan kaunter yang kompleks — selalunya lebih baik daripada `MULTI`/`EXEC` kerana skrip menyokong **logik bersyarat** (transaksi tidak boleh membuat keputusan berdasarkan bacaan perantaraan, tetapi skrip boleh).

Ini menyelesaikan keperluan sebenar untuk operasi atomik yang lebih kompleks daripada arahan tunggal.

Faedah sekunder ialah **lebih sedikit round-trip rangkaian** (berbilang operasi dalam satu panggilan, mengurangkan kependaman) dan menjalankan **logik tersuai di sebelah pelayan** (dekat dengan data).

Memahami **`EVALSHA`** (caching skrip melalui hash untuk mengelakkan penghantaran semula) ialah teknik kecekapan yang praktikal untuk skrip yang kerap digunakan.

Yang kritikal, memahami **peringatan** adalah penting: skrip **menyekat pelayan yang single-threaded** semasa berjalan, jadi ia mesti dipastikan pantas dan ringkas (skrip yang perlahan menyekat semua klien — bahaya prestasi yang sebenar), dan skrip patut bersifat deterministik dengan kunci dihantar melalui `KEYS[]` (untuk ketepatan kluster).

Kesedaran ini mencegah penyalahgunaan skrip untuk pengiraan berat.

Memandangkan operasi atomik yang kompleks ialah keperluan sebenar (lock, logik bersyarat, kemas kini berbilang langkah atomik), dan memandangkan skrip Lua menyediakan logik atomik, single-round-trip, di sebelah pelayan yang merupakan pendekatan yang disyorkan untuknya (dengan peringatan penting tentang penyekatan), memahami skrip Lua — cara ia berfungsi, mengapa ia atomik dan berguna, caching EVALSHA, dan peringatan jaga-supaya-pantas — merupakan pengetahuan peringkat senior yang berharga untuk penggunaan Redis lanjutan, alat yang tepat untuk logik berbilang langkah atomik dan satu topik yang mencerminkan kepakaran Redis yang lebih mendalam.