Redis Overview

Redis is an in-memory data structure server. The important design move is not "put data in Redis", it is choosing the data structure and command shape that matches the production job.

Where Redis Fits

Redis usually sits beside the source-of-truth database, not instead of it. PostgreSQL owns relational truth and durable invariants. Redis owns fast access paths, shared counters, temporary coordination, fanout, and lightweight event buffers.

How A Command Works

Clients talk to Redis with RESP, the Redis Serialization Protocol. RESP is a request-response wire format where clients send commands as arrays of bulk strings, and Redis returns command-specific replies. Pipelining lets clients send multiple commands before waiting for each response, reducing round trips.

RESP Command Anatomy

The command SET name aniket is sent as an array of three bulk strings: command name, key, and value.

*3\r\n
$3\r\n
SET\r\n
$4\r\n
name\r\n
$6\r\n
aniket\r\n

*3 means the outer object is an array of three items. Each $N line says the next bulk string has N bytes. The text form is enough here: RESP is intentionally simple.

Core Internals

What Data Can Be Stored

Redis keys are strings. Values are typed data structures. A key cannot be both a string and a hash at the same time. A wrong command against the wrong type returns a type error.

Use Cases

The same Redis server can power many patterns, but each pattern has a different correctness story. Choose by asking: what is the source of truth, what can expire, what can be lost, and what must be atomic?

GET product:42
SET product:42 "{\"stock\": 99}" EX 60
TTL product:42

Use Case Decision Rules

Hands-On Redis Labs

The lab pages explain the exact Redis commands, key shapes, Lua scripts, terminal output, and production gotchas behind each runnable experiment.

Lua And Lua Scripts

Lua is a small embedded programming language. Redis embeds Lua 5.1 so clients can send scripts with EVAL or load them and call by hash. Scripts run on the Redis server, next to the data.

When Lua is useful

• Conditional update: decrement stock only if enough quota remains.
• Safe lock release: delete a lock only if its value matches your owner token.
• Rate limiter: increment a counter and set expiry only when the key is new.
• Queue bookkeeping: move a job between structures without a visible half-state.
• Cross-key checks on one Redis node when a single built-in command is not enough.

Safe lock release script

EVAL "
if redis.call('GET', KEYS[1]) == ARGV[1] then
  return redis.call('DEL', KEYS[1])
else
  return 0
end
" 1 lock:payment:123 worker-a-uuid

This prevents one worker from deleting another worker's renewed or re-acquired lock. The key name is passed through KEYS. The owner token is passed through ARGV. That matters because Redis Cluster needs scripts to declare their key access clearly.

Fixed-window rate limiter script

EVAL "
local current = redis.call('INCR', KEYS[1])
if current == 1 then
  redis.call('EXPIRE', KEYS[1], ARGV[1])
end
return current
" 1 rl:user:42 60

The script makes the first increment and expiry setup one atomic operation. Without the script, a client crash between INCR and EXPIRE can leave a counter that never resets.

Lua cautions

• Scripts block Redis while they execute, so keep them short.
• Pass keys through KEYS and non-key arguments through ARGV.
• Do not generate a unique script body for every request. Parameterize scripts instead.
• For long-lived server-side logic in Redis 7+, evaluate Redis Functions as an alternative.

Persistence, Eviction, And Durability

Redis can persist data, but persistence choice changes what failures mean.

Redis Versus PostgreSQL

Practical First CLI Experiments

These are enough to learn the shape before writing application code.

# cache with TTL
SET product:42 "{\"price\": 1999}" EX 30
GET product:42
TTL product:42

# rate counter
INCR rl:user:42
EXPIRE rl:user:42 60
TTL rl:user:42

# lock acquisition
SET lock:payment:123 worker-a NX PX 5000
GET lock:payment:123

# stream event
XADD payments * id p1 amount 100
XREAD COUNT 1 STREAMS payments 0

# sorted ranking
ZADD leaderboard 900 user:42 850 user:7
ZREVRANGE leaderboard 0 9 WITHSCORES

Sources

• Redis data types
• Redis Serialization Protocol specification
• Redis pipelining
• Redis transactions
• Scripting with Lua
• Redis persistence
• Redis key eviction
• Redis Pub/Sub