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.
# 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 # TLSOpciones 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.
# 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:jsonPING 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.
# 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 1Consejos 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.
# 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> :rawSelecció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 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 1Ayuda 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.
# 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 GETSETCadenas
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.
# 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 mykeyContadores 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.
# 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 integerAPPEND 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.
# 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.
# 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-modeBitmaps (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.
# 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 10Expiració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.
# 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" KEEPTTLListas
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.
# 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 existLRANGE 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.
# 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 occurrencePops 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.
# 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 100LREM, 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.
# 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 typeCasos 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.
# 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 messagesSets
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.
# 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) 0Operaciones 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.
# 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 s4SREM, 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.
# 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 mysetIteració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.
# 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 SSCANCasos 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.
# 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 winnerSorted 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.
# 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.
# 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 10ZRANGEBYSCORE 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).
# 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 <= 100ZUNIONSTORE 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.
# 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 0Rangos 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.
# 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 10Patró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.
# 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 TTLHashes
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.
# 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 fieldHMGET (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.
# 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 + valuesHINCRBY (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.
# 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 itemHSCAN (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.
# 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 useCasos 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.
# 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_tokenGestió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.
# 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 | noneUNLINK (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.
# 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 lazyfreeRENAME 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.
# 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 atomicKEYS 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.
# 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 exactRANDOMKEY 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.
# 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.
# 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+)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.
# 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 # millisecondsPERSIST (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.
# 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 remainSAVE 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.
# 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 snapshotsBGREWRITEAOF (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.
# 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.
# 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 persistenceRespaldo 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.
# 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.rdbPub/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.
# 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).
# 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 patternPSUBSCRIBE (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.
# 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 eventsPub/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).
# 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 mychannelNotificaciones 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é.
# 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-eventsTransacciones
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.
# 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.
# 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 MULTIWATCH (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.
# 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 executedUNWATCH 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.
# 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, EXECManejo 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.
# 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 SQLPipelining
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.
# 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 3MULTI 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.
# 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 oneProtocolo 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.
# 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.
# 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 throughputLí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.
# 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)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.
# 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" 0EVALSHA 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.
# 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.
# 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_cacheKEYS 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.
# 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 correctlyOperaciones 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.
# 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 60Redis 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.
# 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/AOFGestió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+.
# 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 -lCLIENT 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.
# 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 spacesCLIENT 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).
# 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).
# 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 UNPAUSECLIENT 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.
# 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 = pausedLí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).
# 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-limitGestió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.