Redis in practice: the data structures, the defaults, and what it quietly loses

SET user:1:name "Naiem"
GET user:1:name

SET session:abc "{...}" EX 3600        # expires in an hour
SET lock:job:42 "worker-7" NX EX 30     # only if it does not exist

INCR page:views                         # atomic counter
INCRBY api:calls:user:1 5
DECR stock:sku-99

MSET a 1 b 2 c 3                        # one round trip instead of three
MGET a b c

SETRANGE / GETRANGE                     # operate on part of a string
APPEND log:today "line\n"

HSET user:1 name "Naiem" email "naiem@example.com" plan "pro"
HGET user:1 email
HGETALL user:1
HMGET user:1 name plan                  # only the fields you need
HINCRBY user:1 login_count 1
HDEL user:1 plan

# Per-field expiry - added in Redis 7.4, and genuinely useful
HEXPIRE user:1 3600 FIELDS 1 session_token
HTTL user:1 FIELDS 1 session_token

# Redis 8 additions for cache patterns
HGETEX user:1 EX 600 FIELDS 1 profile   # read and refresh the TTL together
HGETDEL user:1 FIELDS 1 one_time_code   # read and delete atomically

LPUSH queue:emails "job-1"
RPUSH queue:emails "job-2"
LRANGE queue:emails 0 -1                # everything - careful on large lists
LLEN queue:emails

RPOP queue:emails                       # pop one
BRPOP queue:emails 30                   # block up to 30s waiting for one

# Reliable hand-off: atomically move to a processing list
LMOVE queue:emails queue:processing RIGHT LEFT
BLMOVE queue:emails queue:processing RIGHT LEFT 30

LTRIM recent:events 0 999               # keep only the newest 1000

SADD tags:post:1 astro typescript performance
SISMEMBER tags:post:1 astro             # O(1) membership
SCARD tags:post:1
SINTER tags:post:1 tags:post:2          # posts sharing tags
SDIFF followers:1 followers:2
SRANDMEMBER tags:post:1 2               # random sample

# Sorted sets: every member has a score, and the set stays ordered by it
ZADD leaderboard 4200 "player:1" 3100 "player:2" 5600 "player:3"

ZREVRANGE leaderboard 0 9 WITHSCORES    # top ten
ZRANK leaderboard "player:2"            # this player's position
ZINCRBY leaderboard 150 "player:2"      # award points atomically

ZRANGEBYSCORE events 1755000000 1755086400   # a time window
ZREMRANGEBYSCORE events -inf 1754000000      # trim old entries

ZADD tasks 1755123456 "job:99"          # score = run-at timestamp
ZRANGEBYSCORE tasks -inf 1755100000 LIMIT 0 1   # due jobs

# Append-only log with consumer groups - the durable alternative to pub/sub
XADD orders '*' order_id 42 status paid
XLEN orders
XRANGE orders - + COUNT 10

XGROUP CREATE orders billing 0
XREADGROUP GROUP billing worker-1 COUNT 10 BLOCK 5000 STREAMS orders '>'
XACK orders billing 1755123456-0        # mark as processed

XPENDING orders billing                 # delivered but not acknowledged
XAUTOCLAIM orders billing worker-2 60000 0   # take over a dead worker's messages

XTRIM orders MAXLEN '~' 100000          # cap the length, approximately

# HyperLogLog: count uniques without storing them
PFADD visitors:2026-08-14 "user:1" "user:2" "user:3"
PFCOUNT visitors:2026-08-14
PFMERGE visitors:week visitors:2026-08-08 visitors:2026-08-09

# Bitmap: one bit per user, per day
SETBIT active:2026-08-14 1042 1
BITCOUNT active:2026-08-14
BITOP AND active:both active:2026-08-13 active:2026-08-14

SET session:abc "..." EX 3600           # set with a TTL
EXPIRE session:abc 7200                 # add or change a TTL
TTL session:abc                         # seconds left, -1 = no TTL, -2 = gone
PERSIST session:abc                     # remove the TTL

SET counter 5 KEEPTTL                   # overwrite the value, keep the TTL

maxmemory 4gb
maxmemory-policy allkeys-lru

# Sensible for data you would rather not lose
appendonly yes
appendfsync everysec
auto-aof-rewrite-percentage 100
auto-aof-rewrite-min-size 64mb

save 900 1        # RDB snapshot too, for fast restart and backups
save 300 10
save 60 10000

async function getProduct(id: string) {
  const key = `product:${id}`

  const cached = await redis.get(key)
  if (cached) return JSON.parse(cached)

  const product = await db.product.findUnique({ where: { id } })
  if (!product) return null

  // Jitter the TTL so a batch of keys does not all expire together
  const ttl = 300 + Math.floor(Math.random() * 60)
  await redis.set(key, JSON.stringify(product), 'EX', ttl)

  return product
}

-- Sliding window rate limit, atomic
-- KEYS[1] = key, ARGV[1] = now (ms), ARGV[2] = window (ms), ARGV[3] = limit
redis.call('ZREMRANGEBYSCORE', KEYS[1], 0, ARGV[1] - ARGV[2])
local count = redis.call('ZCARD', KEYS[1])

if count >= tonumber(ARGV[3]) then
  return 0
end

redis.call('ZADD', KEYS[1], ARGV[1], ARGV[1] .. '-' .. math.random())
redis.call('PEXPIRE', KEYS[1], ARGV[2])
return 1

# Simpler fixed-window version, no Lua needed
MULTI
INCR rate:user:1:minute:29251835
EXPIRE rate:user:1:minute:29251835 60
EXEC

# Acquire: set only if absent, with an expiry so a dead holder releases it
SET lock:invoice:42 "$UNIQUE_TOKEN" NX PX 30000

# Release: only if we still hold it - must be atomic
EVAL "if redis.call('GET', KEYS[1]) == ARGV[1] then
        return redis.call('DEL', KEYS[1])
      else
        return 0
      end" 1 lock:invoice:42 "$UNIQUE_TOKEN"

# Pub/sub: fire and forget. No history, no delivery guarantee.
SUBSCRIBE cache:invalidate
PUBLISH cache:invalidate "product:42"

# A subscriber that was disconnected receives nothing. Ever.

HSET session:abc123 user_id 42 role admin csrf "xyz"
EXPIRE session:abc123 1800

# Sliding expiry on each request - read and refresh in one round trip
HGETEX session:abc123 EX 1800 FIELDS 2 user_id role

# On the replica
REPLICAOF primary.internal 6379

# Inspect
INFO replication

# Require at least 2 replicas within 10 seconds, or refuse writes
min-replicas-to-write 2
min-replicas-max-lag 10

# What is Redis actually doing right now?
redis-cli INFO stats
redis-cli INFO memory
redis-cli --stat                        # live counters

# Commands slower than 10ms
CONFIG SET slowlog-log-slower-than 10000
SLOWLOG GET 20

# Per-command time and call counts - find your hot path
INFO commandstats
INFO latencystats

# Watch live traffic. Expensive - never leave it running in production.
redis-cli MONITOR

# Find big keys and hot keys without blocking
redis-cli --bigkeys
redis-cli --memkeys
redis-cli --hotkeys                     # needs an LFU eviction policy

# O(n), blocks the server for the whole scan
KEYS user:*                             # do not

# Cursor-based, non-blocking, safe on any size
SCAN 0 MATCH user:* COUNT 100
redis-cli --scan --pattern 'user:*'

# Structure-specific equivalents
HSCAN user:1 0
SSCAN tags:post:1 0
ZSCAN leaderboard 0

# Pipelining: send many commands, read many replies, one round trip
const pipeline = redis.pipeline()
for (const id of ids) pipeline.hgetall(`product:${id}`)
const results = await pipeline.exec()

# MULTI/EXEC: atomic, but note this is not a rollback-capable transaction
MULTI
DECRBY stock:sku-99 1
INCRBY sold:sku-99 1
EXEC

# Bind to private interfaces only. Never 0.0.0.0 on a public host.
bind 127.0.0.1 10.0.1.5
protected-mode yes

requirepass "a-long-random-string"

# Rename or disable commands that let a client wreck the server
rename-command FLUSHALL ""
rename-command FLUSHDB ""
rename-command CONFIG ""
rename-command DEBUG ""

tls-port 6379
port 0
tls-cert-file /etc/redis/redis.crt
tls-key-file /etc/redis/redis.key

# ACLs: per-user permissions, far better than one shared password
ACL SETUSER api-reader on >secret ~cache:* +@read +ping
ACL SETUSER worker on >secret ~queue:* +@read +@write -@dangerous
ACL LIST
ACL WHOAMI

# Who is connected, and from where?
CLIENT LIST
CLIENT KILL ID 42