Kuinka Lua-skriptaus toimii Redisissa?

Question

Accepted Answer

Redis voi suorittaa **Lua-skriptejä** palvelimen puolella — suorittaen useita komentoja yksittäisenä **atomisena** operaationa. Skriptit mahdollistavat monimutkaisen atomisen logiikan, vähentävät verkon kiertosmatkoja, ja ovat suositeltu tapa tehdä monivaiheisia atomisia operaatioita Redisissa.

## Lua-skriptin suorittaminen

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

Skriptit käyttävät `redis.call()`-funktiota komentojen suorittamiseen, jossa `KEYS[]` (avainten nimet) ja `ARGV[]` (argumentit) välitetään sisään. Koko skripti suoritetaan **atomisesti** yhtenä yksikkönä.

## Miksi skriptit ovat atomisia ja hyödyllisiä

```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 — skriptien välimuistaaminen

```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` suorittaa aiemmin ladatun skriptin sen hash-arvon perusteella — tehokas usein käytetyille skripteille (skripti välimuistetaan palvelimen puolella).

## Varoitukset

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

## Miksi sillä on merkitystä

Lua-skriptaamisen ymmärtäminen Redisissa on arvokasta senior-tason tietoa **monimutkaisten atomisten operaatioiden suorittamiseksi**, joten se on hyödyllistä kehittyneelle Redis-käytölle.

Ydinarvo on **atomisyys monivaiheiselle logiikalle**: Lua-skripti suoritetaan **kokonaisuudessaan yhtenä atomisena yksikkönä** (muut komennot eivät sekoitru siihen), mikä tekee siitä suositellun tavan tehdä luku-muokkaa-kirjoita-operaatioita, joiden täytyy olla atomisia — kuten ehdollisia päivityksiä, turvallista lukituksen vapauttamista (poista vain jos tunnus vastaa), nopeuden rajoittamista ja monimutkaisia laskureita — usein parempi kuin `MULTI`/`EXEC`, koska skriptit tukevat **ehdollista logiikkaa** (transaktio ei voi tehdä päätöksiä välivaiheiden lukemisen perusteella, mutta skripti voi).

Tämä ratkaisee oikean tarpeen atomisille operaatioille, jotka ovat monimutkaisempia kuin yksittäiset komennot.

Toissijainen hyöty on **vähemmän verkon kiertosmatkoja** (useita operaatioita yhdessä kutsusssa, mikä vähentää viiveitä) ja **mukautetun logiikan suorittaminen palvelimen puolella** (lähellä dataa).

Ymmärtäminen **`EVALSHA`**:sta (skriptien välimuistaaminen hash-arvon avulla välttääksesi niiden uudelleenlähettämisen) on käytännöllinen tehokkuustekniikka usein käytetyille skripteille.

Kritisesti tärkeää on ymmärtää **varoitukset**: skriptit **estävät yhden säikeen palvelimen** suorittamisen aikana, joten ne täytyy pitää nopeina ja yksinkertaisina (hidas skripti pysäyttää kaikki asiakkaat — oikea suorituskyvyn riski), ja skriptit pitäisi olla deterministisiä avainten välittämisen kanssa `KEYS[]`:n kautta (klusterin oikeellisuuden kannalta).

Tämä tietoisuus estää skriptien väärinkäyttämisen raskaalle laskennalle.

Koska monimutkaiset atomiset operaatiot ovat aito tarve (lukitukset, ehdollinen logiikka, atomiset monivaiheuset päivitykset), ja koska Lua-skriptit tarjoavat atomisen, yhden kierroksen, palvelimen puolella olevan logiikan, joka on suositeltu lähestymistapa niille (tärkeillä varoituksilla nopeuden pitämisestä), Lua-skriptaamisen ymmärtäminen — kuinka se toimii, miksi se on atominen ja hyödyllinen, EVALSHA-välimuistaaminen ja nopeuden pitämisen varoitukset — on arvokasta senior-tason tietoa kehittyneelle Redis-käytölle, oikea työkalu atomiselle monivaiheiselle logiikalle ja aihe, joka kuvastaa syvempää Redis-asiantuntijuutta.