Lua Scripting Interview Questions

Lua EVAL runs atomically on the primary: no other command interleaves until the script returns. That is stronger than MULTI/EXEC with WATCH for read-modify-write on the listed keys. Long scripts still block the whole instance.

EVALSHA sends the SHA1 of a loaded script so the body is not retransmitted. NOSCRIPT means the server does not have that SHA; the client must EVAL the body and retry. Pools that connect to new nodes must handle NOSCRIPT.

KEYS array versus ARGV: Cluster hashing uses KEYS, not ARGV. Putting key names in ARGV to be flexible breaks Cluster and the atomicity contract. Always declare keys in KEYS.

lua-time-limit, default five seconds, kills a runaway script with an error but the instance was blocked until then. Busy scripts show up as everyone else timing out. Split work or do it in the app.

SCRIPT LOAD plus EVALSHA is the deploy path; SCRIPT FLUSH on a node creates a NOSCRIPT storm. Do not FLUSH in production casually. SCRIPT EXISTS checks SHAs before a rollout.

redis.call raises on Redis errors and aborts the script; redis.pcall returns an error value. Uncaught errors still leave the atomic block. Handle WRONGTYPE explicitly when the key might be the wrong structure.

When not to use Lua: multi-key work that spans slots, scripts that call Redis with huge payloads, or logic that belongs in the app for testability. Lua is not a general application server. If you need loops over SCAN of the whole keyspace, stop.

Non-deterministic Lua using TIME or math.random used to desync replicas when the script body was re-executed. redis.replicate_commands() or writing only deterministic Redis calls is the safe pattern. Prefer redis.call of INCR over computing random in Lua.

WATCH/MULTI versus Lua: WATCH retries on conflict; Lua does not yield, so it cannot deadlock with another Lua, but it can starve others by running long. For a short compare-and-set, Lua is simpler than WATCH loops.

Replication of scripts: replicas either re-execute the script or apply the write commands the script produced, depending on version and replicate_commands. Non-deterministic scripts plus script replication equal split-brain data. Keep scripts as pure Redis writes.

EVAL on a replica: replicas reject writes unless you are in an unusual debug story. Read-only Lua that only redis.call GET can still be wrong if it assumes it can SET. Send writes to the master.

Script cache is per node: Cluster means every master you hit needs the SHA. A client that EVALSHA against a new shard gets NOSCRIPT. Frameworks should load on all nodes or fall back to EVAL.

Debugging Lua: redis.log, SCRIPT DEBUG, and isolating with redis-cli --eval. Never debug with MONITOR on production while a hot script runs. Unit-test scripts with a throwaway instance.

Lua and pipelining: you can pipeline EVALSHA but each script still runs atomically and serially. Pipelining does not make two scripts concurrent. Giant pipelines of EVALSHA can still spike p99.

Global variables in Lua persist in the interpreter across scripts unless you take care—this is a footgun. Use local. Shared globals plus SCRIPT LOAD lead to cross-request contamination.

Breaking Cluster rules inside Lua with undocumented tricks will pass on standalone and fail in production Cluster. Test scripts against a real Cluster. Hash tags in KEYS are the supported way to touch two keys.

lua sandbox: Redis Lua cannot do OS or network; that is a feature. Needing a JSON HTTP call from Lua means the design is wrong. Keep side effects as Redis writes only.

Version skew: a script that uses Redis 7 commands fails on 6 with a runtime error inside EVAL, rolling back the atomic block. Pin script compatibility. Deploy scripts in the same change as the server upgrade.

High contention INCR in Lua around a HASH is still one thread; Lua does not add parallelism. If the hot key is the bottleneck, Lua cannot save you. Shard the counter instead.

SCRIPT KILL only stops a script that has not yet written; after the first write you wait. A stuck write script is why lua-time-limit and short bodies matter. Design for killability.