Skip to content

Redis CLI Hoja de referencia

Almacén de estructuras de datos en memoria — comandos y uso de la CLI.

01

Primeros pasos

Conectar al servidor Redis

redis-cli es el cliente estándar de línea de comandos. Por defecto se conecta a 127.0.0.1:6379. Usa -h para el host, -p para el puerto, -a para la contraseña (o fija la variable de entorno REDISCLI_AUTH para no filtrar secretos en el historial del shell). TLS necesita --tls más cert/clave. El esquema de URL redis:// está soportado en Redis 6+, rediss:// para TLS.

redis-cli
# connect to local server (default port 6379)
redis-cli

# connect to a remote host with custom port
redis-cli -h redis.example.com -p 6380

# connect with authentication
redis-cli -a "yourpassword"
redis-cli -h host -p 6379 -a "yourpassword"

# connect over TLS
redis-cli --tls --cert client.crt --key client.key -h host -p 6379

# connect using a URL (Redis 6+)
redis-cli redis://user:password@host:6379/0
redis-cli rediss://user:password@host:6379/0  # TLS

Opciones de conexión y modo

redis-cli soporta tanto modo interactivo como de una sola vez. Pasar un comando como argumentos lo ejecuta y sale. El modo pipe lee comandos RESP/texto de stdin — genial para scripting y cargas masivas. -n selecciona la base de datos lógica. --stat y --latency son helpers de monitoreo integrados. --raw genera valores sin prefijos de tipo, útil para pipes.

redis-cli
# select a specific database index (0-15)
redis-cli -n 1            # use database 1

# run a single command and exit (non-interactive)
redis-cli GET mykey
redis-cli -h host PING

# pass command with arguments
redis-cli SET counter 100
redis-cli INCR counter

# read commands from stdin (pipe mode)
echo "SET k1 v1" | redis-cli
cat commands.txt | redis-cli

# repeat a command every second (watch mode)
redis-cli --stat
redis-cli --latency

# pretty-print JSON output (Redis 6+)
redis-cli --raw GET user:json

PING y test de conectividad

PING es la comprobación de salud más simple — un Redis funcional devuelve PONG. --latency mide continuamente el tiempo de ida y vuelta (útil para diagnosticar problemas de red). --latency-dist muestra un histograma. --latency-history registra estadísticas rodantes. Úsalos para establecer una línea base de tu calidad de conexión antes de ajustar el rendimiento.

redis-cli
# basic connectivity test
redis-cli ping
# PONG

# ping with a message (echoed back)
redis-cli PING "hello"
# "hello"

# test auth + connection in one shot
redis-cli -a password PING

# check round-trip latency (continuous)
redis-cli --latency
# output: min: 0, max: 1, avg: 0.27 (3421 samples)

# latency histogram
redis-cli --latency-dist

# latency history (rolling, every 15s by default)
redis-cli --latency-history -i 1

Consejos del modo interactivo

El modo interactivo es un REPL para comandos de Redis. HELP <comando> o HELP @<grupo> muestra documentación integrada (sin internet). CONNECT cambia de servidor en la sesión. CLEAR limpia la pantalla. La CLI detecta automáticamente la entrada multilínea para cadenas entre comillas. Antepón ':' para correr comandos propios de la CLI (como :raw) frente a comandos de Redis.

redis-cli
# start interactive mode
redis-cli

# inside the CLI:
127.0.0.1:6379> HELP SET       # command help
127.0.0.1:6379> HELP @string   # help for a command group
127.0.0.1:6379> SCAN 0         # any Redis command

# clear the screen
127.0.0.1:6379> CLEAR

# connect to a different server without restarting
127.0.0.1:6379> CONNECT host 6380

# exit
127.0.0.1:6379> EXIT
127.0.0.1:6379> QUIT

# multi-line input: end with a backslash
127.0.0.1:6379> SET mykey "this is \
a multi-line value"

# toggle raw output mode
127.0.0.1:6379> :raw

Selección de base de datos y fundamentos

Las bases de datos de Redis son espacios de nombres lógicos (0-15) que comparten la misma memoria — no esquemas aislados. La mayoría de apps usan solo la db 0. FLUSHDB limpia la db actual; FLUSHALL lo limpia por completo (¡cuidado!). Las múltiples bases de datos están desaconsejadas en favor de instancias separadas o prefijos de claves, ya que comparten un único hilo.

redis-cli
# Redis has 16 logical databases (0-15) by default
SELECT 0     # switch to database 0
SELECT 15    # switch to database 15

# move a key to another database
MOVE mykey 1

# flush the current database (DESTRUCTIVE)
FLUSHDB

# flush ALL databases (VERY DESTRUCTIVE)
FLUSHALL

# get the number of keys in the current db
DBSIZE

# swap two databases (Redis 4.0+)
SWAPDB 0 1

Ayuda y descubrimiento de comandos

COMMAND inspecciona la tabla de comandos del servidor — útil para descubrir capacidades y aridad. COMMAND DOCS (7.0+) devuelve documentación estructurada. El comando HELP de la CLI muestra documentación offline agrupada por categoría (@string, @hash, @server, etc.). Corre 'redis-cli --help' para cada flag y opción de la CLI.

redis-cli
# list all commands (huge output)
COMMAND

# get details of a specific command
COMMAND INFO GET
COMMAND INFO SET HSET LPUSH

# structured documentation (Redis 7+)
COMMAND DOCS SET
COMMAND DOCS @string

# count available commands
COMMAND COUNT

# CLI help
redis-cli --help
redis-cli --version

# inside interactive mode
HELP
HELP @server
HELP @string
HELP @hash
HELP GETSET
02

Cadenas

SET y GET básicos

SET/GET son las operaciones de cadena fundamentales. NX = fijar si no existe (usado para locks); XX = fijar si existe. EX/PX/EXAT/PXAT fijan la expiración atómicamente (sin carrera entre SET y EXPIRE). GETSET devuelve el valor previo mientras fija uno nuevo. Las cadenas son seguras para binarios hasta 512MB.

redis-cli
# set and get a key
SET mykey "Hello"
GET mykey               # "Hello"

# set only if not exists (NX) or only if exists (XX)
SET mykey "new" NX      # set only if key does NOT exist
SET mykey "new" XX      # set only if key DOES exist

# set with expiration (seconds / milliseconds)
SET token "abc" EX 3600    # expires in 3600s
SET token "abc" PX 60000   # expires in 60000ms

# set with expiration at a Unix timestamp
SET token "abc" EXAT 1700000000

# get and set atomically (returns old value)
GETSET counter 0        # returns old value, sets new

# delete a key
DEL mykey

Contadores numéricos (INCR/DECR)

INCR/DECR son atómicos — seguros para acceso concurrente sin locks. Esto hace a Redis ideal para contadores, rate limiting (INCR + EXPIRE) y generar IDs de secuencia. INCRBYFLOAT soporta decimales pero usa precisión doble (cuidado con el redondeo). Si el valor no es un entero, INCR devuelve un error.

redis-cli
# increment a numeric string atomically
SET counter 100
INCR counter            # 101
INCRBY counter 10       # 111

# decrement
DECR counter            # 110
DECRBY counter 5        # 105

# floating point increment
SET price "10.50"
INCRBYFLOAT price 0.25  # "10.75"
INCRBYFLOAT price -1.00 # "9.75"

# all increment ops are atomic and concurrency-safe
# use for: counters, rate limiting, sequence IDs, stats

# INCR on a non-integer value returns an error
SET mystr "hello"
INCR mystr              # ERROR: value is not an integer

APPEND y operaciones de cadena

APPEND extiende una cadena (la crea si falta). STRLEN reporta la longitud. GETRANGE/SETRANGE operan sobre subcadenas (seguras para binarios). GETDEL (6.2+) devuelve y elimina atómicamente — útil para patrones de lectura única. GETEX devuelve atómicamente el valor y fija un TTL — práctico para refrescar la expiración de sesión al leer.

redis-cli
# append to a string value
SET msg "Hello"
APPEND msg " World"     # "Hello World"

# get string length
STRLEN msg              # 11

# get substring
GETRANGE msg 0 4        # "Hello"
GETRANGE msg 6 -1       # "World"

# overwrite a substring (grows if needed)
SETRANGE msg 6 "Redis"  # "Hello Redis"

# get and delete atomically
GETDEL mykey            # returns value AND deletes key
# get and set expiration atomically (6.2+)
GETEX mykey EX 3600     # returns value, sets TTL

# append only if key exists
APPEND existing_key "more"

MSET y MGET (operaciones por lotes)

MSET/MGET agrupan operaciones en un solo viaje de ida y vuelta — esencial para el rendimiento (Redis es monohilo, así que la sobrecarga por comando importa). MSETNX es atómico: o se fijan todas las claves o ninguna. Para muchos pares clave-valor pequeños, considera agruparlos en un hash (HSET) por mejor eficiencia de memoria vía codificación listpack.

redis-cli
# set multiple keys at once (atomic)
MSET k1 "v1" k2 "v2" k3 "v3"

# get multiple keys at once
MGET k1 k2 k3           # 1) "v1" 2) "v2" 3) "v3"

# set multiple only if ALL keys are new
MSETNX k1 "v1" k4 "v4"  # 1 if all set, 0 if any existed

# MSET/MGET reduce round-trips — much faster than
# separate SET/GET calls in a loop

# get the length of a string value
STRLEN k1               # 2

# set multiple fields of different keys is not possible;
# for per-field updates use hashes (HSET)

# pipeline alternative in CLI:
printf '%s\n' "SET k1 v1" "SET k2 v2" "GET k1" | redis-cli --pipe-mode

Bitmaps (basados en cadenas)

Los bitmaps guardan flags booleanos para hasta 4 mil millones de usuarios en ~512MB — extremadamente eficientes en espacio. BITOP AND/OR/XOR/NOT combinan bitmaps (por ejemplo, usuarios activos en varios días). BITCOUNT cuenta usuarios activos. BITFIELD empaqueta varios contadores pequeños en una cadena. Posición = ID de usuario. Casos de uso: usuarios activos diarios, feature flags.

redis-cli
# bitmaps are strings operated on at the bit level
# great for boolean flags on a large user base

# set bit at position (0 or 1)
SETBIT user:1:active 7 1    # user 1 active
GETBIT user:1:active 7      # 1

# count set bits
BITCOUNT user:1:active      # total bits set to 1

# bitwise operations between strings
SETBIT users:d1 5 1
SETBIT users:d2 5 1
BITOP AND active-both users:d1 users:d2
BITCOUNT active-both        # users active on both days

BITOP OR  active-either users:d1 users:d2
BITOP XOR diff         users:d1 users:d2

# find the first set bit
BITPOS user:1:active 1      # position of first 1-bit

# bitfield: multiple counters in one string
BITFIELD mycnt SET u8 0 100
BITFIELD mycnt INCRBY u8 0 10

Expiración y TTL de cadenas

TTL devuelve -2 para claves inexistentes y -1 para claves sin expiración. SET con EX es atómico (sin carrera entre SET y EXPIRE). KEEPTTL (6.0+) te permite actualizar un valor preservando su TTL — útil para refrescar valores cacheados sin reiniciar la ventana de expiración. La expiración es perezosa (comprobada al acceder) más barridos periódicos en segundo plano.

redis-cli
# set a key with expiration in one atomic command
SET session "data" EX 3600    # 1 hour
SET cache "value" PX 60000    # 60 seconds (ms)

# set expiration on an existing key
EXPIRE mykey 60               # 60 seconds
PEXPIRE mykey 60000           # 60 seconds (ms)
EXPIREAT mykey 1700000000     # Unix timestamp

# view remaining time to live
TTL mykey          # seconds (-1 = no expiry, -2 = no key)
PTTL mykey         # milliseconds

# remove expiration (make key persistent)
PERSIST mykey

# TTL with KEEPTTL option (6.0+): set value, keep existing TTL
SET mykey "newval" KEEPTTL
03

Listas

Operaciones push y pop

Las listas son de doble extremo: LPUSH+RPOP = cola (FIFO), LPUSH+LPOP = pila (LIFO). BLPOP/BRPOP bloquean hasta que un ítem esté disponible — la fundación de las colas de Redis (sin polling). Fja siempre un timeout en BLPOP para manejar desconexiones. Las listas son O(1) para operaciones de cabeza/cola pero O(N) para acceso al medio.

redis-cli
# lists are ordered sequences of strings (linked lists)
LPUSH mylist "a" "b"      # list: [b, a]
RPUSH mylist "c"          # list: [b, a, c]

# pop from head or tail
LPOP mylist               # "b" (removes from head)
RPOP mylist               # "c" (removes from tail)

# pop multiple (6.2+)
LPOP mylist 2             # pop 2 from head

# get length
LLEN mylist               # 0

# blocking pop (waits if empty, up to timeout)
BLPOP queue:tasks 30      # blocks up to 30 seconds
BRPOP queue:tasks 0       # blocks forever

# push only if the list exists (don't create new key)
LPUSHX mylist "x"         # 0 if key doesn't exist

LRANGE e indexación

LRANGE 0 -1 devuelve la lista entera. LINDEX es O(N) para elementos del medio — las listas están optimizadas para acceso por los extremos. LSET modifica por índice. LINSERT es O(N) (úsalo con moderación en listas grandes). LPOS halla posiciones de elementos sin eliminarlos. Para acceso aleatorio frecuente por índice, una lista es la elección equivocada — considera un sorted set.

redis-cli
# get a range of elements (0-based, negative from end)
LRANGE mylist 0 -1        # all elements
LRANGE mylist 0 2         # first 3 elements
LRANGE mylist -3 -1       # last 3 elements

# get element by index (O(N) traversal)
LINDEX mylist 0           # first element
LINDEX mylist -1          # last element

# set an element by index
LSET mylist 1 "newval"

# get length
LLEN mylist

# insert before or after a pivot element
LINSERT mylist BEFORE "pivot" "new"
LINSERT mylist AFTER "pivot" "new"

# find the position of an element (6.0+)
LPOS mylist "value"
LPOS mylist "value" RANK 2   # find 2nd occurrence

Pops bloqueantes y colas

BRPOPLPUSH/BLMOVE mueve un ítem atómicamente de la fuente al destino — el consumidor puede procesarlo con seguridad, y si cae, el ítem sigue en el destino (patrón de cola fiable). Esto supera a BRPOP+procesar porque un fallo tras BRPOP pierde el ítem. Tras procesar, elimina de la lista de destino.

redis-cli
# simple FIFO queue: LPUSH to add, RPOP to consume
LPUSH tasks "job1" "job2"
RPOP tasks                # "job1" (FIFO order)

# reliable queue with BRPOP (blocking, waits for work)
BRPOP tasks 0             # blocks until a task is available

# move items between lists atomically
RPOPLPUSH source destination  # move one item

# blocking move (reliable queue pattern)
BRPOPLPUSH source destination 30  # blocks up to 30s

# Redis 6.2+: BLMOVE replaces BRPOPLPUSH
BLMOVE source destination RIGHT LEFT 30

# capped queue (e.g., recent events)
LPUSH recent "event"
LTRIM recent 0 99         # keep latest 100

LREM, LSET y LTRIM

LTRIM es un patrón común para acotar el tamaño de la lista (por ejemplo, conservar solo los últimos 100 eventos). LREM elimina por valor (conteo: positivo=cabeza, negativo=cola, 0=toda la lista). LMPOP (7.0+) hace pop de varias listas en una llamada, útil para colas priorizadas. Para operaciones frecuentes a mitad de lista, una lista es la elección equivocada.

redis-cli
# trim to a range (removes everything outside)
LTRIM mylist 0 99         # keep only first 100 elements
LTRIM mylist -50 -1       # keep only last 50

# remove elements by value
LREM mylist 2 "value"     # remove first 2 occurrences of "value"
LREM mylist -2 "value"    # remove last 2 occurrences
LREM mylist 0 "value"     # remove ALL occurrences

# pop and push in one atomic operation
RPOPLPUSH source dest

# pop from multiple lists (7.0+)
LMPOP 2 mylist1 mylist2 LEFT COUNT 3

# blocking pop from multiple lists (7.0+)
BLMPOP 30 2 mylist1 mylist2 LEFT COUNT 3

# remove a key only if it's a list (type-safe)
DEL mylist                # works on any type

Casos de uso de listas

Las listas son lo mejor para secuencias con patrones de acceso por los extremos: colas, pilas, feeds, búferes. LTRIM las hace ideales para logs/feeds acotados. Para rate limiting, una lista de marcas de tiempo + LTRIM es una ventana deslizante simple. Para colas ordenadas/priorizadas, usa un sorted set. Las listas no soportan deduplicación — usa un set para eso.

redis-cli
# 1. Task queue (FIFO)
LPUSH tasks "process_order:123"
BRPOP tasks 30

# 2. Recent activity feed (capped)
LPUSH user:1:feed "post:99" "post:98"
LTRIM user:1:feed 0 49     # latest 50

# 3. Stack (LIFO)
LPUSH stack "item"
LPOP stack

# 4. Circular buffer (limited size)
LPUSH buffer "new"
LTRIM buffer 0 999         # keep 1000 items

# 5. Rate limiter (sliding window)
LPUSH rate:user:1 1700000000
LTRIM rate:user:1 0 99
LLEN rate:user:1           # request count in window

# 6. Chat history (capped)
LPUSH chat:room:1 "alice: hello"
LTRIM chat:room:1 0 999    # keep last 1000 messages
04

Sets

SADD, SMEMBERS y SISMEMBER

Los sets guardan valores únicos — perfectos para tags, categorías y deduplicación. SISMEMBER es O(1) — mucho más rápido que comprobar una lista. SMEMBERS puede bloquear en sets grandes; usa SSCAN para iterar. SMISMEMBER (7.4+) comprueba la pertenencia por lotes, reduciendo viajes. Los sets usan intset (array ordenado) cuando cada miembro es un entero — muy eficientes en memoria.

redis-cli
# sets: unordered collection of unique strings
SADD tags "redis" "db" "cache"
SADD tags "redis"          # ignored (already exists)

# check membership (O(1))
SISMEMBER tags "redis"     # 1 if member, 0 if not

# get all members (avoid on large sets)
SMEMBERS tags              # 1) "redis" 2) "db" 3) "cache"

# get the number of members
SCARD tags                 # 3

# remove a member
SREM tags "cache"          # 1

# check multiple memberships at once (7.4+)
SMISMEMBER tags "redis" "db" "missing"
# 1) 1  2) 1  3) 0

Operaciones de set (unión/intersección/diferencia)

Las operaciones de set son el superpoder de Redis — unión, intersección y diferencia en O(N) sin procesamiento del cliente. Casos de uso: amigos mutuos (SINTER), visitantes únicos (SUNION), filtrado por tags (SINTER de sets de tags). SINTERCARD (7.0+) devuelve solo el conteo, más rápido cuando no necesitas los miembros. Guarda los resultados para no recomputar.

redis-cli
# set union, intersection, difference
SADD set1 "a" "b" "c"
SADD set2 "b" "c" "d"

# union (all unique members from all sets)
SUNION set1 set2           # a, b, c, d

# intersection (members in ALL sets)
SINTER set1 set2           # b, c

# difference (members in set1 but NOT in set2)
SDIFF set1 set2            # a

# store the result in a new set
SUNIONSTORE result set1 set2
SINTERSTORE result set1 set2
SDIFFSTORE result set1 set2

# count intersection without returning members (7.0+)
SINTERCARD 2 set1 set2 LIMIT 0

# operations on multiple sets at once
SUNION s1 s2 s3 s4

SREM, SMOVE y SPOP

SMOVE es atómico — útil para transiciones de estado (por ejemplo, mover a un usuario del set 'pendiente' al 'activo'). SPOP elimina miembros aleatorios (útil para loterías/fragmentación). SRANDMEMBER no elimina. BSPOP (7.0+) bloquea como BLPOP pero para sets — útil para patrones guiados por eventos donde el orden no importa. SREM devuelve el conteo realmente eliminado.

redis-cli
# remove one or more members
SADD myset "a" "b" "c" "d"
SREM myset "a" "b"         # 2 (number removed)

# move a member from one set to another atomically
SMOVE source dest "member"

# pop a random member (removes it)
SPOP myset                 # removes and returns one
SPOP myset 3               # removes and returns 3 (6.2+)

# get a random member (does NOT remove)
SRANDMEMBER myset          # one random member
SRANDMEMBER myset 3        # 3 random (may repeat)
SRANDMEMBER myset -3       # 3 unique random

# blocking set pop (7.0+) - waits until a member exists
BSPOP myset 30             # blocks up to 30 seconds

# delete the entire set
DEL myset

Iteración SSCAN

SSCAN es la forma segura de iterar sets grandes — SMEMBERS bloquea al servidor en sets enormes. SSCAN es basado en cursor: llámalo repetidamente hasta que el cursor vuelva a 0. COUNT es una pista (puede devolver más o menos). SSCAN ofrece garantías débiles: puede devolver duplicados o perder miembros añadidos durante la iteración, pero nunca bloquea. Maneja siempre el bucle del cursor en tu código.

redis-cli
# SSCAN: cursor-based iteration for large sets
SSCAN myset 0 MATCH "pre*" COUNT 100
# returns: [nextCursor, [member1, member2, ...]]

# continue until cursor returns to 0
SSCAN myset <nextCursor> MATCH "pre*" COUNT 100

# iterate all members safely
cursor=0
while true:
  cursor, members = SSCAN myset cursor COUNT 100
  process(members)
  if cursor == 0: break

# scan with type filtering (7.0+ for SCAN, sets always same type)
# COUNT is a hint, not exact (may return more or fewer)

# MATCH pattern supports glob: *, ?, [abc]
SSCAN myset 0 MATCH "user:*" COUNT 1000

# for small sets, SMEMBERS is fine
# for large sets (>10k), always use SSCAN

Casos de uso de sets

Los sets son la referencia para unicidad y relaciones. El patrón SINTER para seguidores/amigos mutuos es un clásico. Para 'visitantes por día' con cardinalidad enorme, considera HyperLogLog (aproximado pero de 12KB fijos). Para datos únicos ordenados (tablas de clasificación), usa un sorted set. Los sets no tienen orden — si el orden importa, usa una lista o un sorted set.

redis-cli
# 1. Tags / categories
SADD post:1:tags "redis" "db"
SADD post:2:tags "redis" "cache"
SINTER post:1:tags post:2:tags   # posts sharing "redis"

# 2. Unique visitors per day
SADD visitors:2025-01-01 "user:1" "user:2"
SCARD visitors:2025-01-01        # visitor count

# 3. Followers / following (mutual friends)
SADD user:1:following "user:2" "user:3"
SADD user:2:following "user:1" "user:3"
SINTER user:1:following user:2:following  # mutual follows

# 4. Blacklist / whitelist
SADD blacklist "ip:1.2.3.4"
SISMEMBER blacklist "ip:1.2.3.4"   # 1 = blocked

# 5. Lottery / random selection
SADD participants "u1" "u2" "u3" "u4"
SPOP participants 1        # draw a winner
05

Sorted sets

ZADD, ZSCORE y ZRANK

Los sorted sets (zsets) son la estructura más potente de Redis — miembros únicos ordenados por puntuación, con operaciones O(log N). Las opciones de ZADD (NX/XX/GT/LT) habilitan actualizaciones condicionales: GT solo actualiza si la puntuación nueva es mayor (genial para rastrear la 'mejor puntuación'). Las puntuaciones son dobles; los miembros son únicos. Los empates se desempatan lexicográficamente.

redis-cli
# sorted set: unique members ordered by a float score
ZADD leaderboard 100 "alice" 200 "bob" 150 "carol"

# update a score (re-add with new score)
ZADD leaderboard 250 "alice"   # alice's score becomes 250

# add with options (NX: only new, XX: only existing, GT/LT)
ZADD leaderboard NX 300 "new"        # only if new
ZADD leaderboard GT 300 "alice"      # only if new score > current
ZADD leaderboard LT 50 "alice"       # only if new score < current

# get a member's score
ZSCORE leaderboard "alice"      # "250"

# get a member's rank (0-based, ascending)
ZRANK leaderboard "alice"       # rank from lowest
ZREVRANK leaderboard "alice"    # rank from highest (0 = top)

# get the number of members
ZCARD leaderboard               # 3

# get multiple scores at once (6.2+)
ZMSCORE leaderboard "alice" "bob"  # ["250", "200"]

ZRANGE y ZREVRANGE

ZRANGE devuelve por rango (índice); con BYSCORE devuelve por rango de puntuación. Redis 6.2 unificó ZRANGEBYSCORE/ZREVRANGE en ZRANGE con opciones BYSCORE/BYLEX/REV. WITHSCORES incluye la puntuación en la salida. Para tablas de clasificación, ZRANGE 0 9 REV da el top 10. ZRANGESTORE (6.2+) guarda el resultado en una clave nueva para procesarlo después.

redis-cli
# get members by index range (ascending)
ZRANGE leaderboard 0 -1              # all, ascending
ZRANGE leaderboard 0 2               # first 3 (lowest scores)
ZRANGE leaderboard -3 -1             # last 3 (highest scores)

# descending order
ZREVRANGE leaderboard 0 2            # top 3 (highest scores)

# with scores
ZRANGE leaderboard 0 -1 WITHSCORES

# Redis 6.2+: unified ZRANGE with BYSCORE/REV options
ZRANGE leaderboard 100 200 BYSCORE
ZRANGE leaderboard 200 100 BYSCORE REV

# store a range in a new key (6.2+)
ZRANGESTORE top3 leaderboard 0 2 REV

# get by rank with scores
ZRANGE leaderboard 0 9 REV WITHSCORES  # top 10

# limit results (pagination)
ZRANGE leaderboard 0 -1 BYSCORE LIMIT 0 10

ZRANGEBYSCORE y ZCOUNT

ZRANGEBYSCORE devuelve por rango de puntuación; el prefijo '(' hace una puntuación exclusiva. ZCOUNT da el conteo en un rango sin obtener los miembros. ZINCRBY ajusta atómicamente una puntuación y reordena — perfecto para tablas de clasificación en vivo. ZREMRANGEBYRANK es genial para mantener un zset acotado (por ejemplo, conservar solo el top 1000).

redis-cli
# get members by score range
ZRANGEBYSCORE leaderboard 100 200    # scores 100-200
ZRANGEBYSCORE leaderboard 100 +inf   # scores >= 100
ZRANGEBYSCORE leaderboard -inf 200   # scores <= 200
ZRANGEBYSCORE leaderboard (100 200   # scores > 100 (exclusive)

# with pagination
ZRANGEBYSCORE leaderboard 100 200 LIMIT 0 10

# count members in a score range
ZCOUNT leaderboard 100 200

# increment a member's score atomically
ZINCRBY leaderboard 50 "alice"     # alice += 50

# remove a member
ZREM leaderboard "bob"

# remove by rank range
ZREMRANGEBYRANK leaderboard 0 9    # remove lowest 10
ZREMRANGEBYSCORE leaderboard 0 100 # remove scores <= 100

ZUNIONSTORE y ZINTERSTORE

ZUNIONSTORE/ZINTERSTORE combinan zsets con agregación configurable (SUM/MIN/MAX) y pesos — potente para puntuaciones ponderadas (por ejemplo, relevancia = coincidencia_texto*2 + recencia*1). Redis 6.2 añadió ZUNION/ZINTER/ZDIFF que devuelven resultados sin guardar (un comando menos). Son O(N*M) — cuidado con muchos sets grandes. El conteo de sets debe preceder a los nombres de los sets.

redis-cli
# combine multiple sorted sets
ZADD set1 1 "a" 2 "b"
ZADD set2 2 "a" 3 "c"

# union: sum scores by default (a = 1+2 = 3)
ZUNIONSTORE result 2 set1 set2
ZRANGE result 0 -1 WITHSCORES   # a=3, b=2, c=3

# specify aggregation: SUM (default), MIN, MAX
ZUNIONSTORE result 2 set1 set2 AGGREGATE MAX   # a=2, b=2, c=3

# apply weights to each set's scores
ZUNIONSTORE result 2 set1 set2 WEIGHTS 2 1     # set1 scores * 2

# intersection (only members in ALL sets)
ZINTERSTORE result 2 set1 set2                 # only "a"

# Redis 6.2+: return without storing
ZUNION 2 set1 set2 WITHSCORES
ZINTER 2 set1 set2 WITHSCORES
ZDIFF 2 set1 set2 WITHSCORES

# count intersection (7.0+)
ZINTERCARD 2 set1 set2 LIMIT 0

Rangos lexicográficos (BYLEX)

BYLEX habilita consultas por rango sobre miembros cuando las puntuaciones son iguales — convirtiendo un sorted set en un índice de cadenas autoordenado. Casos de uso: autocompletado (guardar palabras con puntuación 0, consultar rangos de prefijo), diccionarios ordenados. '[a' significa inclusivo, '(a' exclusivo, '-' inicio, '+' fin. Solo funciona de forma significativa cuando todas las puntuaciones son idénticas.

redis-cli
# when all scores are equal, sorted sets act as a sorted string set
ZADD myset 0 "apple" 0 "banana" 0 "cherry" 0 "date"

# range by lexicographical order
ZRANGEBYLEX myset "[a" "[c"        # apple, banana, cherry
ZRANGEBYLEX myset "(a" "[c"        # banana, cherry (a exclusive)
ZRANGEBYLEX myset "-" "[b"         # from start to banana
ZRANGEBYLEX myset "[c" "+"         # cherry to end

# count in a lex range
ZLEXCOUNT myset "[a" "[c"          # 3

# remove by lex range
ZREMRANGEBYLEX myset "[a" "[b"

# Redis 6.2+: use ZRANGE with BYLEX
ZRANGE myset "[a" "[c" BYLEX

# limit results (pagination)
ZRANGEBYLEX myset "[a" "[c" LIMIT 0 10

Patrón de tabla de clasificación

Los sorted sets hacen triviales las tablas de clasificación: ZADD para actualizar puntuaciones, ZREVRANGE para el top N, ZREVRANK para la posición de un jugador. ZINCRBY actualiza puntuaciones atómicamente. Para tablas de clasificación por franja temporal (diaria/semanal), usa una clave por periodo con un TTL. La paginación usa ZREVRANGE con offset. Este es uno de los casos de uso más naturales y potentes de Redis.

redis-cli
# build a leaderboard
ZADD leaderboard 100 "alice" 250 "bob" 150 "carol"

# top 10 players (highest scores)
ZREVRANGE leaderboard 0 9 WITHSCORES

# a player's rank (0 = top)
ZREVRANK leaderboard "alice"

# update a score (atomic)
ZINCRBY leaderboard 50 "alice"

# players within a score range (e.g., silver tier 100-199)
ZRANGEBYSCORE leaderboard 100 199

# percentile rank
total = ZCARD(leaderboard)
rank = ZREVRANK(leaderboard "alice")
# percentile = (total - rank) / total * 100

# pagination (page 3, 10 per page)
ZREVRANGE leaderboard 20 29 WITHSCORES

# time-bucketed leaderboards (weekly)
ZADD leaderboard:2025-W01 100 "alice"
EXPIRE leaderboard:2025-W01 604800   # 1 week TTL
06

Hashes

HSET, HGET y HGETALL

Los hashes son ideales para guardar objetos — una clave por objeto, campos por propiedad. Esto supera a serializar JSON porque puedes actualizar campos individuales atómicamente (HSET) sin leer-modificar-escribir. HGETALL devuelve la totalidad de los campos; para hashes grandes, prefiere HSCAN. Los hashes usan codificación listpack cuando son pequeños (bajo ~128 campos), haciéndolos eficientes en memoria.

redis-cli
# a hash maps fields to values (like a small object)
HSET user:1 name "Alice" age 30 email "[email protected]"

# get a single field
HGET user:1 name            # "Alice"

# get all fields and values
HGETALL user:1
# 1) "name"   -> "Alice"
# 2) "age"    -> "30"
# 3) "email"  -> "[email protected]"

# get the number of fields
HLEN user:1                 # 3

# get the string length of a field's value
HSTRLEN user:1 name          # 5 (length of "Alice")

# set a field only if it doesn't exist
HSETNX user:1 status "new"   # 1 if set, 0 if existed

# delete a field
HDEL user:1 email            # removes the email field

HMGET (obtención de varios campos)

HMGET obtiene por lotes varios campos en un solo viaje — mucho más rápido que llamadas HGET separadas. HSET (desde 4.0) acepta múltiples pares campo-valor, dejando HMSET obsoleto. HKEYS/HVALS devuelven cada nombre/valor de campo. HRANDFIELD (6.2+) es útil para muestrear (por ejemplo, feature flags aleatorios). HGETALL bloquea en hashes grandes — usa HSCAN para la iteración de producción.

redis-cli
# get multiple fields at once
HMGET user:1 name age       # 1) "Alice" 2) "30"
HMGET user:1 name missing age  # 1) "Alice" 2) nil 3) "30"

# set multiple fields (HSET supports multiple field-value pairs)
HSET user:1 name "Bob" age 25 email "[email protected]"

# HMSET is deprecated (use HSET with multiple fields)
# HMSET still works but returns OK instead of count

# get all field names
HKEYS user:1                # 1) "name" 2) "age" 3) "email"

# get all values
HVALS user:1                # 1) "Alice" 2) "30" 3) "[email protected]"

# check if a field exists
HEXISTS user:1 name          # 1 if exists, 0 if not

# get a random field (6.2+)
HRANDFIELD user:1            # one random field name
HRANDFIELD user:1 3 WITHVALUES  # 3 random fields + values

HINCRBY (campos numéricos)

HINCRBY sobre campos de hash es atómico — perfecto para contadores por usuario (conteo de logins, conteo de vistas, cantidades del carrito). HINCRBYFLOAT soporta decimales. Los hashes se autoeliminan cuando se elimina el último campo (HDEL). Esto hace a los hashes la estructura ideal para objetos con contadores numéricos — mucho más eficiente que claves de cadena separadas por contador.

redis-cli
# increment a numeric field atomically
HSET user:1:stats logins 0
HINCRBY user:1:stats logins 1    # logins = 1
HINCRBY user:1:stats logins 1    # logins = 2
HINCRBY user:1:stats logins -1   # logins = 1

# increment by a specific amount
HINCRBY user:1:stats page_views 10

# floating point increment
HINCRBYFLOAT user:1:stats score 0.5

# all HINCRBY operations are atomic
# perfect for per-user/per-object counters

# use case: shopping cart (product_id -> quantity)
HSET cart:user:1 product:100 2
HINCRBY cart:user:1 product:100 1   # now 3
HINCRBY cart:user:1 product:100 -1  # now 2
HDEL cart:user:1 product:100        # remove item

HSCAN (iteración de hash)

HGETALL bloquea al servidor en hashes grandes — usa HSCAN para la iteración de producción. HSCAN es basado en cursor: llámalo repetidamente hasta que el cursor vuelva a 0. COUNT es una pista. Los resultados llegan como un array plano [campo, valor, campo, valor, ...] — emparéjalos en tu código. Para hashes con millones de campos, considera fragmentar en varias claves.

redis-cli
# HSCAN: cursor-based iteration (for large hashes)
HSCAN user:1 0 MATCH "na*" COUNT 10
# returns [cursor, [field, value, field, value, ...]]

# iterate all fields safely
cursor=0
while true:
  cursor, fields = HSCAN user:1 cursor COUNT 100
  process(fields)
  if cursor == 0: break

# HGETALL is fine for small hashes (< 100 fields)
# HSCAN is required for large hashes to avoid blocking

# match field names with glob patterns
HSCAN user:1 0 MATCH "user:*" COUNT 1000

# no VALUES-only option; results are [field, value, field, value, ...]
# pair them up in your code

# COUNT is a hint — may return more or fewer than requested

# HSCAN never blocks; safe for production use

Casos de uso de hashes

Los hashes brillan para objetos y contadores agrupados. Una técnica de memoria potente: cuando tienes muchas claves de cadena pequeñas, agrúpalas en un hash — la codificación listpack usa mucha menos sobrecarga que miles de claves individuales (cada una con sus metadatos). Este 'bucketing de claves' puede recortar el uso de memoria 5-10 veces para valores pequeños. El TTL a nivel de campo (7.4+) es una adición importante.

redis-cli
# 1. Store an object (user profile, config)
HSET config:app name "MyApp" version "2.0" debug "off"

# 2. Per-user counters
HINCRBY user:1:stats logins 1
HINCRBY user:1:stats page_views 1
HGET user:1:stats logins

# 3. Shopping cart (product_id -> quantity)
HSET cart:user:1 product:100 2
HINCRBY cart:user:1 product:100 1
HDEL cart:user:1 product:100

# 4. Feature flags
HSET feature_flags user:1 new_ui 1 beta 0
HGET feature_flags user:1 new_ui   # 1

# 5. Session store with TTL
HSET session:abc user_id 1 data "..."
EXPIRE session:abc 1800   # 30 min

# 6. Hash field expiration (Redis 7.4+)
HEXPIRE user:1 60 FIELDS 1 session_token
HPTTL user:1 FIELDS 1 session_token
07

Gestión de claves

EXISTS, TYPE y DEL

EXISTS con varias claves devuelve el conteo de las existentes. TYPE devuelve el tipo de estructura de datos — compruébalo siempre antes de operar para evitar errores WRONGTYPE (el tipo de una clave es inmutable durante su vida). DEL es bloqueante y puede estancar al servidor en estructuras grandes; prefiere UNLINK para claves grandes. TYPE devuelve 'none' para claves inexistentes.

redis-cli
# check if a key exists
SET mykey "hello"
EXISTS mykey             # 1
EXISTS missing           # 0
EXISTS key1 key2 key3    # count of existing keys (multiple)

# get the type of a value
TYPE mykey               # "string"
TYPE mylist              # "list"
TYPE missing             # "none"

# delete one or more keys
DEL mykey                # 1 if deleted, 0 if not
DEL key1 key2 key3       # number of keys deleted

# delete is blocking for large keys — use UNLINK instead
# UNLINK deletes in a background thread

# check type before operating to avoid WRONGTYPE errors
TYPE mykey
# returns: string | list | hash | set | zset | stream | none

UNLINK (borrado asíncrono)

UNLINK (4.0+) es la alternativa no bloqueante a DEL para claves grandes — quita la clave del espacio de claves de inmediato pero libera la memoria en un hilo en segundo plano, evitando estancamientos del servidor. Para claves con millones de elementos, usa siempre UNLINK. FLUSHDB ASYNC / FLUSHALL ASYNC hacen lo mismo para el borrado masivo. El pool de hilos lazyfree se encarga de la liberación real.

redis-cli
# UNLINK: non-blocking delete (large keys)
UNLINK biglist bighash   # returns count of deleted keys

# UNLINK removes the key from the keyspace immediately
# but frees the memory in a background thread

# compare:
DEL biglist              # blocks until fully freed
UNLINK biglist           # returns immediately, frees later

# for small keys, DEL and UNLINK are equivalent
# for large keys (millions of elements), UNLINK is essential

# flush database asynchronously (non-blocking)
FLUSHDB ASYNC
FLUSHALL ASYNC

# check what's being freed in background
INFO memory | grep lazyfree

RENAME y RENAMENX

RENAME mueve atómicamente una clave a un nombre nuevo, sobrescribiendo cualquier clave de destino existente (y su valor). RENAMENX (6.2+) solo renombra si el destino no existe, previniendo sobrescrituras accidentales. El TTL se conserva al renombrar. RENAME es atómico — ningún otro cliente puede ver un estado intermedio. El renombrado entre bases de datos no está soportado; usa MOVE o DUMP/RESTORE.

redis-cli
# rename a key (overwrites destination if it exists)
SET oldkey "value"
RENAME oldkey newkey     # OK; oldkey is gone, newkey has "value"

# rename only if destination doesn't exist (6.2+)
RENAMENX oldkey newkey   # 1 if renamed, 0 if newkey already exists

# rename preserves the type and TTL
SET tempkey "data" EX 3600
RENAME tempkey permkey   # permkey now has TTL of ~3600s
TTL permkey              # ~3600

# rename across databases is not supported
# use MOVE + RENAME, or DUMP/RESTORE for cross-db moves

# type is immutable — rename keeps the type
TYPE permkey             # "string"

# renaming is atomic

KEYS vs SCAN

KEYS bloquea al servidor mientras escanea el espacio de claves completo — NUNCA lo uses en producción sobre datasets grandes. SCAN es la alternativa segura para producción: basado en cursor, no bloqueante, devuelve un cursor que sigues hasta 0. SCAN puede devolver duplicados o perder claves añadidas durante la iteración, pero nunca bloquea. COUNT es una pista (puede devolver más o menos). Maneja siempre el bucle del cursor en tu código.

redis-cli
# KEYS: blocks the server while scanning — NEVER in production
KEYS *                   # all keys (DANGEROUS on large DBs)
KEYS user:*              # keys matching pattern
KEYS session:*

# SCAN: cursor-based iteration (non-blocking, production-safe)
SCAN 0 MATCH user:* COUNT 100
# returns: [nextCursor, [key1, key2, ...]]

# continue until cursor returns to 0
SCAN <nextCursor> MATCH user:* COUNT 100

# scan by type (7.0+)
SCAN 0 TYPE hash
SCAN 0 MATCH user:* TYPE string COUNT 100

# SCAN is weakly consistent:
# - may return duplicates
# - may miss keys added during iteration
# - but NEVER blocks the server

# COUNT is a hint, not exact

RANDOMKEY y DBSIZE

RANDOMKEY devuelve una clave aleatoria sin eliminarla — útil para muestrear. DBSIZE devuelve el conteo exacto de claves en la base de datos actual (O(1)). INFO keyspace muestra los conteos por base de datos con estadísticas de expiración (keys, expires, avg_ttl). Para una clave aleatoria de un tipo concreto no hay comando integrado — usa SCAN + TYPE en un bucle.

redis-cli
# get a random key (O(1), does not remove)
RANDOMKEY                # "user:1" or nil if db is empty

# get the number of keys in the current database
DBSIZE                   # 1234

# count keys across all databases (in a cluster)
# note: DBSIZE only counts the current db
SELECT 0; DBSIZE
SELECT 1; DBSIZE

# get keyspace info (keys per db with expiry info)
INFO keyspace
# db0:keys=1000,expires=500,avg_ttl=3600000
# db1:keys=50,expires=10,avg_ttl=60000

# scan with count for approximate size estimation
SCAN 0 COUNT 1           # get cursor + small sample

# find a random key of a specific type
# (no built-in; use SCAN + TYPE in a loop)

Comandos OBJECT

OBJECT ENCODING revela la representación interna (depurar memoria). OBJECT IDLETIME halla claves frías (candidatas a eviction). OBJECT FREQ funciona solo con maxmemory-policy LFU. MEMORY USAGE con SAMPLES 0 cuenta exactamente (por defecto muestrea en colecciones grandes). COMMAND DOCS (7.0+) devuelve documentación estructurada. Estas herramientas de introspección ayudan a depurar el hinchado de memoria.

redis-cli
# OBJECT subcommands for introspection
OBJECT ENCODING mykey     # internal encoding (embstr, raw, int, listpack, etc.)
OBJECT REFCOUNT mykey     # reference count
OBJECT IDLETIME mykey     # seconds since last access
OBJECT FREQ mykey         # access frequency (LFU mode only)

# check memory usage of a key (bytes)
MEMORY USAGE mykey
MEMORY USAGE mykey SAMPLES 0   # exact count (slower for large keys)

# total memory used by the server
INFO memory | grep used_memory_human

# inspect a key's internal structure (debugging, can be slow)
DEBUG OBJECT mykey        # raw internal info

# the encoding changes automatically as the structure grows
# e.g., hash: listpack -> hashtable when fields exceed threshold

# help understand a command
COMMAND INFO GET
COMMAND DOCS SET          # structured docs (7.0+)
08

Expiración y persistencia

EXPIRE y EXPIREAT

EXPIRE fija un TTL sobre una clave existente; SET con EX/PX/EXAT/PXAT lo hace atómicamente (preferido). Las opciones NX/GT/LT (7.0+) habilitan el fijado condicional de TTL — útil para 'solo añadir expiración si no hay' o 'solo extender, nunca acortar'. TTL devuelve -1 para claves sin expiración, -2 para claves inexistentes. La expiración es perezosa (comprobada al acceder) más barridos periódicos en segundo plano.

redis-cli
# set expiration on an existing key (seconds)
SET mykey "value"
EXPIRE mykey 60              # expires in 60 seconds
EXPIRE mykey 60 NX           # only set TTL if none exists (7.0+)
EXPIRE mykey 60 GT           # only set if new TTL > current (7.0+)
EXPIRE mykey 60 LT           # only set if new TTL < current (7.0+)

# set expiration in milliseconds
PEXPIRE mykey 60000

# set expiration at a Unix timestamp
EXPIREAT mykey 1700000000       # seconds
PEXPIREAT mykey 1700000000000    # milliseconds

# set value AND expiration atomically (preferred)
SET token "abc" EX 3600
SET token "abc" PX 3600000
SET token "abc" EXAT 1700000000

# get remaining TTL
TTL mykey          # seconds (-1 = no expiry, -2 = no key)
PTTL mykey         # milliseconds

PERSIST (quitar TTL)

PERSIST quita el TTL, haciendo la clave persistente (el valor permanece). GETEX (6.2+) devuelve atómicamente el valor y fija o quita el TTL — útil para refrescar la expiración de sesión al leer (GETEX clave EX 3600) o hacer permanente una clave temporal (GETEX clave PERSIST). COPY (6.2+) copia una clave, opcionalmente entre bases de datos, sin la carrera de GET+SET.

redis-cli
# remove expiration (make key persistent)
SET session "data" EX 3600
TTL session               # 3600
PERSIST session           # 1 (success)
TTL session               # -1 (no expiry)

# PERSIST returns 1 if the TTL was removed, 0 if key had no TTL or doesn't exist

# copy a key with optional TTL handling (6.2+)
COPY source dest               # copy without TTL
COPY source dest REPLACE       # overwrite destination
COPY source dest DB 1          # copy to another database

# GETEX: get value and optionally set/remove TTL (6.2+)
GETEX mykey EX 3600       # returns value, sets 3600s TTL
GETEX mykey PERSIST       # returns value, removes TTL

# note: PERSIST only removes TTL; the key and value remain

SAVE y BGSAVE (RDB)

SAVE bloquea al servidor hasta completar la instantánea — nunca lo uses en producción. BGSAVE bifurca el proceso (copy-on-write) para que el hilo principal no se bloquee, pero datasets grandes pueden causar picos de memoria durante el fork. Las reglas 'save' disparan instantáneas automáticas según la tasa de cambios. RDB es compacto e ideal para respaldos pero arriesga perder los datos escritos tras la última instantánea.

redis-cli
# SAVE: synchronous snapshot (BLOCKS the server until done)
SAVE                     # blocks — use only in maintenance windows

# BGSAVE: background snapshot (non-blocking, forks a child)
BGSAVE                   # returns immediately, saves in background
LASTSAVE                 # Unix timestamp of the last successful save

# check if a BGSAVE is in progress
INFO persistence | grep rdb_bgsave_in_progress

# configure automatic snapshots in redis.conf:
#   save 3600 1     # save if >= 1 key changed in 3600s
#   save 300 100    # save if >= 100 keys changed in 300s
#   save 60 10000   # save if >= 10000 keys changed in 60s
#   save ""         # disable RDB entirely

# RDB file location
CONFIG GET dbfilename    # "dump.rdb"
CONFIG GET dir           # "/var/lib/redis"

# RDB pros: compact, fast restart, great for backups
# RDB cons: potential data loss between snapshots

BGREWRITEAOF (compactación AOF)

AOF añade cada comando de escritura a un log — mucho más duradero que RDB (máximo 1 segundo de pérdida de datos con everysec). 'always' hace fsync en cada escritura (muy lento, úsalo solo para datos críticos). BGREWRITEAOF compacta el log (lo reescribe como el conjunto mínimo de comandos). Redis 7 usa un formato AOF de varias partes (RDB base + log incremental) — appenddirname guarda las partes.

redis-cli
# AOF: logs every write command (durable, replayable)
# enable in redis.conf:
#   appendonly yes
#   appendfilename "appendonly.aof"

# fsync policies:
#   appendfsync always    # fsync every write (safest, slowest)
#   appendfsync everysec  # fsync once per second (default, balanced)
#   appendfsync no        # let OS decide (fastest, risk of data loss)

# trigger AOF rewrite (compacts the log)
BGREWRITEAOF             # non-blocking, rewrites in background

# AOF auto-rewrite thresholds:
#   auto-aof-rewrite-percentage 100
#   auto-aof-rewrite-min-size 64mb

# check AOF status
INFO persistence | grep aof

# AOF pros: minimal data loss (1 sec max with everysec)
# AOF cons: larger files, slower load on restart

# Redis 7: multi-part AOF (base + incremental files)
CONFIG GET appenddirname   # "appendonlydir"

Configuración de persistencia

CONFIG SET cambia ajustes en runtime (sin reiniciar); CONFIG REWRITE los persiste en redis.conf. La configuración de producción recomendada es el híbrido RDB + AOF: RDB para un reinicio rápido y respaldos, AOF para pérdida mínima de datos. Desde Redis 7, el AOF empieza con una instantánea base RDB seguida de comandos incrementales — combinando carga rápida con durabilidad.

redis-cli
# view current persistence settings
CONFIG GET save
CONFIG GET appendonly
CONFIG GET appendfsync
CONFIG GET dir
CONFIG GET dbfilename
CONFIG GET appendfilename

# enable AOF at runtime
CONFIG SET appendonly yes

# change fsync policy at runtime
CONFIG SET appendfsync everysec

# disable RDB snapshots
CONFIG SET save ""

# persist config changes to redis.conf
CONFIG REWRITE

# hybrid persistence (recommended):
# RDB for fast restart + AOF for durability
# redis.conf:
#   save 3600 1
#   appendonly yes
#   aof-use-rdb-preamble yes   # RDB header in AOF (faster load)

# check persistence status
INFO persistence

Respaldo y restauración

Respalda el archivo RDB (compacto, rápido) regularmente — es una instantánea consistente incluso mientras Redis corre (copy-on-write). Para AOF, respalda el directorio appendonly completo (multiparte de Redis 7). Restaura deteniendo Redis, reemplazando los archivos y reiniciando. Para recuperarte de un comando erróneo, edita el AOF para quitarlo antes de reiniciar. redis-cli --rdb hace un respaldo en línea sin tocar el sistema de archivos directamente.

redis-cli
# backup: copy the RDB file while Redis runs
BGSAVE
# wait for LASTSAVE to update, then copy the file
cp /var/lib/redis/dump.rdb /backup/dump-$(date +%F).rdb

# AOF backup: copy the AOF manifest + files (Redis 7)
cp -r /var/lib/redis/appendonlydir /backup/

# restore: stop Redis, replace data files, restart
redis-cli SHUTDOWN
cp /backup/dump.rdb /var/lib/redis/dump.rdb
redis-server /etc/redis/redis.conf

# for point-in-time recovery from AOF:
# edit the AOF file to remove unwanted commands, then restart

# RDB file analysis (offline, safe)
redis-check-rdb /var/lib/redis/dump.rdb
redis-check-aof /var/lib/redis/appendonly.aof

# fix a truncated AOF
redis-check-aof --fix /var/lib/redis/appendonly.aof

# online backup with --rdb (dumps RDB to stdout/file)
redis-cli --rdb /backup/dump.rdb
09

Pub/Sub

SUBSCRIBE y UNSUBSCRIBE

SUBSCRIBE bloquea al cliente para recibir mensajes de uno o más canales. Un cliente suscrito solo puede llamar SUBSCRIBE/UNSUBSCRIBE/PSUBSCRIBE/PUNSUBSCRIBE/PING/QUIT — ningún otro comando. PUBSUB inspecciona el estado del pub/sub (canales activos, conteos de suscriptores). Los mensajes son fire-and-forget: si ningún suscriptor escucha, el mensaje se pierde. Para entrega fiable, usa Streams.

redis-cli
# subscribe to channels (in one client, blocks)
SUBSCRIBE news alerts

# the client now listens for messages:
# 1) "subscribe" 2) "news" 3) 1
# 1) "subscribe" 2) "alerts" 3) 2

# unsubscribe from specific channels
UNSUBSCRIBE news
UNSUBSCRIBE news alerts

# unsubscribe from ALL channels
UNSUBSCRIBE

# note: published messages are NOT persisted
# if no subscriber is listening, the message is lost
# for persistent messaging, use Streams instead

# count active subscriptions (in another client)
PUBSUB CHANNELS           # list active channels
PUBSUB NUMSUB news        # subscriber count for "news"

PUBLISH

PUBLISH devuelve el número de suscriptores que recibieron el mensaje (0 si ninguno). No hay forma de recuperar un mensaje tras publicarse — si ningún suscriptor escucha, se fue. PUBSUB CHANNELS lista los canales activos (los que tienen al menos un suscriptor); PUBSUB NUMSUB devuelve los conteos de suscriptores. Para mensajería fiable y reproducible, usa Streams (XADD/XREAD).

redis-cli
# publish a message to a channel (from another client)
PUBLISH news "Breaking: Redis 7.4 released"
# returns: number of subscribers that received the message

# publish to a channel with no subscribers
PUBLISH empty "hello"
# returns: 0 (message is lost)

# publish to multiple channels (separate PUBLISH calls)
PUBLISH news "msg1"
PUBLISH alerts "msg2"

# pub/sub has no persistence, no replay, no consumer groups
# subscribers must be connected to receive messages

# check how many clients are listening
PUBSUB NUMSUB news
PUBSUB NUMSUB news alerts    # multiple channels

# list active channels (with pattern)
PUBSUB CHANNELS              # all active channels
PUBSUB CHANNELS news:*       # channels matching pattern

PSUBSCRIBE (suscripción por patrón)

PSUBSCRIBE se suscribe a los canales que coincidan con patrones glob — potente para el enrutado de eventos (por ejemplo, user:*:login atrapa cada evento de login de usuario). Un mensaje que coincide tanto con una suscripción directa como con un patrón se entrega dos veces. Los suscriptores de patrón reciben eventos 'pmessage' con el patrón, el canal y el mensaje. PUNSUBSCRIBE cancela las suscripciones por patrón.

redis-cli
# subscribe to channels matching a glob pattern
PSUBSCRIBE news.*
PSUBSCRIBE user:*:login
PSUBSCRIBE events:*

# patterns use glob syntax:
#   *    matches any sequence
#   ?    matches one character
#   [ab] matches 'a' or 'b'

# unsubscribe from patterns
PUNSUBSCRIBE news.*
PUNSUBSCRIBE               # unsubscribe from ALL patterns

# a message matching both a direct subscription and a pattern
# is delivered twice (once for each)

# pattern subscribers receive:
# 1) "pmessage" 2) "news.*" 3) "news.tech" 4) "the message"

# use case: event routing
PSUBSCRIBE user:*:login       # all user logins
PSUBSCRIBE order:*:created    # all order creations
PSUBSCRIBE cache:*:invalidate # cache invalidation events

Pub/Sub fragmentado (7.0+)

El Pub/Sub fragmentado (7.0+) resuelve un problema del modo Cluster: el Pub/Sub regular difunde cada PUBLISH a la totalidad de los nodos del clúster, desperdiciando ancho de banda. El Pub/Sub fragmentado enruta los mensajes solo al fragmento que posee la clave del canal — mucho más eficiente en clústeres grandes. Usa SSUBSCRIBE/SPUBLISH en despliegues Cluster. El nombre del canal determina el fragmento (como una clave).

redis-cli
# regular Pub/Sub broadcasts to ALL cluster nodes (expensive)
# sharded Pub/Sub routes messages only to the shard owning the channel

# subscribe to a shard channel
SSUBSCRIBE mychannel

# publish to a shard channel
SPUBLISH mychannel "hello"

# sharded pub/sub uses the channel name for shard routing
# so messages only travel within one shard (more efficient)

# use sharded pub/sub in a Redis Cluster to avoid
# broadcasting messages to every node

# regular SUBSCRIBE/PUBLISH still work in cluster mode
# but they broadcast to all shards (cluster-wide overhead)

# check shard channel subscribers (7.0+)
PUBSUB SHARDCHANNELS
PUBSUB SHARDNUMSUB mychannel

Notificaciones de keyspace

Las notificaciones de keyspace permiten a los clientes reaccionar a eventos del ciclo de vida de claves (set, delete, expire, evict). Configúralas con notify-keyspace-events. Son fire-and-forget (sin persistencia) y no fiables — si el servidor Redis se reinicia, los eventos pendientes se pierden. Para el procesado fiable de eventos, usa Streams. Las notificaciones de keyspace son geniales para efectos secundarios como limpieza o calentamiento de caché.

redis-cli
# enable keyspace notifications (disabled by default)
CONFIG SET notify-keyspace-events "KEA"
# K = keyspace events, E = keyevent events
# g = generic (DEL, EXPIRE, ...), $ = string, l = list
# h = hash, s = set, z = sorted set, x = expired, e = evicted
# A = all except m (m = keymiss)

# subscribe to events on a specific key
SUBSCRIBE __keyspace@0__:mykey
# publishes "set", "del", "expire", etc.

# subscribe to events of a specific type
SUBSCRIBE __keyevent@0__:del
# publishes the key name that was deleted

# example: react when a key expires
SUBSCRIBE __keyspace@0__:session:abc
# receives "expired" when the key TTL ends

# example: react to all expired keys
SUBSCRIBE __keyevent@0__:expired

# check current setting
CONFIG GET notify-keyspace-events
10

Transacciones

MULTI y EXEC

MULTI/EXEC agrupa comandos en un bloque atómico y secuencial — ningún otro cliente puede intercalarse. Los comandos se encolan (devolviendo QUEUED) y se ejecutan juntos en EXEC. Un error de encolamiento (nombre de comando malo) aborta toda la transacción. Un error de runtime (tipo equivocado en una clave) se salta solo ese comando — el resto se ejecuta igual. Esto difiere de las transacciones SQL.

redis-cli
# MULTI starts a transaction; commands are queued
MULTI
SET counter 1
INCR counter
INCR counter
GET counter
EXEC
# returns: 1) OK  2) 2  3) 3  4) "3"

# all queued commands execute atomically (no interleaving)
# other clients cannot run commands between MULTI and EXEC

# each queued command returns "QUEUED" until EXEC
MULTI
SET x 1
# "QUEUED"
INCR x
# "QUEUED"
EXEC
# 1) OK 2) 2

# the transaction is atomic: all or nothing (at queuing time)

DISCARD (cancelar transacción)

DISCARD cancela una transacción, limpiando los comandos en cola y liberando la conexión del modo transacción. También limpia las claves WATCHed (ver WATCH). Tras DISCARD, el cliente puede emitir comandos normales de nuevo. DISCARD es el equivalente del 'rollback' — pero ojo, Redis no soporta la reversión parcial dentro de EXEC; los errores de runtime se saltan el comando que falla pero confirman el resto.

redis-cli
# DISCARD cancels a transaction (clears all queued commands)
MULTI
SET x 1
INCR x
DISCARD
# OK — no commands are executed

# after DISCARD, the connection returns to normal mode
GET x
# (nil) or the previous value — nothing changed

# DISCARD also clears all WATCHed keys
WATCH counter
MULTI
INCR counter
DISCARD
# counter is no longer watched

# you must call MULTI before DISCARD
DISCARD
# ERR DISCARD without MULTI

WATCH (bloqueo optimista)

WATCH implementa el bloqueo optimista: si una clave observada cambia entre WATCH y EXEC, la transacción se aborta (EXEC devuelve nil). Este es el patrón estándar de Redis para la atomicidad de lectura-modificación-escritura (ya que Redis no tiene locks de fila). Reintenta siempre ante nil. WATCH se comprueba en el momento de EXEC. UNWATCH cancela las observaciones (también ocurre en DISCONNECT). Una clave observada modificada por el mismo cliente también dispara el aborto.

redis-cli
# WATCH monitors keys; if any change before EXEC, transaction aborts
WATCH counter
val = GET counter          # read current value
MULTI
INCR counter               # queue the update
EXEC                       # nil if counter changed -> retry

# typical pattern: read-modify-write with retry
WATCH key
current = GET key
new_value = compute(current)
MULTI
SET key new_value
EXEC
# if EXEC returns nil, the key changed — loop and retry

# UNWATCH cancels all watches
UNWATCH

# WATCH is checked at EXEC time, not during queuing
# if a watched key is modified (by any client, including yourself),
# EXEC returns nil and the transaction is not executed

UNWATCH y casos límite de WATCH

Tras EXEC (ya sea que la transacción se confirmara o se abortara por WATCH), todas las observaciones se limpian automáticamente. Lo mismo con DISCARD. Para reintentar un bucle de bloqueo optimista, debes llamar a WATCH de nuevo antes del siguiente MULTI. WATCH dentro de MULTI es un error — WATCH siempre debe preceder a MULTI. UNWATCH es principalmente para cancelar observaciones sin entrar en una transacción.

redis-cli
# UNWATCH cancels all watches
WATCH key1 key2
UNWATCH                    # both keys are no longer watched

# WATCH inside a MULTI is not allowed (error)
MULTI
WATCH key
# ERR WATCH inside MULTI is not allowed

# after EXEC (success or abort), watches are cleared
WATCH key
MULTI
SET key "new"
EXEC
# key is no longer watched after EXEC

# after DISCARD, watches are cleared
WATCH key
MULTI
DISCARD
# key is no longer watched

# re-WATCH after EXEC to retry the optimistic lock loop
WATCH key
val = GET key
MULTI
SET key newval
EXEC
# if nil, loop: WATCH key again, GET, MULTI, SET, EXEC

Manejo de errores de transacción

Redis tiene dos tipos de error en las transacciones. Los errores de encolamiento (nombre/aridad de comando malos) abortan toda la transacción en el momento de EXEC (EXECABORT) — nada corre. Los errores de runtime (por ejemplo, INCR sobre un no entero) se saltan solo el comando que falla — el resto se ejecuta igual. NO hay rollback. Esta es una diferencia crítica con las bases de datos SQL. Valida tus datos antes de MULTI para evitar errores de runtime.

redis-cli
# two types of errors in transactions:

# 1. Queuing errors (bad command syntax) — aborts the WHOLE transaction
MULTI
SET key "value"
INCRBY key "notanumber"   # error during queuing (wrong arity/type at parse)
GET key
EXEC
# EXECABORT Transaction discarded because of previous errors.
# NOTHING executes — not even the SET

# 2. Runtime errors (wrong type at execution) — skips ONLY that command
SET key "stringvalue"
MULTI
INCR key                  # queues fine (syntax OK)
SET otherkey "ok"
EXEC
# 1) (error) ERR value is not an integer
# 2) OK
# the INCR failed but SET otherkey succeeded — no rollback!

# lesson: Redis transactions do NOT have rollback like SQL
11

Pipelining

Fundamentos del pipeline

El pipelining agrupa comandos para reducir los viajes de red — dramáticamente más rápido que los comandos individuales sobre una red. Cada viaje cuesta latencia de red (~0.1-1ms); 1000 comandos individuales = 100-1000ms, pero en pipeline = ~1ms. La mayoría de librerías cliente aportan un mecanismo pipeline/multi. redis-cli puede hacer pipeline vía stdin. El pipelining NO garantiza atomicidad — otros clientes pueden intercalarse.

redis-cli
# pipelining sends multiple commands in one network round-trip
# (no atomicity guarantee, just reduced latency)

# using redis-cli with stdin (simple pipeline):
printf '%s\n' "SET k1 v1" "SET k2 v2" "GET k1" | redis-cli
# OK
# OK
# "v1"

# using redis-cli --pipe (raw RESP, fastest for bulk loads):
# (see the data-import-export section for details)

# in a client library (e.g., Node.js with ioredis):
const pipe = redis.pipeline()
pipe.set("k1", "v1")
pipe.set("k2", "v2")
pipe.incr("counter")
const results = await pipe.exec()

# vs individual commands:
await redis.set("k1", "v1")    # round-trip 1
await redis.set("k2", "v2")    # round-trip 2
await redis.incr("counter")    # round-trip 3

MULTI vs pipelining

MULTI/EXEC garantiza atomicidad (ningún otro cliente puede intercalarse) Y la mayoría de librerías cliente lo encadenan automáticamente por pipeline (así que también obtienes menos viajes). El pipelining plano solo reduce viajes — otros clientes pueden ejecutar entre tus comandos en pipeline. Usa MULTI/EXEC cuando necesites atomicidad (por ejemplo, lectura-modificación-escritura con WATCH); usa pipelining plano para operaciones masivas donde el orden/atomicidad no importa.

redis-cli
# MULTI/EXEC: atomic (no interleaving), pipelined automatically
MULTI
SET k1 v1
SET k2 v2
INCR counter
EXEC
# all 3 commands run atomically as one block

# Pipelining: NOT atomic, just batched (other clients can interleave)
# (in client code)
pipe.set("k1", "v1")
pipe.set("k2", "v2")
pipe.incr("counter")
pipe.exec()
# commands may interleave with other clients

# when to use which:
# - need atomicity (all-or-nothing)?      -> MULTI/EXEC
# - just want speed (bulk operations)?    -> pipelining
# - both?                                  -> MULTI/EXEC (auto-pipelined)

# MULTI/EXEC is automatically pipelined by most clients
# so you get atomicity + batch round-trips in one

Protocolo RESP

RESP es el protocolo de cable de Redis — simple, basado en texto y rápido. *N denota un array de N elementos; $N una cadena masiva de N bytes; + una cadena simple; : un entero; - un error. El modo --pipe de redis-cli acepta RESP crudo para una carga masiva a máxima velocidad (mucho más rápido que comandos de texto vía stdin). Entender RESP ayuda a depurar y construir clientes personalizados.

redis-cli
# RESP (REdis Serialization Protocol) is the wire format
# redis-cli sends RESP; you can also send it raw with --pipe

# simple command (PING) in RESP:
# *1\r\n$4\r\nPING\r\n

# SET key value in RESP:
# *3\r\n$3\r\nSET\r\n$3\r\nkey\r\n$5\r\nvalue\r\n

# RESP types:
#   +OK      simple string
#   -ERR     error
#   :42      integer
#   $5\r\nhello   bulk string
#   *2\r\n...     array

# raw pipeline with RESP (fastest bulk insert):
# generate a RESP file and pipe it:
cat commands.resp | redis-cli --pipe

# --pipe mode expects raw RESP; checks reply counts
# output: "Last reply received from server: ..."
# "errors: 0, replies: N"

Pipeline en scripts de shell

El scripting de shell con redis-cli es una forma común de cargar datos en masa o correr operaciones por lotes. El enfoque más simple pasa comandos de texto vía stdin (echo/cat | redis-cli). Para máxima velocidad, genera RESP y usa el modo --pipe (un orden de magnitud más rápido para cargas grandes). Los ejemplos de bucles de bash muestran ambos enfoques — elige según tu volumen y necesidades de rendimiento.

redis-cli
# pipeline multiple commands via stdin
echo -e "SET k1 v1\nSET k2 v2\nGET k1\nGET k2" | redis-cli

# pipeline from a file
cat commands.txt | redis-cli

# pipeline with --pipe-mode (raw RESP, fastest)
# first generate RESP, then pipe:
redis-cli --pipe < commands.resp

# bulk insert example (bash, generate RESP):
for i in $(seq 1 1000); do
  printf '*3\r\n$3\r\nSET\r\n$4\r\nkey:\r\n$1\r\n%s\r\n' "$i"
done | redis-cli --pipe

# or simpler (text mode, slightly slower):
for i in $(seq 1 1000); do
  echo "SET key:$i value$i"
done | redis-cli

# --pipe-mode reports errors and throughput

Límites del pipeline y buenas prácticas

El pipelining es la palanca de rendimiento de Redis más grande, pero no lo exageres — las respuestas en cola consumen memoria tanto en cliente como en servidor. Lotea en grupos de 100-1000 comandos. Haz benchmark con redis-benchmark -P para hallar tu punto dulce (el rendimiento se estanca y la latencia aumenta con pipelines muy grandes). Para comandos que dependen de resultados previos, usa scripts Lua (atómicos, un solo viaje) en lugar de múltiples llamadas en pipeline.

redis-cli
# don't pipeline too many commands at once
# (queued replies consume memory on both client and server)

# bad: 1 million commands in one pipeline
# -> huge memory buffer, potential timeout

# good: batch in groups of 100-1000
for batch in chunks(data, 500):
  pipe = redis.pipeline()
  for item in batch:
    pipe.set(item.key, item.value)
  pipe.exec()

# benchmark pipelining
redis-benchmark -t set -n 100000 -P 16   # -P = pipeline size
# try -P 1, 10, 100, 1000 to find the sweet spot

# use pipelining for:
# - bulk imports
# - batch reads (MGET is better for simple multi-get)
# - pre-warming cache
# - reducing latency in high-RTT environments

# avoid pipelining for:
# - commands that depend on previous results (use Lua instead)
# - very large batches (split into chunks)
12

Scripting Lua

Fundamentos de EVAL

EVAL corre scripts Lua atómicamente — mientras corre un script, ningún otro comando se ejecuta, haciéndolo ideal para operaciones atómicas de varios pasos. KEYS y ARGV pasan datos de quien llama; nunca construyas claves por concatenación de cadenas en el script (viola las reglas del clúster — todas las claves deben ir en KEYS). redis.call lanza errores (detiene), redis.pcall los devuelve. Los scripts se cachean por su hash SHA1 para EVALSHA.

redis-cli
# EVAL: run a Lua script inline
# EVAL "script" numkeys key1 key2 ... arg1 arg2 ...
EVAL "return redis.call('GET', KEYS[1])" 1 mykey
# 1 = number of keys
# mykey = KEYS[1]

# run a simple script (no keys)
EVAL "return 42" 0
EVAL "return {1, 2, 3}" 0
EVAL "return 'hello'" 0

# a check-and-set script:
EVAL "
  local cur = redis.call('GET', KEYS[1])
  if cur == ARGV[1] then
    return redis.call('SET', KEYS[1], ARGV[2])
  end
  return 0
" 1 mykey "expected" "newvalue"

# redis.call() raises error if command fails (stops script)
# redis.pcall() returns error as a table (can handle)
EVAL "local ok, err = pcall(redis.call, 'GET', 'missing'); return err" 0

EVALSHA y SCRIPT LOAD

EVALSHA corre un script previamente cargado por su hash SHA1, evitando reenviar el cuerpo del script en cada llamada — una gran victoria de ancho de banda para apps que corren el mismo script repetidamente. Ante fallo de caché (tras SCRIPT FLUSH o reinicio), Redis devuelve NOSCRIPT; los clientes lo atrapan y recurren a EVAL + SCRIPT LOAD. Usa siempre librerías (redis-py, ioredis) que manejen esto transparentemente.

redis-cli
# load a script once, get its SHA1
SCRIPT LOAD "return redis.call('GET', KEYS[1])"
# returns: "fa00d1f0..." (the SHA1 hash)

# execute by hash (saves bandwidth on repeated calls)
EVALSHA "fa00d1f0..." 1 mykey

# check if a script is cached
SCRIPT EXISTS "fa00d1f0..." "abcd1234..."
# 1) 1  2) 0   (1 = exists, 0 = not cached)

# flush the script cache
SCRIPT FLUSH

# list all running scripts (during debug)
SCRIPT DEBUG SYNC   # blocking debug mode
SCRIPT DEBUG NO     # disable debugger

# typical client library pattern:
# 1. SCRIPT LOAD the script on startup
# 2. EVALSHA to run it (falls back to EVAL on NOSCRIPT error)

SCRIPT LOAD, FLUSH y EXISTS

SCRIPT LOAD cachea un script y devuelve su SHA1. SCRIPT EXISTS comprueba si los scripts están cacheados (útil tras un reinicio). SCRIPT FLUSH limpia los scripts cacheados — los EVALSHA siguientes devuelven NOSCRIPT. SCRIPT KILL detiene un script de larga ejecución, pero solo si aún no ha hecho escrituras (para mantener la consistencia); si las hizo, debes hacer SHUTDOWN NOSAVE. Los scripts son efímeros — usa Functions (7.0+) para persistencia.

redis-cli
# SCRIPT LOAD: load a script without running it
SCRIPT LOAD "return redis.call('SET', KEYS[1], ARGV[1])"
# returns the SHA1 hash

# SCRIPT EXISTS: check if scripts are cached (after load or restart)
SCRIPT EXISTS "abc123..." "def456..."
# 1) 1  2) 0

# SCRIPT FLUSH: clear the script cache
SCRIPT FLUSH
# all EVALSHA calls will now return NOSCRIPT until scripts are reloaded

# SCRIPT KILL: stop a running script (only if it hasn't written yet)
SCRIPT KILL

# if the script has already executed a write command:
# SHUTDOWN NOSAVE is the only way to stop it (extreme measure)

# scripts are ephemeral — they don't survive a restart
# use Redis Functions (7.0+) for persistent scripts

# check the script cache size
INFO memory | grep script_cache

KEYS y ARGV

KEYS[] lleva nombres de claves (esencial para el enrutado del clúster — el clúster las usa para determinar qué fragmento maneja el script). ARGV[] lleva valores y parámetros. Nunca fijes nombres de clave dentro del script (por ejemplo, redis.call('GET', 'mykey')) — esto rompe el enrutado del clúster porque el clúster no puede saber en qué fragmento vive 'mykey'. Pasa siempre las claves vía KEYS[]. El argumento numkeys le dice a Redis cuántas KEYS esperar.

redis-cli
# KEYS[]: key names passed to the script
# ARGV[]: additional arguments (values, options)

# example: atomic increment with cap
EVAL "
  local current = tonumber(redis.call('GET', KEYS[1]) or 0)
  local max = tonumber(ARGV[1])
  if current >= max then
    return -1  -- cap reached
  end
  return redis.call('INCR', KEYS[1])
" 1 counter 100
# KEYS[1] = counter, ARGV[1] = 100

# example: move item between lists atomically
EVAL "
  local item = redis.call('RPOP', KEYS[1])
  if item then
    redis.call('LPUSH', KEYS[2], item)
  end
  return item
" 2 source_list dest_list

# NEVER hardcode key names in scripts (breaks cluster routing)
# always pass keys via KEYS[] so the cluster can route correctly

Operaciones atómicas con Lua

Los scripts Lua son la forma canónica de hacer operaciones atómicas de varios comandos en Redis (sin carreras de MULTI/EXEC). Compare-and-set, adquisición de semáforos, migraciones de colas y rate limiting se benefician por igual. Los scripts bloquean al servidor mientras corren — mantenlos cortos y evita bucles sobre muchas claves (que pueden estancar a otros clientes). Para trabajo muy largo, usa Redis Functions (Redis 7.0+), que se declaran y versionan como procedimientos almacenados.

redis-cli
# atomic compare-and-set (only update if value matches)
EVAL "
  local cur = redis.call('GET', KEYS[1])
  if cur == ARGV[1] then
    return redis.call('SET', KEYS[1], ARGV[2])
  end
  return 0
" 1 mykey "expected" "newvalue"

# atomic 'decrement if positive' (semaphore / rate limit)
EVAL "
  local val = tonumber(redis.call('GET', KEYS[1]) or 0)
  if val > 0 then
    redis.call('DECR', KEYS[1])
    return 1
  end
  return 0
" 1 semaphore

# atomic list pop + push (move between queues)
EVAL "
  local item = redis.call('RPOP', KEYS[1])
  if item then
    redis.call('LPUSH', KEYS[2], item)
  end
  return item
" 2 source_queue dest_queue

# atomic rate limiter (fixed window)
EVAL "
  local count = redis.call('INCR', KEYS[1])
  if count == 1 then
    redis.call('EXPIRE', KEYS[1], ARGV[1])
  end
  return count
" 1 rate:user:1 60

Redis Functions (7.0+)

Functions (7.0+) mejora los scripts EVAL: están con nombre (no solo hasheados), organizadas en librerías y persisten entre reinicios (los scripts EVAL son efímeros). Esto las hace más fáciles de gestionar y desplegar. FCALL invoca una función por nombre. Functions es la forma moderna de añadir lógica atómica del lado del servidor. Como los scripts, deben ser deterministas para la replicación. FUNCTION DUMP/RESTORE habilita respaldo y migración.

redis-cli
# FUNCTIONS are named, versioned Lua scripts (better than EVAL)
# register a function library
FUNCTION LOAD '#!lua name=mylib
redis.register_function("my_set",
  function(keys, args)
    return redis.call("SET", keys[1], args[1])
  end
)'

# call a function by name
FCALL my_set 1 mykey "hello"

# list loaded libraries
FUNCTION LIST
FUNCTION LIST WITHCODE   # include source

# get the function's code (for backup)
FUNCTION DUMP

# delete a library
FUNCTION DELETE mylib

# restore from a dump (for migration)
FUNCTION RESTORE <payload>

# functions persist across restarts (unlike EVAL scripts)
# they're saved in RDB/AOF
13

Gestión de conexiones

CLIENT LIST

CLIENT LIST muestra cada cliente conectado con dirección, edad, tiempo inactivo, comando actual y flags — inestimable para hallar fugas o clientes atascados. El campo 'idle' ayuda a detectar conexiones abandonadas. 'cmd' muestra el último comando (útil para hallar a un cliente corriendo un comando lento). 'flags' indica el tipo de cliente (N=normal, M=master, S=slave/réplica, P=pubsub, b=bloqueado). Filtra por TYPE en 7.0+.

redis-cli
# list all connected clients
CLIENT LIST
# fields: id, addr, laddr, fd, name, age, idle, flags, db, cmd, ...

# filter by type (7.0+)
CLIENT LIST TYPE normal    # normal clients only
CLIENT LIST TYPE replica   # replicas
CLIENT LIST TYPE pubsub    # pub/sub subscribers

# filter by ID (7.0+)
CLIENT LIST ID 1 2 3

# output includes useful fields:
#   addr=10.0.0.1:12345   remote address
#   age=3600              seconds since connected
#   idle=0                seconds since last command
#   cmd=get               last command executed
#   db=0                  current database
#   flags=N               N=normal, M=master, S=slave, P=pubsub

# count connected clients
CLIENT LIST | wc -l

CLIENT SETNAME y GETNAME

CLIENT SETNAME etiqueta una conexión para poder identificarla en CLIENT LIST — esencial para depurar fugas de conexión en entornos de múltiples servicios. Fja el nombre justo después de conectar en tu app (por ejemplo, 'api-server:pid12345:pool1'). Los nombres aparecen en el campo 'name' de CLIENT LIST. Esto hace trivial hallar qué servicio posee una conexión atascada o con fuga.

redis-cli
# name your connection (for identification in CLIENT LIST)
CLIENT SETNAME "my-app-worker-1"

# get the current connection's name
CLIENT GETNAME

# in application code, set the name immediately after connecting:
# redis-cli example:
redis-cli CLIENT SETNAME "debug-session"

# names appear in CLIENT LIST output:
CLIENT LIST
# ... name=my-app-worker-1 ...

# names are useful for:
# - identifying which app/pool a connection belongs to
# - finding leaks (connections that should have been closed)
# - debugging stuck clients
# - naming conventions: app:hostname:pid or pool:name

# names are limited to a reasonable length and cannot contain spaces

CLIENT KILL

CLIENT KILL desconecta a la fuerza a un cliente — útil para quitar conexiones atascadas o con fuga. Mata por ADDR (ip:puerto), ID, TYPE o USER (ACL). MAXAGE (7.0+) mata a los clientes inactivos más de N segundos. SKIPME yes (por defecto) evita matar tu propia conexión. Usa CLIENT LIST primero para hallar el objetivo y luego CLIENT KILL para desconectarlo. Los kills son inmediatos (sin apagado elegante).

redis-cli
# kill a client by address
CLIENT KILL ADDR 10.0.0.1:12345

# kill a client by ID
CLIENT KILL ID 42

# kill by type (7.0+)
CLIENT KILL TYPE normal    # kill all normal clients
CLIENT KILL TYPE pubsub    # kill all pub/sub clients

# kill by user (ACL, 6.0+)
CLIENT KILL USER appuser

# kill by address with skip-me
CLIENT KILL ADDR 10.0.0.1:0 SKIPME yes   # don't kill myself

# kill all clients matching filters (7.0+)
CLIENT KILL TYPE normal MAXAGE 3600      # kill idle > 1h

# kill returns the number of clients killed
# use with caution — kills are immediate, no graceful shutdown

# common use: disconnect a stuck client consuming resources
CLIENT LIST
CLIENT KILL ID <id>

CLIENT ID e INFO

CLIENT ID devuelve un entero único nunca reutilizado para la conexión — útil para logging y correlación. CLIENT INFO da información detallada sobre tu propia conexión. CLIENT NO-EVICT (6.0+) protege las escrituras de un cliente de disparar la eviction (útil para escrituras críticas). CLIENT REPLY controla si el servidor envía respuestas (OFF para cargas masivas fire-and-forget, SKIP para un comando).

redis-cli
# get the current client's unique ID (never reused)
CLIENT ID

# get the current client's info (detailed)
CLIENT INFO
# id=42 addr=127.0.0.1:12345 laddr=127.0.0.1:6379 name= db=0 ...

# the ID is a monotonically increasing integer
# it's unique per connection and never reused
# useful for logging and tracking

# CLIENT NO-EVICT (6.0+): this client's writes won't trigger eviction
CLIENT NO-EVICT ON    # protect this client from eviction
CLIENT NO-EVICT OFF   # normal behavior

# CLIENT REPLY (6.0+): control reply mode
CLIENT REPLY ON       # normal replies
CLIENT REPLY OFF      # no replies
CLIENT REPLY SKIP     # skip reply for next command only

# CLIENT UNPAUSE: resume processing after CLIENT PAUSE
CLIENT UNPAUSE

CLIENT PAUSE

CLIENT PAUSE bloquea la ejecución de comandos para el resto de clientes durante N milisegundos — útil para instantáneas seguras, migraciones y failovers de clúster. El modo WRITE (7.0+) pausa solo las escrituras permitiendo que las lecturas continúen (menos disruptivo). El cliente que pausa no se bloquea. Durante la pausa, los comandos en cola consumen memoria, así que mantén las pausas cortas. CLIENT UNPAUSE reanuda de inmediato.

redis-cli
# pause all client processing for N milliseconds
CLIENT PAUSE 10000         # pause for 10 seconds
# all other clients' commands are queued, not executed

# pause modes (7.0+):
CLIENT PAUSE 10000 ALL        # pause all commands (default)
CLIENT PAUSE 10000 WRITE      # pause only writes (reads continue)

# resume processing immediately
CLIENT UNPAUSE

# use cases:
# - safe snapshot/migration (pause writes, take consistent backup)
# - cluster failover (pause to ensure clean handoff)
# - debugging (pause to inspect state)

# during pause:
# - commands from OTHER clients are queued (memory grows)
# - the pausing client can still run commands
# - paused commands execute when the pause ends

# check if a pause is active
CLIENT INFO | grep flags
# 'P' flag = paused

Límites de conexiones y timeout

maxclients acota las conexiones concurrentes (10000 por defecto) — súbelo si tienes muchos servidores de app o pools de conexiones. timeout desconecta a los clientes inactivos (0 = nunca; fja 300s por seguridad). tcp-keepalive detecta conexiones TCP muertas (300s por defecto). Cada cliente consume memoria para su búfer de salida — monitorea con INFO clients. client-output-buffer-limit evita que un cliente lento consuma toda la memoria del servidor (especialmente importante para pub/sub y réplicas).

redis-cli
# max concurrent clients
CONFIG GET maxclients        # default 10000
CONFIG SET maxclients 50000  # increase limit

# timeout: disconnect idle clients after N seconds
CONFIG GET timeout           # default 0 (never)
CONFIG SET timeout 300       # 5 minutes

# TCP keepalive (detect dead connections)
CONFIG GET tcp-keepalive     # default 300
CONFIG SET tcp-keepalive 60

# when maxclients is reached, new connections are rejected
# error: "ERR max number of clients reached"

# check current client count vs limit
INFO clients
# connected_clients:150
# blocked_clients:5
# maxclients:10000

# each connection uses memory (~a few KB for the output buffer)
# monitor for output buffer growth:
INFO clients | grep client_recent_max_output_buffer

# set output buffer limits (prevent one client from using all memory)
CONFIG GET client-output-buffer-limit
14

Gestión del servidor

Secciones de INFO

INFO es el comando de monitoreo principal — reporta memoria, clientes, replicación, persistencia y estadísticas de una vez. Filtra secciones (INFO memory) para reducir la salida. Métricas clave: used_memory_rss (huella real), mem_fragmentation_ratio (ideal ~1.0-1.5), connected_clients, instantaneous_ops_per_sec, keyspace_hits/misses (tasa de aciertos de caché). TIME devuelve la hora del servidor para sincronización de relojes.

redis-cli
# comprehensive server information
INFO                  # all sections
INFO server           # version, uptime, config
INFO clients          # connected clients
INFO memory           # memory usage, fragmentation
INFO persistence      # RDB/AOF status
INFO stats            # ops/sec, hit rate, keyspace
INFO replication      # primary/replica state
INFO cpu              # CPU usage
INFO keyspace         # keys per database
INFO commandstats     # command frequency
INFO errorstats       # error frequency

# get a specific metric
INFO memory | grep used_memory_human
INFO stats | grep instantaneous_ops_per_sec
INFO replication | grep role

# check Redis version and mode
INFO server | grep redis_version
INFO server | grep redis_mode        # standalone, cluster, sentinel

# get server time
TIME                    # [unix_timestamp, microseconds]

CONFIG GET y SET

CONFIG SET cambia ajustes en runtime sin reiniciar Redis — ideal para ajustar. CONFIG GET recupera los valores actuales (usa patrones como CONFIG GET *memory*). Ajustes comunes de runtime: maxmemory + política de eviction, umbral de slowlog, timeout, umbrales de codificación. Algunos ajustes no son cambiables en runtime (por ejemplo, puerto y dirección de bind exigen reinicio). Prueba siempre los cambios de configuración en staging primero.

redis-cli
# view config (runtime changes with CONFIG SET)
CONFIG GET maxmemory
CONFIG GET maxmemory-policy
CONFIG GET save
CONFIG GET appendonly
CONFIG GET requirepass

# change config at runtime (no restart needed)
CONFIG SET maxmemory 4gb
CONFIG SET maxmemory-policy allkeys-lru
CONFIG SET slowlog-log-slower-than 10000   # 10ms in microseconds
CONFIG SET timeout 300

# view all config (large output)
CONFIG GET *

# get a specific pattern
CONFIG GET *max*
CONFIG GET *timeout*

# common runtime tweaks:
CONFIG SET maxclients 20000
CONFIG SET hash-max-listpack-entries 256
CONFIG SET appendfsync everysec

CONFIG REWRITE

CONFIG REWRITE persiste los cambios de CONFIG SET de runtime de vuelta a redis.conf — el archivo se actualiza en el sitio, conservando comentarios y estructura. Esto une el hueco entre los cambios de runtime y la persistencia entre reinicios. Respalda siempre redis.conf antes de REWRITE (rara vez causa problemas, pero seguridad primero). Versiona tu redis.conf para poder rastrear y auditar los cambios a lo largo del tiempo.

redis-cli
# persist config changes to redis.conf
CONFIG REWRITE

# after CONFIG SET maxmemory 4gb
# CONFIG REWRITE updates redis.conf to include:
#   maxmemory 4gb

# the original redis.conf is updated in-place
# comments and structure are preserved

# view the config file path
CONFIG GET *

# typical redis.conf (production):
# bind 127.0.0.1
# protected-mode yes
# port 6379
# maxmemory 4gb
# maxmemory-policy allkeys-lru
# save 3600 1
# appendonly yes
# appendfsync everysec
# tcp-keepalive 300
# timeout 0

# always back up redis.conf before CONFIG REWRITE

SLOWLOG

SLOWLOG registra los comandos más lentos que el umbral configurado (10ms = 10000us por defecto) — inestimable para hallar a los culpables de la latencia. Fija el umbral a tu SLO (por ejemplo, 5ms). Comandos lentos comunes: KEYS, SMEMBERS en sets enormes, HGETALL en hashes enormes, SORT sobre datos grandes. slowlog-max-len acota el log (128 por defecto). Fija el umbral a 0 para registrar la totalidad (solo depuración — sobrecarga alta).

redis-cli
# configure slow log (threshold in microseconds)
CONFIG SET slowlog-log-slower-than 10000   # 10ms (10000 us)
CONFIG SET slowlog-max-len 128             # keep last 128 entries

# view slow commands
SLOWLOG GET          # last 10 (default)
SLOWLOG GET 5        # last 5
SLOWLOG GET 0        # all entries

# each entry:
# 1) id              unique ID
# 2) timestamp       Unix time
# 3) duration        microseconds
# 4) command         the command and args
# 5) client          address:port
# 6) client name     if set

# slowlog length
SLOWLOG LEN

# reset (clear all entries)
SLOWLOG RESET

# set threshold to 0 to log ALL commands (debugging)
# set to -1 to disable
CONFIG SET slowlog-log-slower-than 0

MONITOR

MONITOR transmite en tiempo real cada comando de cada cliente — una herramienta de depuración potente pero con un impacto de rendimiento ENORME (aproximadamente reduce a la mitad el rendimiento). NUNCA uses MONITOR en producción salvo necesidad absoluta y solo brevemente. Es perfecto para staging: conecta MONITOR, reproduce el problema y ve exactamente qué comandos envía tu app. Para producción, usa SLOWLOG, LATENCY MONITOR o INFO commandstats en su lugar.

redis-cli
# MONITOR: real-time log of ALL commands (debugging only!)
MONITOR
# every command from every client is printed:
# 1700000000.123456 [0 10.0.0.1:12345] "SET" "key" "value"
# 1700000000.123567 [0 10.0.0.1:12345] "GET" "key"

# to stop monitoring, send any non-MONITOR command or disconnect
# press Ctrl+C in redis-cli

# WARNING: MONITOR has a HUGE performance impact
# it roughly halves throughput — use only for debugging

# use cases:
# - debugging what commands an app is sending
# - auditing command patterns
# - finding the source of unexpected writes

# safer alternatives for production:
# - SLOWLOG (only slow commands)
# - LATENCY MONITOR (specific events)
# - COMMANDSTATS in INFO (command frequency)

# MONITOR is best used in a staging/dev environment

Monitoreo LATENCY

LATENCY MONITOR rastrea los eventos de latencia (fja un umbral, por ejemplo, 100ms). LATENCY DOCTOR analiza los eventos recientes y sugiere arreglos — un gran punto de partida para el diagnóstico. Eventos comunes: 'command' (comandos lentos), 'fork' (retardo del fork de BGSAVE), 'expire-cycle' (barrido de expiración), 'aof-write' (retardo del fsync de AOF). LATENCY GRAPH muestra una línea de tiempo ASCII. Fja el umbral a tu SLO y monitorea regularmente.

redis-cli
# enable latency monitoring (threshold in ms)
CONFIG SET latency-monitor-threshold 100   # 100ms

# view latency events
LATENCY HISTORY event-name
LATENCY LATEST                            # most recent events
LATENCY HISTORY command
LATENCY HISTORY expire-cycle

# ASCII art graph of an event
LATENCY GRAPH command

# human-readable diagnosis and recommendations
LATENCY DOCTOR

# reset latency data
LATENCY RESET
LATENCY RESET event-name

# common events to monitor:
#   command         slow commands
#   fast-command    slow O(1) commands
#   expire-cycle    expiration cycle taking too long
#   fork            BGSAVE/BGREWRITEAOF fork taking too long
#   aof-write       AOF write delays
#   unlink          async delete delays

# check current threshold
CONFIG GET latency-monitor-threshold
15

Cluster

CLUSTER INFO

CLUSTER INFO da un resumen rápido de salud: cluster_state debería ser 'ok' (los 16384 slots cubiertos), cluster_slots_ok debería igualar 16384. cluster_known_nodes es el conteo total de nodos; cluster_size el número de primarios. Si cluster_state es 'fail', algunos slots no están disponibles (probablemente un primario y su réplica ambos caídos). Compruébalo desde cualquier nodo — la información es del clúster completo.

redis-cli
# cluster-wide health
CLUSTER INFO
# key fields:
#   cluster_state:ok              # ok or fail
#   cluster_slots_assigned:16384  # total slots
#   cluster_slots_ok:16384        # slots covered
#   cluster_known_nodes:6         # total nodes
#   cluster_size:3                # number of primaries
#   cluster_current_epoch:7
#   cluster_my_epoch:1

# cluster_state:ok means all slots are covered
# cluster_state:fail means some slots are unavailable

# check from any node in the cluster
redis-cli -p 7000 CLUSTER INFO

# other cluster commands require being in cluster mode
# (redis-server --cluster-enabled yes)

CLUSTER NODES

CLUSTER NODES es la vista definitiva de la topología — una línea por nodo con ID, dirección, rol (master/slave), el master que sigue (para réplicas) y rangos de slots. Busca los flags 'fail' o 'fail?' que indican nodos insanos. Los rangos de slots muestran qué primario posee qué slots de hash (0-16383). CLUSTER SHARDS (7.0+) agrupa los nodos por fragmento (primario + sus réplicas).

redis-cli
# view the full cluster topology
CLUSTER NODES
# each line is a node:
# <id> <addr:port@cport> <flags> <master> <ping-sent> <pong-recv> <epoch> <link> <slots>

# flags include:
#   M  = master (primary)
#   S  = slave (replica)
#   mymaster = the node this replica follows
#   fail? = suspected down
#   fail  = confirmed down
#   handshake = new node joining
#   nofailover = failover disabled

# example output:
# 1a2b... 127.0.0.1:7000@17000 myself,master - 0 0 1 connected 0-5460
# 3c4d... 127.0.0.1:7001@17001 master - 0 0 2 connected 5461-10922
# 5e6f... 127.0.0.1:7002@17002 master - 0 0 3 connected 10923-16383
# 7g8h... 127.0.0.1:7003@17003 slave 1a2b... 0 0 4 connected

# count nodes by type
CLUSTER NODES | grep -c master
CLUSTER NODES | grep -c slave

# Redis 7.0+: shard view
CLUSTER SHARDS

CLUSTER KEYSLOT y COUNTKEYSINSLOT

CLUSTER KEYSLOT muestra a qué slot se mapea una clave (CRC16 % 16384). Los hash tags ({...}) fuerzan que claves relacionadas caigan en el mismo slot — esencial para operaciones multi-clave (MGET, transacciones, scripts Lua) en un clúster. Usa redis-cli -c (modo clúster) para seguir automáticamente las redirecciones MOVED. CLUSTER GETKEYSINSLOT recupera las claves de un slot (usado durante el re-fragmentado).

redis-cli
# get the hash slot for a key
CLUSTER KEYSLOT mykey       # e.g., 1234
# CRC16(key) % 16384

# count keys in a specific slot (on the owning node)
CLUSTER COUNTKEYSINSLOT 1234

# get keys in a slot (must be run on the slot's owning node)
CLUSTER GETKEYSINSLOT 1234 10   # up to 10 keys

# in a cluster, keys must be on the same slot for multi-key ops
# use hash tags to force keys to the same slot:
SET {user:1}:profile "alice"
SET {user:1}:cart "items"
# both map to the same slot (the part inside {})

# CLUSTER KEYSLOT {user:1}:profile
# CLUSTER KEYSLOT {user:1}:cart
# same result -> same slot -> same shard

# if you access a key on the wrong node, you get a MOVED redirect:
# (error) MOVED 1234 127.0.0.1:7000
# redis-cli -c follows redirects automatically

Hash tags

Los hash tags ({...}) fuerzan claves al mismo slot, habilitando operaciones multi-clave en un clúster. Pero úsalos con criterio — abusar de un tag (por ejemplo, {users}:1, {users}:2) crea un punto caliente en un fragmento. Diseña los hash tags alrededor de los patrones de acceso: agrupa las claves accedidas juntas (los datos de un usuario, los ítems de un pedido) pero mantén separadas las claves no relacionadas. Este es el reto central de modelado de datos del clúster.

redis-cli
# hash tags: the substring inside {} determines the slot
# {user:1}:profile and {user:1}:cart share a slot

# enabling multi-key operations in a cluster:
MSET {user:1}:name "Alice" {user:1}:age 30   # OK (same slot)
MSET user:1:name "Alice" user:2:age 30       # CROSSSLOT error

# transactions across keys (must be same slot)
WATCH {order:1}:items
MULTI
HINCRBY {order:1}:items product:1 1
HINCRBY {order:1}:total 10
EXEC

# Lua scripts accessing multiple keys (all keys must share a slot)
EVAL "..." 2 {user:1}:a {user:1}:b

# design hash tags carefully:
# - too broad -> hotspots (one shard overloaded)
#   e.g., {users}:1, {users}:2 -> all on one shard (bad!)
# - too narrow -> can't do multi-key ops
#   e.g., user:1:a, user:1:b -> different slots (can't MGET)

# good: {user:1}:* groups one user's data on one shard
# bad:  {all-users}:* puts everyone on one shard

CLUSTER FAILOVER

El failover del clúster es automático cuando un primario es inalcanzable más allá de cluster-node-timeout (15s por defecto). El failover manual es para mantenimiento (actualizaciones sin tiempo de inactividad): FAILOVER es elegante (espera la sincronización de replicación), FORCE se salta la sincronización (más rápido, leve riesgo de pérdida de datos), TAKEOVER se salta el consenso (solo emergencias, riesgo de split-brain). Tras el failover, el primario antiguo se convierte en réplica cuando regresa. Corre siempre con réplicas en producción.

redis-cli
# when a primary fails, its replica is promoted automatically
# manual failover (for maintenance), run on the REPLICA:
redis-cli -p 7001 CLUSTER FAILOVER         # graceful (waits for sync)
redis-cli -p 7001 CLUSTER FAILOVER FORCE   # without primary agreement (faster)
redis-cli -p 7001 CLUSTER FAILOVER TAKEOVER # force, may split brain (emergency)

# graceful failover steps:
# 1. replica stops syncing from master
# 2. master stops accepting writes
# 3. replica catches up on replication offset
# 4. replica is promoted to master
# 5. cluster is updated with new master info
# 6. old master becomes a replica when it returns

# CLUSTER RESET resets a node (HARD removes all data)
CLUSTER RESET HARD
CLUSTER RESET SOFT

# check failover status
CLUSTER INFO | grep cluster_state

# rolling upgrade pattern:
# for each replica: CLUSTER FAILOVER (becomes master), upgrade old master

Herramienta redis-cli --cluster

La herramienta redis-cli --cluster maneja operaciones complejas de clúster: creación, re-fragmentado, reequilibrio, añadir/quitar nodos, comprobaciones de salud y reparaciones. --cluster check es tu referencia para verificar la salud del clúster tras cambios. --cluster fix autorepara problemas menores (slots huérfanos, etc.). --cluster call corre un comando en cada nodo. Usa estas herramientas en lugar de comandos CLUSTER manuales para tareas operativas.

redis-cli
# create a cluster (6 nodes: 3 primaries + 3 replicas)
redis-cli --cluster create \
  host1:7000 host2:7000 host3:7000 \
  host1:7001 host2:7001 host3:7001 \
  --cluster-replicas 1

# check cluster health
redis-cli --cluster check host1:7000

# repair issues
redis-cli --cluster fix host1:7000

# reshard (move slots between nodes)
redis-cli --cluster reshard host1:7000
# prompts for: how many slots, target node, source nodes

# rebalance slots across all nodes
redis-cli --cluster rebalance host1:7000

# add a new node
redis-cli --cluster add-node newhost:7000 host1:7000

# add a replica
redis-cli --cluster add-node newhost:7001 host1:7000 \
  --cluster-slave --cluster-master-id <nodeId>

# remove a node (migrates its slots first)
redis-cli --cluster del-node host1:7000 <nodeId>

# call a command on all nodes
redis-cli --cluster call host1:7000 INFO server
16

Sentinel (HA)

Configuración de Sentinel

Sentinel aporta HA sin fragmentar: monitorea a un primario, promociona a una réplica ante fallo y reconfigura a los clientes. El quorum (el último número) es cuántos sentinels deben concordar que el primario está caído — fja (N/2)+1 para N sentinels. Despliega 3 sentinels en máquinas separadas por tolerancia a fallos. down-after-milliseconds debería ser > al jitter de red; demasiado bajo causa failovers falsos.

redis-cli
# Sentinel monitors a primary + replicas, handles failover
# sentinel.conf (port 26379):
sentinel monitor mymaster 192.168.1.10 6379 2
# name, host, port, quorum (number of sentinels to agree on failure)

sentinel down-after-milliseconds mymaster 30000   # 30s to declare down
sentinel failover-timeout mymaster 180000         # 3min failover timeout
sentinel parallel-syncs mymaster 1                # replicas to resync in parallel

# start a sentinel:
redis-sentinel /etc/redis/sentinel.conf
# or:
redis-server /etc/redis/sentinel.conf --sentinel

# deploy at least 3 sentinels (odd number) for quorum
# sentinels communicate with each other and the Redis nodes

# connect to a sentinel to find the current primary:
redis-cli -p 26379 SENTINEL get-master-addr-by-name mymaster

# sentinel auto-discovers other sentinels and replicas

SENTINEL masters y réplicas

SENTINEL masters lista cada primario monitoreado; SENTINEL master <nombre> da detalles (incluidos num-slaves y num-other-sentinels). SENTINEL replicas muestra las réplicas; SENTINEL sentinels muestra los sentinels pares. ckquorum verifica que tienes suficientes sentinels para un quorum — corre esto en el monitoreo. Todas las librerías cliente principales de Redis soportan Sentinel de forma nativa (consultan a los sentinels para hallar al primario actual).

redis-cli
# query sentinel state
redis-cli -p 26379 SENTINEL masters          # all monitored primaries
redis-cli -p 26379 SENTINEL master mymaster  # details of one primary
# fields: name, ip, port, runid, role, ...
#   num-slaves, num-other-sentinels
#   quorum, down-after-milliseconds
#   failover-timeout, parallel-syncs

# list replicas of a master
redis-cli -p 26379 SENTINEL replicas mymaster

# list other sentinels monitoring the same master
redis-cli -p 26379 SENTINEL sentinels mymaster

# count monitoring sentinels (should be >= quorum)
redis-cli -p 26379 SENTINEL sentinels mymaster | grep -c name

# check the number of OK sentinels
SENTINEL ckquorum mymaster
# "OK 3 usable Sentinels. Quorum and failover authorization can be reached"
# or "NOQUORUM" warning (not enough sentinels)

SENTINEL get-master-addr-by-name

SENTINEL get-master-addr-by-name devuelve la IP y el puerto del primario actual — los clientes lo llaman para descubrir al primario y luego conectarse. Ante failover, los sentinels devuelven la dirección del primario nuevo. Los clientes deberían suscribirse a los eventos +switch-master para enterarse de los failovers de inmediato. Este patrón de descubrimiento está integrado en el modo Sentinel de todas las librerías cliente principales de Redis.

redis-cli
# find the current primary address
redis-cli -p 26379 SENTINEL get-master-addr-by-name mymaster
# 1) "192.168.1.10"
# 2) "6379"

# clients use this to discover the current primary
# on failover, the sentinel returns the new primary's address

# clients should connect to sentinels, NOT directly to the primary
# libraries: redis-py, jedis, ioredis all support sentinel mode

# example client connection (pseudo-code):
# 1. connect to a sentinel
# 2. SENTINEL get-master-addr-by-name mymaster
# 3. connect to the returned primary
# 4. on connection error, repeat from step 1

# monitor for failover events
redis-cli -p 26379 SUBSCRIBE +switch-master
# publishes: mymaster 192.168.1.10 6379 192.168.1.11 6379

# other events:
redis-cli -p 26379 SUBSCRIBE +failover-state
redis-cli -p 26379 SUBSCRIBE +sdown
redis-cli -p 26379 SUBSCRIBE +odown

SENTINEL failover

SENTINEL failover dispara un failover manual (para actualizaciones rodantes/mantenimiento). El failover automático ocurre cuando un primario está caído más que down-after-milliseconds. El failover es automático pero causa una breve interrupción de escritura (segundos). El líder sentinel electo elige la réplica más actualizada para promocionar. Cuando el primario antiguo regresa, se convierte en réplica — las escrituras que aceptó durante la partición de red se PIERDEN (riesgo de split-brain).

redis-cli
# force a manual failover (for maintenance)
SENTINEL failover mymaster
# triggers failover: promotes a replica to primary

# the failover process:
# 1. sentinels mark primary SDOWN (subjectively down)
# 2. quorum agrees -> ODOWN (objectively down)
# 3. a sentinel is elected leader
# 4. leader picks the best replica (most up-to-date)
# 5. promotes the replica: REPLICAOF NO ONE
# 6. reconfigures other replicas to follow the new primary
# 7. updates sentinel configs with the new primary address
# 8. clients reconnect via sentinel discovery

# during failover, writes fail briefly (seconds)
# reads from replicas continue (if the app uses them)

# the old primary, when it returns, is reconfigured as a replica
# of the new primary (its writes during partition are lost)

# monitor failover events:
redis-cli -p 26379 SUBSCRIBE +switch-master
redis-cli -p 26379 SUBSCRIBE +failover-*

Quorum y monitoreo de Sentinel

El quorum es el número de sentinels que deben concordar que el primario está caído antes de disparar el failover — fja la mayoría (N/2+1) para N sentinels. ckquorum verifica que tienes suficiente. down-after-milliseconds debería ser > al jitter de red (30s es seguro). failover-timeout acota la duración del failover. parallel-syncs controla cuántas réplicas se resincronizan simultáneamente (1 = seguro pero lento). Los sentinels actualizan su configuración solos ante cambios de topología.

redis-cli
# quorum: number of sentinels that must agree a master is down
# set in sentinel monitor command:
sentinel monitor mymaster 192.168.1.10 6379 2
#                                          ^ quorum = 2

# for 3 sentinels: quorum = 2 (majority)
# for 5 sentinels: quorum = 3 (majority)

# check quorum status
SENTINEL ckquorum mymaster
# "OK 3 usable Sentinels" or "NOQUORUM"

# tune down-after-milliseconds (time before declaring down)
sentinel down-after-milliseconds mymaster 30000   # 30s default

# tune failover-timeout (max time for failover to complete)
sentinel failover-timeout mymaster 180000   # 3min default

# parallel-syncs: how many replicas resync simultaneously
sentinel parallel-syncs mymaster 1   # 1 at a time (safe, slow)

# view sentinel configuration
SENTINEL masters
SENTINEL master mymaster

# reset a master's state (clears discovered replicas/sentinels)
SENTINEL reset mymaster

# Sentinel automatically updates its config file when topology changes
17

Monitoreo

Comando MONITOR

MONITOR transmite en tiempo real cada comando de cada cliente. El formato de salida es: marca_de_tiempo [db direccion_cliente] "comando" "args". Es inestimable para depurar qué comandos está enviando realmente una app. Pero aproximadamente reduce a la mitad el rendimiento — úsalo solo en staging/dev o para depuración breve de producción. Filtra con grep para patrones concretos. Para monitoreo de producción, usa SLOWLOG, INFO commandstats o LATENCY MONITOR en su lugar.

redis-cli
# MONITOR: real-time log of ALL commands (debugging only!)
MONITOR
# every command from every client is printed:
# 1700000000.123456 [0 10.0.0.1:12345] "SET" "key" "value"
# 1700000000.123567 [0 10.0.0.1:12345] "GET" "key"

# format: <unix_time> [<db> <addr>] "<cmd>" "<arg>" ...
# the [0 ...] shows which database and client

# to stop monitoring: Ctrl+C or send any command

# filter for specific patterns (in another terminal):
redis-cli MONITOR | grep "SET"
redis-cli MONITOR | grep "10.0.0.1"
redis-cli MONITOR | grep -E "(SET|DEL)"

# WARNING: MONITOR roughly halves throughput
# use only for debugging, never in production

# safer alternatives:
# - SLOWLOG (only slow commands)
# - INFO commandstats (command frequency)
# - LATENCY MONITOR (latency events)

Monitoreo LATENCY

LATENCY MONITOR rastrea los picos de latencia por tipo de evento. Fja un umbral (por ejemplo, 100ms) y Redis registra los eventos que lo excedan. LATENCY DOCTOR analiza los eventos recientes y sugiere arreglos — un gran punto de partida para el diagnóstico. LATENCY GRAPH muestra una línea de tiempo ASCII. Culpables comunes: 'fork' (BGSAVE en datasets grandes), 'expire-cycle' (expiración masiva), 'aof-fsync-always' (fsync de AOF). Fja el umbral a tu SLO y monitorea regularmente.

redis-cli
# enable latency monitoring (threshold in ms)
CONFIG SET latency-monitor-threshold 100   # 100ms

# view recent latency events
LATENCY LATEST
# event, timestamp, last latency, max latency

# history of an event
LATENCY HISTORY command
LATENCY HISTORY expire-cycle
LATENCY HISTORY fork

# ASCII art graph
LATENCY GRAPH command

# human-readable diagnosis and recommendations
LATENCY DOCTOR

# reset latency data
LATENCY RESET
LATENCY RESET command

# common events:
#   command         slow commands (over threshold)
#   fast-command    slow O(1)/O(log N) commands
#   expire-cycle    key expiration sweep too slow
#   fork            BGSAVE/BGREWRITEAOF fork delay
#   aof-fsync-always  AOF fsync delay
#   unlink          async delete delay

# check threshold
CONFIG GET latency-monitor-threshold

MEMORY DOCTOR y STATS

MEMORY USAGE reporta bytes para una clave (SAMPLES 0 para exactitud total). MEMORY STATS da estadísticas detalladas del asignador. MEMORY DOCTOR aporta diagnóstico automatizado (busca fragmentación, claves grandes, etc.). Vigila mem_fragmentation_ratio: >1.5 desperdicia memoria (fragmentación), <1 significa que Redis está haciendo swap (catastrófico para la latencia). MEMORY PURGE intenta devolver memoria al sistema operativo. La defragmentación activa (4.0+) recupera automáticamente la memoria fragmentada.

redis-cli
# MEMORY USAGE: bytes used by a single key
MEMORY USAGE mykey
MEMORY USAGE bigset SAMPLES 0   # exact (default samples for large keys)

# MEMORY STATS: detailed allocator stats
MEMORY STATS

# MEMORY DOCTOR: automated memory diagnosis
MEMORY DOCTOR

# MEMORY MALLOC-STATS: low-level allocator stats (jememalloc)
MEMORY MALLOC-STATS

# check total memory used
INFO memory | grep used_memory_human

# key metrics to watch:
#   used_memory             logical bytes used
#   used_memory_rss         RSS from OS (real footprint)
#   used_memory_peak        peak usage
#   mem_fragmentation_ratio >1.5 = fragmentation, <1 = swapping (bad!)

# MEMORY PURGE: attempt to free memory back to OS
MEMORY PURGE

# active defragmentation (4.0+)
CONFIG SET activedefrag yes

Comandos DEBUG

Los comandos DEBUG son para diagnóstico y pruebas — úsalos con cuidado. DEBUG SLEEP prueba cómo maneja la latencia tu app (bloquea al servidor). DEBUG OBJECT revela la codificación interna y el refcount de una clave. DEBUG RELOAD guarda, vacía y recarga el dataset (útil para probar la persistencia). Son potentes pero peligrosos — restríngelos con ACLs en producción (la categoría -@admin o -@dangerous). Nunca corras DEBUG en un primario de producción sin entender el impacto.

redis-cli
# DEBUG SLEEP: block the server for N seconds (testing only!)
DEBUG SLEEP 2             # blocks for 2 seconds (testing latency)

# DEBUG OBJECT: raw internal info about a key
DEBUG OBJECT mykey
# Value at:0x7f... refcount:1 encoding:embstr serializedlength:12 ...

# DEBUG SET-ACTIVE-EXPIRE: toggle expiration sweeps
DEBUG SET-ACTIVE-EXPIRE 0  # disable expiration sweeps (debugging)
DEBUG SET-ACTIVE-EXPIRE 1  # re-enable

# DEBUG JMAP: memory map (jemalloc)
DEBUG JMAP

# DEBUG CHANGE-REPL-ID: change replication ID (advanced)
DEBUG CHANGE-REPL-ID

# DEBUG RELOAD: save RDB, flush, reload from RDB (testing)
DEBUG RELOAD

# DEBUG LOADAOF: reload from AOF (testing)
DEBUG LOADAOF

# WARNING: DEBUG commands can be dangerous
# use ACL to restrict them in production:
# ACL SETUSER default -@admin

redis-cli --latency

redis-cli --latency mide continuamente el tiempo de ida y vuelta — esencial para establecer la línea base del rendimiento de red. --latency-history registra estadísticas rodantes cada 15s (usa -i para cambiarlo). --latency-dist muestra un histograma (visualiza el jitter y la latencia de cola). Para modo clúster, comprueba la latencia a cada nodo por separado. Establece una línea base y luego monitorea los picos. Latencia >1ms en localhost indica un problema (CPU, presión de memoria o comandos lentos).

redis-cli
# continuous latency measurement (round-trip time)
redis-cli --latency
# output: min: 0, max: 1, avg: 0.27 (3421 samples)

# latency history (rolling, every N seconds)
redis-cli --latency-history
# default interval: 15 seconds
# output: min: 0, max: 2, avg: 0.31 (1500 samples) -- 15.01 seconds

# custom interval (1 second)
redis-cli --latency-history -i 1

# latency distribution (histogram)
redis-cli --latency-dist
# shows a visual histogram of latency distribution

# latency to a remote host
redis-cli -h remote-host --latency

# use cases:
# - baseline your network latency
# - detect network issues (jitter, spikes)
# - compare latency before/after config changes
# - monitor latency over time with --latency-history

# for cluster mode, check latency to each node:
redis-cli -h node1 -p 7000 --latency &
redis-cli -h node2 -p 7000 --latency &

redis-cli --stat

redis-cli --stat es como 'top' para Redis — muestra un resumen que se refresca de claves, memoria, clientes, clientes bloqueados, peticiones/seg y conexiones. El (+N) junto a las peticiones muestra el delta desde la última muestra. Úsalo para comprobaciones rápidas de salud y para detectar anomalías (memoria creciendo, clientes con fuga, tasa de peticiones disparándose). La columna 'child' muestra si hay un hijo BGSAVE/BGREWRITEAOF corriendo.

redis-cli
# --stat: continuous server stats (like top for Redis)
redis-cli --stat
# output (refreshes every second):
# ------- data ------ --------------------- load -------------------- - child -
# keys       mem      clients blocked requests            connections
# 1000       1.50M    50      0       12345 (+12)         1000

# --stat shows:
#   keys       total keys in the db
#   mem        memory usage
#   clients    connected clients
#   blocked    blocked clients (BLPOP, etc.)
#   requests   total requests (+N since last sample)
#   connections total connections since start
#   child      child process info (BGSAVE/BGREWRITEAOF)

# custom interval (every 5 seconds)
redis-cli --stat -i 5

# monitor a remote server
redis-cli -h host --stat

# use cases:
# - quick health check (are clients/memory/keys growing?)
# - spot traffic spikes (requests/second)
# - monitor during load tests
# - detect connection leaks (clients increasing steadily)

# combine with --no-raw for machine-readable output
18

Seguridad

AUTH (contraseña heredada)

AUTH es la autenticación de contraseña única heredada (pre-Redis 6). En Redis 6+, usa usuarios ACL (AUTH usuario contraseña). El flag -a expone la contraseña en el historial del shell — prefiere la variable de entorno REDISCLI_AUTH. Usa siempre contraseñas fuertes (64+ caracteres aleatorios). En producción, combina AUTH con TLS, restricciones de red (bind/firewall) y mínimo privilegio basado en ACL para defensa en profundidad.

redis-cli
# set a password (simple, legacy)
CONFIG SET requirepass "strongpassword"

# authenticate (legacy, before Redis 6)
AUTH "strongpassword"
# OK

# authenticate as a specific user (Redis 6+ ACL)
AUTH appuser "secretpassword"
# OK

# connect with password via CLI
redis-cli -a "strongpassword"
redis-cli -a "strongpassword" --no-auth-warning  # suppress warning

# safer: use environment variable
export REDISCLI_AUTH="strongpassword"
redis-cli   # reads REDISCLI_AUTH automatically

# remove password
CONFIG SET requirepass ""

# AUTH returns ERR if the password is wrong
# after AUTH, all commands work normally

ACL SETUSER

Las ACLs de Redis 6+ reemplazan el modelo de contraseña única — crea usuarios con permisos acotados. La sintaxis: on (habilitado), >contraseña, ~patrón (patrones de clave), +comando/-comando, +@categoría/-@categoría (por ejemplo, +@read, -@dangerous). Crea siempre un usuario de mínimo privilegio para cada app. El usuario default siempre existe — fja una contraseña fuerte o restríngelo. Guarda las ACLs a un archivo (ACL SAVE) por persistencia.

redis-cli
# Redis 6+: ACL system with users and permissions
# create a user with limited access
ACL SETUSER appuser on >secretpassword ~app:* +get +set +del -@dangerous
# on = enabled
# >password = set password
# ~pattern = key patterns this user can access
# +command = allowed commands
# -command = denied commands
# +@category / -@category = allow/deny command categories

# categories: @read, @write, @admin, @dangerous, @keyspace, @connection, etc.

# create a read-only user
ACL SETUSER readonly on >pass ~* +@read -@dangerous

# create an admin user
ACL SETUSER admin on >adminpass ~* +@all

# create a user for a specific app (restricted keys)
ACL SETUSER app1 on >pass ~app1:* +@read +@write +@connection -@dangerous

# the default user (always exists)
ACL SETUSER default on >defaultpass ~* +@all -@dangerous

ACL LIST y GETUSER

ACL LIST muestra cada usuario en formato compacto de reglas. ACL GETUSER da los permisos detallados de un usuario (incluidas contraseñas hasheadas, comandos permitidos/denegados, patrones de clave). ACL WHOAMI devuelve el usuario actual. ACL LOG (7.0+) registra los comandos denegados y los fallos de autenticación — útil para auditoría de seguridad. ACL SAVE/LOAD gestionan el archivo ACL por persistencia entre reinicios.

redis-cli
# list all users (compact rules)
ACL LIST
# 1) "user default on nopass ~* +@all"
# 2) "user appuser on #abc123... ~app:* +get +set +del -@dangerous"

# view a user's detailed permissions
ACL GETUSER appuser
# flags, passwords, commands, keys, channels, selectors

# view current user
ACL WHOAMI
# "appuser"

# view all users (just names, 7.0+)
ACL USERS

# delete a user
ACL DELUSER appuser

# save ACLs to a file (persists across restarts)
ACL SAVE

# reload ACLs from file
ACL LOAD

# aclfile in redis.conf:
#   aclfile /etc/redis/users.acl

# view current user's rules
ACL LOG        # security audit log (7.0+)
ACL LOG RESET  # clear the audit log

ACL WHOAMI y DELUSER

ACL WHOAMI identifica al usuario actual. ACL DELUSER elimina a un usuario (y desconecta sus conexiones activas). Poner a un usuario 'off' lo deshabilita temporalmente sin borrar sus reglas — útil para suspender accesos. ACL LOG registra los eventos de seguridad (comandos denegados, autenticación fallida) — monitorea actividad sospechosa. Rota las contraseñas regularmente con ACL SETUSER >nuevacontraseña.

redis-cli
# get the current authenticated user
ACL WHOAMI
# "appuser"

# switch user (re-authenticate)
AUTH adminuser "adminpass"
ACL WHOAMI
# "adminuser"

# delete a user (disconnects their clients)
ACL DELUSER tempuser

# temporarily disable a user (keeps the rules, blocks login)
ACL SETUSER appuser off
# the user cannot authenticate, but their rules are preserved
# re-enable:
ACL SETUSER appuser on

# rotate a user's password
ACL SETUSER appuser >newpassword

# remove a user's password
ACL SETUSER appuser <secretpassword  # remove this password
# or remove all passwords:
ACL SETUSER appuser resetpass

# view the audit log (denied commands, auth failures)
ACL LOG
ACL LOG COUNT 5  # last 5 entries
ACL LOG RESET    # clear the log

rename-command (deshabilitar comandos)

rename-command (en redis.conf) deshabilita o renombra comandos peligrosos — fja "" para deshabilitar o una cadena para renombrar. Exige reinicio (no cambiable en runtime). En Redis 6+, prefiere las ACLs (-flushall, -@dangerous) que son cambiables en runtime y por usuario. Comandos que vale la pena restringir: FLUSHALL/FLUSHDB (pérdida de datos), KEYS (bloquea al servidor), CONFIG (seguridad), DEBUG (puede tumbar), SHUTDOWN (detiene el servidor).

redis-cli
# rename or disable dangerous commands (in redis.conf)
rename-command FLUSHALL ""
rename-command FLUSHDB ""
rename-command CONFIG "CONFIG_9f8a7b"
rename-command KEYS ""
rename-command DEBUG ""
rename-command SHUTDOWN "SHUTDOWN_7x9y"

# "" completely disables the command (returns error)
# a string renames it (must use the new name)

# Redis 6+: prefer ACLs instead of rename-command
# ACL SETUSER default -flushall -config -keys -@dangerous

# view available commands (after rename/restrictions)
COMMAND

# note: rename-command requires a restart (not changeable at runtime)
# ACLs are runtime-changeable and more flexible

# dangerous commands to restrict:
#   FLUSHALL, FLUSHDB  - delete all data
#   KEYS               - blocks server
#   CONFIG             - can change security settings
#   DEBUG              - can crash the server
#   SHUTDOWN           - stops the server
#   MONITOR            - performance impact

Cifrado TLS/SSL

TLS cifra los datos en tránsito — esencial para producción, especialmente sobre redes no confiables. Redis 6+ soporta TLS de forma nativa. mTLS (tls-auth-clients yes) exige que los clientes presenten un certificado, aportando autenticación mutua sin contraseñas. Para clúster/sentinel, habilita TLS también en la comunicación entre nodos. El puerto 0 desactiva el texto plano; durante la migración, corre ambos puertos temporalmente. Usa siempre certificados firmados por una CA adecuada en producción.

redis-cli
# enable TLS in redis.conf (Redis 6+)
port 0                       # disable plain-text port
tls-port 6379
tls-cert-file /etc/redis/redis.crt
tls-key-file /etc/redis/redis.key
tls-ca-cert-file /etc/redis/ca.crt

# connect with TLS
redis-cli --tls --cert client.crt --key client.key \
  --cacert ca.crt -h host -p 6379

# mutual TLS (mTLS) for client authentication
tls-auth-clients yes         # require client certs
tls-auth-clients no          # don't require (default)
tls-auth-clients optional    # verify if provided

# TLS for cluster and replication
tls-cluster yes              # TLS between cluster nodes
tls-replication yes          # TLS between primary/replica

# mix TLS and plain text (transition period)
# port 6380
# tls-port 6379

# generate self-signed certs for testing:
# openssl req -x509 -newkey rsa:4096 -keyout redis.key \
#   -out redis.crt -days 365 -nodes
19

Importación y exportación de datos

redis-cli --rdb (respaldo)

redis-cli --rdb hace un respaldo en línea — transmite el RDB a un archivo sin tocar directamente el sistema de archivos del servidor. Es no bloqueante (usa el fork en segundo plano de BGSAVE) y seguro para producción. Combinado con SSH, puedes respaldar un Redis remoto a un archivo local. Verifica los respaldos con redis-check-rdb. Programa respaldos regulares vía cron. Prueba siempre los procedimientos de restauración — un respaldo no probado no es un respaldo.

redis-cli
# dump the RDB snapshot to a file (online backup)
redis-cli --rdb /backup/dump.rdb
# Output: RDB file written to /backup/dump.rdb

# dump RDB to a remote host's file (via SSH):
ssh remote-host "redis-cli --rdb /tmp/dump.rdb"

# the --rdb flag:
# - connects to Redis and requests a BGSAVE
# - streams the RDB to the specified file
# - non-blocking (uses the background fork)
# - safe to run on a production server

# verify the RDB file
redis-check-rdb /backup/dump.rdb

# restore: stop Redis, replace dump.rdb, restart
redis-cli SHUTDOWN
cp /backup/dump.rdb /var/lib/redis/dump.rdb
redis-server /etc/redis/redis.conf

# schedule regular backups:
# 0 2 * * * redis-cli --rdb /backup/dump-$(date +\%F).rdb

redis-cli --pipe (inserción masiva)

redis-cli --pipe es la forma más rápida de cargar datos en masa a Redis — transmite RESP crudo y no espera respuestas hasta el final. Genera RESP con printf o un script. --pipe reporta errores y respuestas totales. Para cargas más simples/pequeñas, pasar comandos de texto (echo | redis-cli) funciona pero es más lento. Haz siempre benchmark: --pipe puede cargar millones de claves en minutos. Vigila la memoria durante cargas grandes.

redis-cli
# --pipe: bulk load raw RESP data (fastest method)
# generate RESP and pipe it:

# example: bulk SET commands (bash)
for i in $(seq 1 100000); do
  printf '*3\r\n$3\r\nSET\r\n$%d\r\nkey:%d\r\n$%d\r\nvalue%d\r\n' \
    $((4 + ${#i})) $i $((5 + ${#i})) $i
done | redis-cli --pipe

# simpler text mode (slower but easier):
for i in $(seq 1 100000); do
  echo "SET key:$i value$i"
done | redis-cli

# --pipe mode output:
# All data transferred. Waiting for the last reply...
# Last reply received from server.
# errors: 0, replies: 100000

# prepare RESP from a CSV/data file:
# (each line: key,value)
while IFS=, read -r key value; do
  printf '*3\r\n$3\r\nSET\r\n$%d\r\n%s\r\n$%d\r\n%s\r\n' \
    ${#key} "$key" ${#value} "$value"
done < data.csv | redis-cli --pipe

DUMP y RESTORE

DUMP serializa el valor de una clave a un blob binario (incluye tipo y valor, pero no TTL — especifica el TTL en RESTORE en milisegundos). RESTORE lo deserializa a una clave, funcionando entre instancias de Redis distintas (genial para migraciones). El formato serializado es específico de versión — un blob de Redis 4.x puede no cargar en 7.x; verifica siempre la compatibilidad. Para copias dentro de la instancia, prefiere el comando nativo COPY (6.2+) sobre DUMP+RESTORE.

redis-cli
# DUMP: serialize a key's value (binary blob)
DUMP mykey
# returns a serialized blob (binary, includes type + value + TTL info)

# RESTORE: deserialize into a key
RESTORE newkey 0 <serialized_blob>
# 0 = no TTL (milliseconds); set a TTL otherwise
RESTORE newkey 3600000 <blob>   # 1 hour TTL
RESTORE newkey 0 <blob> REPLACE  # overwrite if exists

# copy a key (6.2+ does this natively with COPY)
# manual copy via DUMP + RESTORE:
SET source "value"
blob = DUMP source
RESTORE dest 0 blob

# DUMP/RESTORE preserve the type but NOT the TTL
# (TTL must be specified in RESTORE)

# DUMP/RESTORE work across different Redis instances
# (migrate data between servers)

# note: serialized format is version-specific
# a blob from Redis 4.x may not load in 7.x — verify compatibility

# use COPY (6.2+) instead for in-instance copies:
COPY source dest                # copy without TTL
COPY source dest REPLACE        # overwrite destination
COPY source dest DB 1           # copy to another database
COPY source dest REPLACE DB 1   # both

MIGRATE (mover entre servidores)

MIGRATE mueve (o copia) atómicamente una clave entre instancias de Redis — la clave nunca está en ambos lugares a la vez (atómico). Es el bloque de construcción del re-fragmentado del clúster. COPY conserva la clave fuente; por defecto la elimina. REPLACE sobrescribe una clave de destino existente. Para varias claves, pasa una cadena vacía como clave y listalas con KEYS. Fja el timeout lo bastante alto para valores grandes. MIGRATE bloquea en ambos extremos durante la transferencia.

redis-cli
# MIGRATE: atomically move a key from one Redis to another
# syntax: MIGRATE host port key|"" dest-db timeout [COPY] [REPLACE]
#         [AUTH password] [KEYS key1 key2 ...]

# move a single key (default: deletes from source after copy)
MIGRATE 192.168.1.20 6379 mykey 0 5000
# host, port, key, dest-db, timeout-ms

# copy without deleting from source
MIGRATE 192.168.1.20 6379 mykey 0 5000 COPY

# overwrite if the key exists on destination
MIGRATE 192.168.1.20 6379 mykey 0 5000 REPLACE

# migrate multiple keys (pass "" as the key, then KEYS ...)
MIGRATE 192.168.1.20 6379 "" 0 5000 KEYS key1 key2 key3

# authenticate with the destination
MIGRATE 192.168.1.20 6379 mykey 0 5000 AUTH destpassword

# MIGRATE is atomic: the key appears on exactly one instance at any moment
# timeout is in milliseconds — large keys need longer timeouts
# returns NOKEY if the key doesn't exist on source

COPY (copia dentro de la instancia)

COPY (6.2+) duplica una clave dentro de la misma instancia atómicamente — mucho más simple que DUMP+RESTORE. NO copia el TTL por defecto (usa EXPIRE después). COPY funciona entre bases de datos con la opción DB. REPLACE sobrescribe un destino existente. Para copias entre instancias, usa MIGRATE (que es atómico a través de la red). COPY es el reemplazo moderno del patrón DUMP+RESTORE para duplicar dentro de la instancia.

redis-cli
# COPY: duplicate a key within the same instance (6.2+)
COPY source dest               # copy value (no TTL by default)
COPY source dest REPLACE       # overwrite destination if it exists
COPY source dest DB 1          # copy to another database
COPY source dest REPLACE DB 1  # both options

# before COPY existed, you needed DUMP + RESTORE:
SET src "hello"
blob = DUMP src
RESTORE dst 0 blob

# COPY preserves the type (string, list, hash, ...)
SET mystr "hello"
COPY mystr mystr_copy
TYPE mystr_copy               # "string"

# COPY does NOT copy TTL by default — use after EXPIRE if needed
SET temp "data" EX 3600
COPY temp temp_copy
TTL temp_copy                 # -1 (no TTL)
EXPIRE temp_copy 3600         # set TTL manually

# COPY is atomic and never blocks (unlike DUMP on huge keys)

redis-check-rdb y redis-check-aof

redis-check-rdb y redis-check-aof verifican la integridad de los archivos de persistencia — córrelos siempre sobre los respaldos antes de restaurar. redis-check-aof --fix recupera de un AOF truncado eliminando la cola incompleta (pide confirmación). Redis 7 usa un AOF multieparte (base + incrementales) — comprueba el archivo manifest. Estas herramientas son de solo lectura salvo --fix, haciéndolas seguras de correr en cualquier momento. Valida los respaldos religiosamente — un respaldo no verificado no es un respaldo.

redis-cli
# verify the integrity of an RDB file (offline, safe)
redis-check-rdb /var/lib/redis/dump.rdb
# outputs: [offset] Checksum OK | CRC error | file truncated

# verify an AOF file
redis-check-aof /var/lib/redis/appendonly.aof
# outputs: AOF analyzed: size=... ok_up_to=... ok_up_to_line=...

# fix a truncated AOF (interactive prompt)
redis-check-aof --fix /var/lib/redis/appendonly.aof

# Redis 7 multi-part AOF: check the manifest
redis-check-aof --manifest /var/lib/redis/appendonlydir/appendonly.aof.manifest

# truncate an RDB to a specific offset (recovery)
redis-check-rdb --fix /var/lib/redis/dump.rdb

# use cases:
# - verify a backup before restore
# - diagnose corruption after a crash
# - recover from a truncated AOF (removes the incomplete tail)
# - validate files copied across servers

# always run these checks BEFORE replacing production data files
20

Pruebas de rendimiento

Fundamentos de redis-benchmark

redis-benchmark es la herramienta de pruebas de carga integrada de Redis — simula clientes concurrentes y reporta rendimiento (peticiones/seg) y percentiles de latencia. -t selecciona pruebas (PING, SET, GET, INCR, etc.); -n fija el conteo de peticiones; -d el tamaño del payload. Haz siempre benchmark en hardware equivalente a producción para establecer la línea base. Los 50 clientes paralelos por defecto son un punto de partida — ajusta -c para que coincida con tu carga real. Corre benchmarks antes y después de cambios de configuración para medir el impacto.

redis-cli
# redis-benchmark: built-in performance benchmarking tool
# runs commands against a Redis server and reports throughput/latency

# default benchmark (50 parallel clients, 100000 requests)
redis-benchmark
# default commands: PING, SET, GET, INCR, LPUSH, RPUSH, LPOP, RPOP,
#   SADD, HSET, SPOP, ZADD, ZPOPMIN, LRANGE_100, LRANGE_300, ...

# run a specific command only
redis-benchmark -t set,get -n 100000
# -t = test (comma-separated commands)
# -n = number of requests

# test a specific command with custom data
redis-benchmark -t set -n 100000 -d 100
# -d = data size in bytes (default 3)

# output example:
# ====== SET ======
#   100000 requests completed in 0.85 seconds
#   50 parallel clients
#   3 bytes payload
#   keep alive: 1
#   98.90% <= 1 milliseconds
#   100.00% <= 1 milliseconds
#   117647.05 requests per second

# run against a remote server with auth
redis-benchmark -h host -p 6379 -a password -t set,get -n 100000

Ajuste de pipeline y concurrencia

Las dos palancas de rendimiento mayores son -c (concurrencia) y -P (tamaño de pipeline). -c aumenta los clientes paralelos (más peticiones en vuelo); -P agrupa comandos por viaje (menos sobrecarga de red). Combinados pueden empujar el rendimiento 10-20 veces. Los benchmarks de un solo cliente (-c 1) miden latencia pura; los multicliente miden rendimiento. Payloads mayores (-d) desplazan el cuello de botella al ancho de banda de red. Ajusta siempre -c/-P para que coincidan con el comportamiento real de tu librería cliente.

redis-cli
# -c = number of parallel connections (clients)
redis-benchmark -t set -n 100000 -c 50     # default: 50 clients
redis-benchmark -t set -n 100000 -c 200    # 200 concurrent clients
redis-benchmark -t set -n 100000 -c 1      # single client (latency focus)

# -P = pipeline size (commands per round-trip)
redis-benchmark -t set -n 100000 -P 1      # no pipelining (baseline)
redis-benchmark -t set -n 100000 -P 16     # pipeline 16 commands
redis-benchmark -t set -n 100000 -P 100    # pipeline 100 commands

# combine -c and -P for max throughput
redis-benchmark -t set -n 100000 -c 50 -P 16

# typical results (localhost, small values):
#   -c 1  -P 1   -> ~100k req/s  (latency-bound)
#   -c 50 -P 1   -> ~600k req/s  (concurrency)
#   -c 50 -P 16  -> ~2M req/s    (pipelining)

# test with a larger payload (network-bound)
redis-benchmark -t set -n 100000 -d 1024   # 1KB values
redis-benchmark -t set -n 100000 -d 65536  # 64KB values

Percentiles de latencia y salida CSV

Mira siempre los percentiles de latencia (P50, P99, P99.9), no solo los promedios — los promedios ocultan los picos de latencia de cola que dañan la experiencia del usuario. Un P99 5 veces peor que el P50 indica jitter (GC, red o comandos lentos). --csv genera resultados legibles por máquina para seguir tendencias a lo largo del tiempo. Guarda benchmarks antes y después de cambios de configuración para medir el impacto objetivamente. Sigue la latencia P99 y las peticiones/seg juntas — optimizar una a expensas de la otra es una trampa común.

redis-cli
# --csv: CSV output (easy to parse / log)
redis-benchmark -t set,get -n 100000 --csv
# output: "test","rps","avg_latency_ms","min_latency_ms",...
# "SET","117647.05","0.284","0.144"
# "GET","125000.00","0.272","0.136"

# --precision: set decimal places for latency
redis-benchmark -t set -n 100000 --precision 4

# latency percentiles (Redis 6+):
# the default output shows "X% <= Y milliseconds" lines
# ====== SET ======
#   50.00% <= 0.239 milliseconds
#   99.00% <= 0.511 milliseconds
#   99.90% <= 1.023 milliseconds
#   100.00% <= 1.519 milliseconds

# focus on tail latency (P99, P99.9) — average hides outliers
# P99 > 5x P50 indicates jitter or GC pauses

# save results to a file for comparison
redis-benchmark -t set,get -n 100000 --csv > bench-$(date +%F).csv

# compare two runs (before/after a config change)
diff bench-2025-01-01.csv bench-2025-01-02.csv

Benchmark de clúster y Lua

El modo --cluster distribuye claves entre los slots del clúster — esencial para benchmarks de clúster realistas (los benchmarks de un solo nodo pierden la sobrecarga de enrutado entre slots). -r fija el tamaño del espacio de claves aleatorio (usa un valor grande para evitar que todas las operaciones golpeen una clave, lo que infla los números vía caché en memoria). --eval hace benchmark de scripts Lua. --threads (Redis 6+) usa múltiples hilos de benchmark — útil cuando un solo hilo no puede generar suficiente carga para saturar al servidor. Usa siempre -r para números realistas.

redis-cli
# benchmark a Redis Cluster (redis-benchmark supports cluster mode)
redis-benchmark --cluster -h node1 -p 7000 -t set,get -n 100000
# automatically distributes keys across cluster slots

# cluster mode with multiple nodes
redis-benchmark --cluster -h node1 -p 7000 -h node2 -p 7000 \
  -t set,get -n 100000 -c 50

# benchmark a Lua script (--eval)
redis-benchmark -n 100000 eval "return redis.call('SET', KEYS[1], ARGV[1])" 0 mykey hello
# note: key and args are positional after the script

# benchmark with random keys (--random-data + keyspace length)
redis-benchmark -t set -n 100000 -r 1000000
# -r 1000000 = random keys from a 1M keyspace (SET key:RAND_INT value)
# avoids hitting the same key (tests real-world distribution)

# use a random payload (not the same bytes each time)
redis-benchmark -t set -n 100000 -r 1000000 -d 100 --random-data

# only run the benchmark for a fixed time (seconds)
redis-benchmark -t set --threads 4 -n 100000
# --threads (6+) uses multiple threads (default 1, doesn't help single-core)

--idle y calentamiento

--idle mide la sobrecarga pura de conexión/red con solo PINGs — la línea base que no puedes superar. Calienta siempre el servidor antes de medir (las cachés frías infravaloran el rendimiento): corre un benchmark de descarte primero y luego el medido. --loop corre continuamente (útil para pruebas de carga sostenida). --seed hace reproducible el espacio de claves aleatorio — esencial para comparaciones A/B. --dbnum selecciona la base de datos (usa una db separada para no contaminar los datos de producción durante los benchmarks).

redis-cli
# --idle: only send PINGs (no commands) — measure pure connection overhead
redis-benchmark -t ping -n 100000 --idle
# useful for measuring connection / network baseline latency

# --dbnum: select a specific database
redis-benchmark -t set -n 100000 --dbnum 1

# --clients: same as -c (alias)
redis-benchmark -t set -n 100000 --clients 100

# warm up the server before measuring (avoid cold-start bias)
redis-benchmark -t set -n 10000   # warmup run (discard results)
redis-benchmark -t set -n 100000  # measured run

# --loop: run the benchmark forever (Ctrl+C to stop)
redis-benchmark -t set -n 100000 --loop

# --seed: reproducible random keys (same -r sequence every run)
redis-benchmark -t set -n 100000 -r 1000000 --seed 42

# benchmark with a specific client socket buffer
redis-benchmark -t set -n 100000 --numdatadb 1

Interpretación y trampas del benchmark

Las trampas del benchmark inflan los números de forma irreal: (1) los benchmarks solo en localhost pierden la latencia de red; (2) sin -r, todas las operaciones golpean una clave (inflado por caché); (3) los payloads diminutos no estresan memoria/red; (4) ignorar la sobrecarga de persistencia (el fsync de AOF puede recortar el rendimiento 2-5 veces); (5) un solo hilo de benchmark no puede saturar a un servidor multinúcleo. Un benchmark realista usa -r (claves aleatorias), -d (payload realista), --threads (cliente multihilo) y prueba con persistencia y red equivalentes a producción. Divulga siempre los parámetros del benchmark al compartir números.

redis-cli
# COMMON PITFALL #1: benchmarking localhost only
# localhost numbers don't reflect real network latency
# always test over your production network path

# COMMON PITFALL #2: all keys the same (no -r)
# redis-benchmark -t set -n 100000
#   -> all SETs hit "key:0" — inflated by in-memory caching
# FIX: use -r to randomize keys
redis-benchmark -t set -n 100000 -r 1000000

# COMMON PITFALL #3: tiny payloads only
# 3-byte values don't reflect real memory/network pressure
# test with realistic sizes
redis-benchmark -t set -n 100000 -d 256 -r 1000000

# COMMON PITFALL #4: ignoring persistence overhead
# benchmark with AOF on vs off to see the durability cost:
redis-benchmark -t set -n 100000   # with current persistence settings
# (then) CONFIG SET appendonly no
redis-benchmark -t set -n 100000   # without AOF — compare

# COMMON PITFALL #5: single-threaded benchmark client
# one benchmark thread may not generate enough load
redis-benchmark -t set -n 100000 --threads 4 -c 100

# GOOD BENCHMARK (realistic):
redis-benchmark -t set,get -n 1000000 -c 50 -P 16 -r 1000000 -d 100 --threads 4 --csv

Was this helpful?