Redis में Lua scripting कैसे काम करती है?

Question

Accepted Answer

Redis **Lua scripts** को server-side execute कर सकता है — कई commands को एक single **atomic** operation के रूप में चलाते हुए। Scripts complex atomic logic को सक्षम बनाते हैं, network round-trips को कम करते हैं, और Redis में multi-step atomic operations करने का अनुशंसित तरीका हैं।

## एक 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 commands चलाने के लिए `redis.call()` का उपयोग करते हैं, जिसमें `KEYS[]` (key names) और `ARGV[]` (arguments) पास किए जाते हैं। पूरा script **atomically** एक unit के रूप में execute होता है।

## scripts atomic और उपयोगी क्यों हैं

```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 — scripts को cache करना

```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` एक पहले से load किए गए script को उसके hash द्वारा चलाता है — बार-बार उपयोग किए जाने वाले scripts के लिए efficient (script server-side cache होता है)।

## सावधानियाँ

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

## यह क्यों महत्वपूर्ण है

Redis में Lua scripting को समझना **complex atomic operations करने** के लिए मूल्यवान senior-level ज्ञान है, इसलिए यह advanced Redis उपयोग के लिए उपयोगी है।

मुख्य मूल्य **multi-step logic के लिए atomicity** है: एक Lua script **पूरी तरह से एक atomic unit के रूप में** execute होता है (कोई अन्य commands interleave नहीं होते), जो इसे read-modify-write operations करने का अनुशंसित तरीका बनाता है जो atomic होने चाहिए — जैसे conditional updates, safe lock release (केवल तभी delete करें जब token match हो), rate limiting, और complex counters — अक्सर `MULTI`/`EXEC` से बेहतर क्योंकि scripts **conditional logic** को support करते हैं (transaction intermediate reads के आधार पर निर्णय नहीं ले सकता, लेकिन एक script ले सकता है)।

यह single commands से अधिक complex atomic operations की वास्तविक आवश्यकता को हल करता है।

एक secondary लाभ **कम network round-trips** (एक call में कई operations, latency को कम करते हुए) और **custom logic server-side** चलाना (data के पास) है।

**`EVALSHA`** को समझना (scripts को hash द्वारा cache करना ताकि उन्हें फिर से न भेजना पड़े) बार-बार उपयोग किए जाने वाले scripts के लिए एक व्यावहारिक efficiency technique है।

महत्वपूर्ण रूप से, **सावधानियों** को समझना महत्वपूर्ण है: scripts चलते समय **single-threaded server को block करते हैं**, इसलिए उन्हें fast और simple रखा जाना चाहिए (एक slow script सभी clients को रोक देता है — एक वास्तविक performance hazard), और scripts deterministic होने चाहिए जिनमें keys `KEYS[]` के माध्यम से पास की जाएँ (cluster correctness के लिए)।

यह जागरूकता scripts को heavy computation के लिए misuse करने से रोकती है।

चूँकि complex atomic operations एक वास्तविक आवश्यकता हैं (locks, conditional logic, atomic multi-step updates), और चूँकि Lua scripts atomic, single-round-trip, server-side logic प्रदान करते हैं जो उनके लिए अनुशंसित approach है (blocking के बारे में महत्वपूर्ण सावधानियों के साथ), Lua scripting को समझना — यह कैसे काम करता है, यह atomic और उपयोगी क्यों है, EVALSHA caching, और keep-it-fast सावधानियाँ — advanced Redis उपयोग के लिए मूल्यवान senior-level ज्ञान है, atomic multi-step logic के लिए सही tool और एक विषय जो गहरी Redis विशेषज्ञता को दर्शाता है।