Skip to content

Redis Hoja de referencia

Almacén de estructuras de datos en memoria, usado como base de datos, caché y message broker.

01

Primeros pasos

Conectar a Redis

redis-cli es el cliente estándar de línea de comandos. PING prueba la conectividad (devuelve PONG). Usa siempre el comando AUTH o el flag -a en producción. Evita poner contraseñas en la línea de comandos en entornos compartidos — usa en su lugar la variable de entorno REDISCLI_AUTH. El Redis moderno (6+) soporta usuarios basados en ACL con permisos acotados.

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

# connect with a specific host and port
redis-cli -h host.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

# test the connection
PING          # returns PONG
PING "hello"  # returns "hello"

Selección de base de datos y conceptos básicos

Las bases de datos de Redis son namespaces lógicos (numerados 0-15), no esquemas aislados — comparten la misma memoria. La mayoría de las aplicaciones usan solo la db 0. FLUSHDB vacía la db actual; FLUSHALL lo vacía por completo. Se desaconsejan las múltiples bases de datos en favor de instancias Redis separadas o prefijos de claves, ya que comparten un único hilo y no se pueden configurar por separado.

redis
# 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

# get basic server info
INFO server
INFO memory
INFO replication

Claves y operaciones generales

KEYS bloquea el servidor mientras escanea — nunca lo uses en producción con conjuntos de datos grandes; usa SCAN en su lugar (basado en cursor, sin bloqueo). Estructura las claves con dos puntos (user:1:profile) para que sean legibles. EX fija la expiración en segundos; PX en milisegundos. TYPE devuelve la estructura de datos (string, list, hash, set, zset, stream).

redis
# set and get a key
SET user:1 "Alice"
GET user:1

# check if a key exists
EXISTS user:1          # 1 if exists, 0 if not

# delete keys
DEL user:1
DEL key1 key2 key3     # returns number deleted

# set a key with expiration (seconds)
SET session:abc "data" EX 3600

# find keys matching a pattern (avoid in production)
KEYS user:*
SCAN 0 MATCH user:* COUNT 100   # safer iteration

# rename a key
RENAME oldkey newkey

# get the type of a value stored at a key
TYPE user:1

Expiración y TTL

TTL devuelve -2 para claves inexistentes y -1 para claves sin expiración. La expiración es perezosa — Redis solo comprueba cuando se accede a la clave o durante barridos periódicos en segundo plano. SET con EX es atómico (sin carrera entre SET y EXPIRE). Las claves expiradas no disparan eventos por defecto; activa las keyspace notifications si las necesitas.

redis
# set expiration on an existing key
EXPIRE user:1 60        # 60 seconds
EXPIREAT user:1 1700000000  # Unix timestamp

# set expiration in milliseconds
PEXPIRE user:1 60000

# view remaining time to live (seconds)
TTL user:1              # -2 if no key, -1 if no expiry

# view TTL in milliseconds
PTTL user:1

# remove expiration (make key persistent)
PERSIST user:1

# set value AND expiration atomically
SET token "abc" EX 3600

SCAN e iteración segura

SCAN es la alternativa segura para producción a KEYS — devuelve un cursor que sigues hasta 0. COUNT es una pista, no un valor exacto (puede devolver más o menos). SCAN ofrece garantías débiles: puede devolver duplicados o perder claves añadidas durante la iteración, pero nunca bloquea. Usa HSCAN/SSCAN/ZSCAN para los tipos de colección. Gestiona siempre el bucle del cursor en tu código.

redis
# SCAN: cursor-based iteration (non-blocking)
SCAN 0 MATCH user:* COUNT 100
# returns: [nextCursor, [key1, key2, ...]]
SCAN <nextCursor> MATCH user:* COUNT 100
# continue until cursor returns to 0

# scan a specific type
SCAN 0 TYPE hash

# HSCAN: iterate hash fields
HSCAN myhash 0 MATCH field* COUNT 100

# SSCAN: iterate set members
SSCAN myset 0 MATCH member* COUNT 100

# ZSCAN: iterate sorted set members
ZSCAN myzset 0 MATCH member* COUNT 100
02

Panorama de tipos de datos

Estructuras de datos básicas

Elegir la estructura de datos correcta es la habilidad clave en Redis. Strings para contadores/cachés, hashes para objetos, lists para colas, sets para unicidad/tags, sorted sets para leaderboards/rankings, streams para logs de eventos. Cada operación sobre una estructura de datos es atómica, así que clientes concurrentes no pueden corromper el estado. Elige la estructura que encaje con tu patrón de acceso.

redis
# Redis is a data structure server, not just a key-value store
# Each key holds a typed data structure:

# String: binary-safe blob (up to 512MB)
SET key "value"
SET counter 100

# List: ordered, linked-list of strings
LPUSH mylist "a" "b"
RPUSH mylist "c"

# Hash: field-value map (like a small object)
HSET user:1 name "Alice" age 30

# Set: unordered collection of unique strings
SADD tags "redis" "db"

# Sorted Set (ZSet): set scored by a float
ZADD leaderboard 100 "alice" 200 "bob"

# Stream: append-only log with IDs
XADD mystream * field value

# Bitmap, HyperLogLog, Geo: built on strings/zsets

Elegir el tipo correcto

Elige el tipo según el patrón de acceso: ¿necesitas unicidad? Set. ¿Ordenar por puntuación? Sorted set. ¿Actualizar un campo de un objeto? Hash (no un string serializado). ¿Conteos únicos aproximados a gran escala? HyperLogLog (12KB para miles de millones de elementos). Elegir bien el tipo = código más simple, operaciones atómicas y un ahorro de memoria espectacular.

redis
# Use case -> data type mapping:
# Cache a string  -> String
SET api:response "json_blob"

# Store an object -> Hash (one key, multiple fields)
HSET user:1 name "Alice" email "[email protected]" age 30

# Queue / stack   -> List
LPUSH tasks "job1"   # push to head
RPOP tasks           # pop from tail (FIFO queue)

# Unique tags      -> Set
SADD post:1:tags "redis" "db" "cache"

# Leaderboard      -> Sorted Set
ZADD scores 100 "alice" 250 "bob"
ZREVRANGE scores 0 9     # top 10

# Event log        -> Stream
XADD events * type click user 1

# Count unique     -> HyperLogLog (approximate, fixed memory)
PFADD visitors "user1" "user2"

Codificación en memoria

Redis usa codificaciones compactas (listpack, intset) para estructuras pequeñas — ahorrando 5-10x de memoria — y cambia a tablas hash/skiplists automáticamente a medida que crecen. OBJECT ENCODING revela la codificación actual. MEMORY USAGE informa de los bytes. Puedes ajustar los umbrales (p. ej., hash-max-listpack-entries), pero los valores por defecto están bien elegidos. Entender las codificaciones ayuda a planificar capacidad.

redis
# Redis optimizes storage based on size
# Inspect the internal encoding of a key
OBJECT ENCODING mykey

# String encodings:
#   "embstr"  - short strings (< 44 bytes)
#   "raw"     - long strings
#   "int"     - integer values

# Hash/List/Set/ZSet encodings:
#   "listpack" / "intset" - small (compact, memory-efficient)
#   "hashtable" / "list" / "skiplist" - large (faster, more memory)

# check memory usage of a key
MEMORY USAGE mykey

# sample memory usage stats
MEMORY STATS

# the encoding changes automatically as the structure grows

Comandos OBJECT y de memoria

OBJECT IDLETIME es útil para encontrar claves de caché frías (poco accedidas). OBJECT FREQ solo funciona con maxmemory-policy LFU. MEMORY USAGE con SAMPLES 0 cuenta con exactitud (por defecto muestrea en colecciones grandes). COMMAND DOCS (Redis 7+) devuelve documentación estructurada. Estas herramientas de introspección ayudan a depurar el inflado de memoria y a ajustar las políticas de eviction.

redis
# OBJECT subcommands for introspection
OBJECT ENCODING mykey     # internal encoding
OBJECT REFCOUNT mykey     # reference count
OBJECT IDLETIME mykey     # seconds since last access
OBJECT FREQ mykey         # access frequency (LFU mode)

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

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

# help understand a command
COMMAND INFO GET
COMMAND DOCS SET

# COMMAND lists all commands (huge output)
COMMAND

Errores de tipo y comprobación de tipos

El tipo de una clave es fijo durante toda su vida — no puedes reutilizar la misma clave para otro tipo sin borrarla antes. Los errores WRONGTYPE protegen contra confusiones de tipo accidentales. Comprueba siempre TYPE al trabajar con claves de origen desconocido. Este tipado estricto es la razón por la que los comandos de Redis llevan prefijo de tipo (HSET vs SET vs SADD).

redis
# each key has ONE type; using the wrong command fails
SET mykey "hello"
LPUSH mykey "x"        # WRONGTYPE error

# WRONGTYPE Operation against a key holding the wrong kind of value

# check the type before operating
TYPE mykey             # "string"
if [ "$(TYPE mykey)" = "string" ]; then ...

# TYPE returns: string|list|hash|set|zset|stream|none

# rename preserves the type
RENAME mykey newkey
TYPE newkey            # still "string"

# type is immutable; delete + recreate to change types
DEL mykey
LPUSH mykey "x"        # now a list
03

Strings

Operaciones básicas con strings

Los strings son binarios (pueden guardar cualquier secuencia de bytes hasta 512MB, incluidas imágenes o JSON). SET con NX es la primitiva clásica de lock en Redis (asignar si no existe). GETSET es atómico y útil para intercambiar configuraciones. SETRANGE puede hacer crecer un string. Para datos estructurados, prefiere Hashes antes que strings JSON serializados — permiten actualizaciones a nivel de campo.

redis
# set and get
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 mykey "new" EX 60 NX  # with expiry, only if new

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

# append to a string
APPEND mykey " world"   # "hello world"

# get substring
GETRANGE mykey 0 4      # "hello"
SETRANGE mykey 6 "redis"# "hello redis"

# get string length
STRLEN mykey            # 11

Contadores numéricos

INCR/DECR son atómicos — seguros para acceso concurrente sin bloqueos. Esto hace de Redis la opción ideal para contadores, rate limiting (INCR + EXPIRE) y generación de IDs secuenciales. INCRBYFLOAT soporta decimales pero usa doble precisión (ojo con el redondeo). Si el valor no es un entero, INCR devuelve un error. Los contadores funcionan mejor combinados con EXPIRE para estadísticas por tramos de tiempo.

redis
# increment a numeric string atomically
INCR counter            # counter = counter + 1
INCRBY counter 10       # counter = counter + 10

# decrement
DECR counter            # counter = counter - 1
DECRBY counter 5        # counter = counter - 5

# floating point operations
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

Operaciones con múltiples claves

MSET/MGET agrupa operaciones en un solo viaje de ida y vuelta — esencial para el rendimiento (el modelo de un solo hilo de Redis hace que la sobrecarga por comando importe). MSETNX es atómico: o se asignan las claves o ninguna (sin términos medios). GETDEL (6.2+) devuelve y borra atómicamente — útil para patrones de mensajes de lectura única. Agrupa comandos en lotes siempre que puedas para reducir la latencia de red.

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

# get multiple keys at once
MGET k1 k2 k3           # ["v1", "v2", "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

# atomic get-and-delete (useful for queues)
GETDEL mykey            # returns value AND deletes key

Bitmaps (basados en strings)

Los bitmaps almacenan flags booleanos para hasta 4 mil millones de usuarios en ~512MB — extremadamente eficientes en espacio para poblaciones grandes. BITOP AND/OR/XOR/NOT combina bitmaps (p. ej., usuarios activos varios días). BITCOUNT cuenta los usuarios activos. Casos de uso: usuarios activos diarios, feature flags, control de asistencia. La posición = ID de usuario.

redis
# 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:daily:2025-01-01 5 1
SETBIT users:daily:2025-01-02 5 1
BITOP AND active-both users:daily:2025-01-01 users:daily:2025-01-02
BITCOUNT active-both        # users active on both days

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

Operaciones bitfield

BITFIELD empaqueta varios contadores pequeños en un solo string — p. ej., 1000 contadores diarios como u8 en 1KB. OVERFLOW SAT satura en el máximo (bueno para estadísticas), FAIL devuelve nil en desbordamiento (bueno para topes), WRAP da la vuelta (por defecto, normalmente indeseado). Es mucho más eficiente en memoria que claves separadas para muchos contadores pequeños.

redis
# BITFIELD: multiple counters in one string (compact)
# store up to 2^63 counters, each 1-64 bits, in a single key

# set a 8-bit unsigned counter at offset 0
BITFIELD mycount SET u8 0 100

# increment a counter (with overflow control)
BITFIELD mycount INCRBY u8 0 10   # returns 110
BITFIELD mycount INCRBY u8 0 10   # returns 120

# overflow control: WRAP (default), SAT, FAIL
BITFIELD mycount OVERFLOW SAT INCRBY u8 0 200  # saturates at 255
BITFIELD mycount OVERFLOW FAIL INCRBY u8 0 999 # returns nil (overflow)

# read multiple counters in one call
BITFIELD mycount GET u8 0 GET u8 8 GET u8 16
04

Hashes

Conceptos básicos de hashes

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

redis
# 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 multiple fields
HMGET user:1 name age       # ["Alice", "30"]

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

# get all field names or values
HKEYS user:1                # [name, age, email]
HVALS user:1                # [Alice, 30, [email protected]]

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

Operaciones con campos del hash

HSETNX ofrece 'asignar si no existe' a nivel de campo (útil para inicializaciones de una sola vez). HINCRBY sobre campos de hash es atómico — perfecto para contadores por usuario (nº de logins, nº de vistas). Los hashes se autoeliminan al quitar el último campo (HDEL). HMSET está obsoleto desde que HSET acepta múltiples campos; usa siempre HSET.

redis
# 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

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

# increment a numeric field atomically
HINCRBY user:1 age 1         # age = 31
HINCRBY user:1 age -5        # age = 26
HINCRBYFLOAT user:1 score 0.5

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

# set multiple fields (same as HSET with multiple)
HMSET user:1 a 1 b 2         # deprecated, use HSET

Iteración de hashes

HGETALL bloquea el servidor en hashes grandes — usa HSCAN para iterar en producción. HSCAN está basado en cursor: llámalo repetidamente hasta que el cursor vuelva a 0. COUNT es una pista. HRANDFIELD (6.2+) es útil para muestrear (p. ej., feature flags aleatorios). Para hashes con millones de campos, considera partirlos en varias claves mediante sharding.

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

# iterate all fields
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

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

Expiración de hashes (Redis 7.4+)

El TTL a nivel de campo (7.4+) es una función importante para los hashes — antes necesitabas claves separadas o soluciones alternativas para expirar campos individuales. Útil para objetos con vidas mixtas (un perfil de usuario donde el token de sesión expira pero el nombre persiste). Las versiones antiguas de Redis exigen guardar los campos con expiración como claves separadas con su propio EXPIRE.

redis
# before 7.4, expiration was only at the key level
EXPIRE user:1 3600    # the whole hash expires

# Redis 7.4+: field-level TTL (HEXPIRE)
HEXPIRE user:1 60 FIELDS 1 session_token
# expires only the session_token field in 60 seconds

# get TTL of a specific field
HPTTL user:1 FIELDS 1 session_token

# persist a specific field (remove its TTL)
HPERSIST user:1 FIELDS 1 session_token

# get all fields and their expiration times
HEXPIRETIME user:1 FIELDS 1 session_token

Casos de uso de los hashes

Los hashes brillan con objetos y contadores agrupados. Una técnica de memoria potente: cuando tienes muchos strings pequeños como claves, agrúpalos en un hash — la codificación listpack usa mucha menos sobrecarga que miles de claves individuales (cada una con sus metadatos). Este 'key bucketing' puede reducir el uso de memoria en 5-10x para valores pequeños.

redis
# 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. Group small key-value pairs into one hash (memory savings)
# instead of SET k1 v1; SET k2 v2 -> HSET bucket k1 v1 k2 v2
05

Lists

Conceptos básicos de listas (push/pop)

Las listas son de doble extremo, así que LPUSH+RPOP = cola (FIFO), LPUSH+LPOP = pila (LIFO). BLPOP/BRPOP bloquean hasta que haya un elemento — la base de las colas de Redis (sin polling). Fija siempre un timeout en BLPOP para gestionar desconexiones. Las listas son O(1) en operaciones de cabeza/cola pero O(N) para el acceso al medio.

redis
# lists are ordered sequences of strings (linked lists)
# push to head (left) or tail (right)
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
LPOP mylist 2             # ["a", ...]

# 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

Indexación y rangos de listas

LRANGE 0 -1 devuelve la lista entera. LTRIM es un patrón común para limitar el tamaño de la lista (p. ej., conservar solo los últimos 100 eventos). LREM elimina por valor (count: positivo=cabeza, negativo=cola, 0=toda la lista). LINDEX es O(N) para elementos del medio — las listas están optimizadas para el acceso por los extremos. Para acceso aleatorio por índice, usa otra estructura.

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

# get a range of elements
LRANGE mylist 0 -1        # all elements
LRANGE mylist 0 2         # first 3 elements
LRANGE mylist -3 -1       # last 3 elements

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

# get length
LLEN mylist

# trim to a range (removes everything outside)
LTRIM mylist 0 99         # keep only first 100 elements

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

Lista como cola

BRPOPLPUSH/BLMOVE mueve un elemento atómicamente del origen al destino — el consumidor puede procesarlo con seguridad y, si se cae, el elemento sigue en la lista de destino (patrón de cola fiable). Esto supera a BRPOP+procesar, porque una caída tras BRPOP pierde el elemento. Tras procesar, borra de la lista de destino.

redis
# 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
LPUSH source "item"
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

Inserción y eliminación en listas

LINSERT es O(N) — úsalo con moderación en listas grandes. LPOS encuentra posiciones de elementos sin eliminarlos. LMPOP (7.0+) saca elementos de varias listas en una llamada, útil para colas con prioridades. Para operaciones frecuentes en el medio de la lista, una lista es la elección equivocada — considera un sorted set u otro modelo de datos.

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

# remove elements by value
LREM mylist 1 "value"     # remove first occurrence from head
LREM mylist -1 "value"    # remove first occurrence from tail
LREM mylist 0 "value"     # remove ALL occurrences

# pop and push in one atomic operation
RPOPLPUSH source dest

# get and remove from both ends (6.2+)
LPOP mylist 2             # pop 2 from head
LMPOP 2 mylist LEFT COUNT 3  # (7.0+) pop from one of multiple lists

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

Casos de uso de las listas

Las listas son las mejores para secuencias con acceso por los extremos: colas, pilas, feeds, buffers. LTRIM las hace ideales para logs/feeds limitados. Para rate limiting, una lista de timestamps + LTRIM es una ventana deslizante sencilla. Para colas ordenadas/con prioridad, usa un sorted set. Las listas no soportan deduplicación — para eso usa un set.

redis
# 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 <timestamp>
LTRIM rate:user:1 0 99
LLEN rate:user:1           # request count in window
06

Sets

Conceptos básicos de sets

Los sets almacenan 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. SRANDMEMBER no elimina; SPOP sí. Los sets usan intset (array ordenado) cuando cada miembro es un entero — muy eficientes en memoria.

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

# remove a member
SREM tags "cache"

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

# get the number of members
SCARD tags                 # 2

# get all members (avoid on large sets)
SMEMBERS tags              # ["redis", "db"]

# get a random member
SRANDMEMBER tags           # one random member
SRANDMEMBER tags 3         # 3 random (may repeat)
SRANDMEMBER tags -3        # 3 unique random

# pop a random member (removes it)
SPOP tags                  # removes and returns one

Operaciones de sets

Las operaciones de conjuntos son el superpoder de Redis — unión, intersección y diferencia en O(N) sin procesamiento en el cliente. Casos de uso: amigos en común (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 evitar recalcular.

redis
# 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

Iteración y movimiento de sets

SMOVE es atómico — útil para transiciones de estado (p. ej., mover un usuario del set 'pending' al 'active'). SSCAN es la forma segura de iterar sets grandes. SMISMEMBER (7.4+) comprueba pertenencia por lotes, reduciendo viajes de red. BSPOP (7.0+) bloquea como BLPOP pero para sets — útil para patrones dirigidos por eventos donde el orden no importa.

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

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

# pop multiple random members (6.2+)
SPOP myset 3               # removes and returns 3 members

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

# check multiple memberships at once (7.4+)
SMISMEMBER myset "a" "b" "c"
# returns [1, 0, 1]

Casos de uso de los sets

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

redis
# 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
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"

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

Sets frente a otros tipos

La selección de tipos es la decisión central de diseño en Redis. Set para unicidad + pertenencia rápida (sin orden). Sorted set para rankings/ordenación (cuesta más memoria). List para secuencias con duplicados. Hash para objetos campo-valor. Cuando dudes, dibuja tus patrones de acceso: lecturas, escrituras, ordenación y requisitos de unicidad — el tipo correcto se vuelve obvio.

redis
# Set: unordered, unique, O(1) membership check
SADD myset "a" "b"
SISMEMBER myset "a"       # O(1)

# Sorted Set: unique + ordered by score
ZADD myzset 1 "a" 2 "b"
ZRANK myzset "a"          # 0 (rank)

# List: ordered, allows duplicates, O(N) search
LPUSH mylist "a" "a"
LPOS mylist "a"           # 0 (first match)

# Hash: field-value pairs, no ordering
HSET myhash a 1 b 2

# Choose:
# - need uniqueness only?           -> Set
# - need uniqueness + ordering?     -> Sorted Set
# - need ordering + allow dups?     -> List
# - need key-value mapping?         -> Hash
07

Sorted Sets

Conceptos básicos de sorted sets

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) permiten actualizaciones condicionales: GT solo actualiza si la nueva puntuación es mayor (genial para registrar el 'mejor resultado'). Las puntuaciones son doubles; los miembros son únicos. Los empates se resuelven lexicográficamente.

redis
# 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: conditional)
ZADD leaderboard NX 300 "new"
ZADD leaderboard GT 300 "alice"  # only if new score is greater

# 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

Consultas por rango

ZRANGE devuelve por rango (índice); ZRANGEBYSCORE devuelve por puntuación. El prefijo '(' hace que una puntuación sea exclusiva. Redis 6.2 unificó ambos en ZRANGE con las opciones BYSCORE/BYLEX/REV. WITHSCORES incluye la puntuación en la salida. Para leaderboards, ZREVRANGE 0 9 da el top 10. ZRANGESTORE (6.2+) guarda el resultado en una clave nueva.

redis
# 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)

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

# descending order
ZREVRANGE leaderboard 0 2            # top 3 (highest scores)
ZREVRANGEBYSCORE leaderboard 200 100 # 200 down to 100

# 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

Operaciones de puntuación y rangos

ZINCRBY ajusta una puntuación atómicamente y reordena — perfecto para leaderboards en vivo. ZREMRANGEBYRANK es genial para mantener un zset acotado (p. ej., conservar solo el top 1000). ZCOUNT da el conteo en un rango sin traer los miembros. ZMSCORE (6.2+) obtiene puntuaciones por lotes, reduciendo viajes de red en búsquedas de varios miembros.

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

# get the score
ZSCORE leaderboard "alice"

# remove a member
ZREM leaderboard "bob"

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

# count members in a score range
ZCOUNT leaderboard 100 200

# get the rank
ZRANK leaderboard "alice"          # ascending rank
ZREVRANK leaderboard "alice"       # descending rank (0 = highest)

# get multiple members' scores at once
ZMSCORE leaderboard "alice" "bob"  # ["250", "200"]

Rangos lexicográficos (BYLEX)

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

redis
# 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

Agregaciones de sorted sets

ZUNIONSTORE/ZINTERSTORE combinan zsets con agregación configurable (SUM/MIN/MAX) y pesos — potente para puntuaciones ponderadas (p. ej., relevancia = text_match*2 + recency*1). Redis 6.2 añadió ZUNION/ZINTER/ZDIFF que devuelven resultados sin almacenar (un comando menos). Son O(N*M) — cuidado con muchos sets grandes. El número de sets va antes de los nombres de los sets.

redis
# ZUNIONSTORE / ZINTERSTORE: 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
08

Pub/Sub

Conceptos básicos de Pub/Sub

Pub/Sub es fire-and-forget: los mensajes se entregan a los suscriptores conectados en ese momento, sin persistencia. Si no hay ningún suscriptor escuchando, el mensaje se pierde. Eso lo hace inadecuado para entrega fiable — para eso usa Streams. Pub/Sub es ideal para notificaciones en tiempo real, chat y fan-out donde alguna pérdida puntual es aceptable. Los suscriptores deben estar conectados para recibir.

redis
# subscribe to channels (in one client)
SUBSCRIBE news alerts

# publish a message to a channel (from another client)
PUBLISH news "Breaking: Redis 7.4 released"

# pattern subscription (glob-style)
PSUBSCRIBE news.*

# unsubscribe
UNSUBSCRIBE news
PUNSUBSCRIBE news.*

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

Pub/Sub sharded (7.0+)

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

redis
# 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)

Patrones y casos de uso de Pub/Sub

Pub/Sub es perfecto para patrones de fan-out: un publicador, muchos suscriptores (salas de chat, dashboards en vivo, invalidación de caché). PSUBSCRIBE con patrones glob (user:*:login) permite un enrutado flexible. La limitación principal es la falta de persistencia — si un suscriptor se desconecta, pierde mensajes. Para entrega fiable, combina Pub/Sub con un Stream como respaldo, o usa directamente Streams.

redis
# 1. Real-time chat
# client subscribes to their room
SUBSCRIBE chat:room:42
# server publishes messages
PUBLISH chat:room:42 "Alice: hello"

# 2. Cache invalidation
# subscribe to invalidation channel
SUBSCRIBE cache:invalidate
# when data changes, publish
PUBLISH cache:invalidate "user:123"

# 3. Event notifications (with PSUBSCRIBE patterns)
PSUBSCRIBE user:*:login
# matches user:1:login, user:2:login, etc.

# 4. Live dashboards
SUBSCRIBE metrics:*
# push real-time updates to dashboards

# 5. Multiplayer game state
PUBLISH game:room:1 "player_moved:5:10"

Keyspace notifications

Las keyspace notifications permiten a los clientes reaccionar a eventos del ciclo de vida de las claves (set, delete, expire, evict). Se configuran 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 procesamiento fiable de eventos, usa Streams. Las keyspace notifications son geniales para efectos secundarios como limpieza o calentamiento de caché.

redis
# 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

Pub/Sub vs Streams

Pub/Sub es para mensajería efímera en tiempo real; Streams para mensajería duradera y reproducible. Un híbrido habitual: Pub/Sub para notificaciones en vivo (rápido, con pérdidas) + Streams como fuente de verdad (duradero, reproducible). Los nuevos suscriptores leen el Stream para ponerse al día y luego se suscriben a Pub/Sub para las actualizaciones en vivo. Para la mayoría de sistemas de producción que necesitan fiabilidad, Streams es el mejor punto de partida.

redis
# Pub/Sub: fire-and-forget, no persistence
PUBLISH channel "msg"   # lost if no subscribers

# Streams: persistent, replayable, consumer groups
XADD mystream * msg "hello"   # stored forever (or capped)

# Pub/Sub pros: simple, low latency, fan-out
# Pub/Sub cons: no persistence, no replay, no consumer groups

# Streams pros: persistent, replayable, consumer groups, ACK
# Streams cons: more complex, requires cleanup (XADD MAXLEN)

# when to use each:
# - real-time notifications (loss OK)     -> Pub/Sub
# - chat with presence                    -> Pub/Sub + Streams
# - reliable task queue                   -> Streams
# - event sourcing / audit log            -> Streams
# - fan-out to transient subscribers      -> Pub/Sub
09

Transacciones y pipelining

Transacciones MULTI/EXEC

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

redis
# MULTI starts a transaction; commands are queued
MULTI
SET counter 1
INCR counter
INCR counter
GET counter
EXEC
# returns: [OK, 2, 3, "3"]

# discard a transaction (cancels all queued commands)
MULTI
SET x 1
DISCARD

# errors during queuing (syntax) abort the whole transaction
# errors during EXEC (e.g., wrong type) skip only that command

WATCH (bloqueo optimista)

WATCH implementa bloqueo optimista: si una clave vigilada cambia entre WATCH y EXEC, la transacción se aborta (EXEC devuelve nil). Este es el patrón estándar de Redis para atomicidad de leer-modificar-escribir (ya que Redis no tiene bloqueos de fila). Reintenta siempre al recibir nil. WATCH se comprueba en el momento de EXEC, no durante el encolado. UNWATCH cancela las vigilas (también ocurre al DISCONNECT).

redis
# WATCH monitors keys; if any change before EXEC, the 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

Pipelining (lotes de viajes de red)

El pipelining agrupa comandos para reducir viajes de red — mucho más rápido que comandos individuales a través de la red. A diferencia de MULTI/EXEC, los comandos en pipeline NO son atómicos (otros clientes pueden intercalarse). Usa pipelining para operaciones masivas donde la atomicidad no importa (inserciones y lecturas en lote) y MULTI/EXEC cuando necesites atomicidad. La mayoría de clientes hacen pipelining automáticamente dentro de MULTI/EXEC.

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

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

# vs MULTI/EXEC: pipelining does NOT guarantee atomicity
# other clients can interleave between pipelined commands

# raw protocol example (RESP):
# *1\r\n$4\r\nPING\r\n*1\r\n$4\r\nPING\r\n
# (send multiple commands at once, read multiple replies)

Scripts Lua (atómicos)

Los scripts Lua son la forma de hacer operaciones atómicas complejas en Redis — el script se ejecuta como una única unidad atómica (sin intercalado). EVALSHA re-ejecuta un script cargado por hash (evita reenviar el script). Mantén los scripts cortos (bloquean el servidor). Los scripts tienen requisitos de determinismo (sin llamadas aleatorias ni de tiempo) para la replicación. Redis 7+ usa FUNCTIONS como alternativa más estructurada.

redis
# Lua scripts run atomically — no other command runs during execution
# EVAL: run a script
EVAL "return redis.call('GET', KEYS[1])" 1 mykey

# 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"

# load a script once, then run by SHA hash (efficient)
SCRIPT LOAD "return redis.call('GET', KEYS[1])"
# returns a SHA1 hash
EVALSHA <sha1> 1 mykey

# check if a script is loaded
SCRIPT EXISTS <sha1>

Functions (Redis 7.0+)

Functions (7.0+) mejora los scripts EVAL: tienen nombre (no solo hash), se organizan en librerías y persisten tras los reinicios (los scripts EVAL son efímeros). Esto los hace más fáciles de gestionar y desplegar. FCALL invoca una función por su nombre. Functions son la forma moderna de añadir lógica atómica en el servidor. Como los scripts, deben ser deterministas para la replicación.

redis
# 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

# get the function's code
FUNCTION DUMP mylib

# delete a library
FUNCTION DELETE mylib

# functions persist across restarts (unlike EVAL scripts)
10

Persistencia

Snapshots RDB

Los snapshots RDB son archivos binarios compactos, ideales para backups y recuperación ante desastres. BGSAVE hace un fork del proceso (copy-on-write) así que el hilo principal no se bloquea, pero conjuntos de datos grandes pueden causar picos de memoria durante el fork. Las reglas 'save' disparan snapshots automáticos según la tasa de cambios. RDB arriesga perder los datos escritos tras el último snapshot — combínalo con AOF para durabilidad.

redis
# RDB: point-in-time snapshot of the dataset (compact binary)
# trigger a snapshot manually:
SAVE              # blocks until done (use with care)
BGSAVE            # forks a background process (non-blocking)
LASTSAVE          # Unix timestamp of the last successful save

# 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 (default: dump.rdb in the working dir)
CONFIG GET dbfilename
CONFIG GET dir

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

AOF (Append-Only File)

AOF añade cada comando de escritura a un log — mucho más duradero que RDB (como máximo 1 segundo de pérdida de datos con everysec). 'always' hace fsync en cada escritura (muy lento, solo para datos críticos). BGREWRITEAOF compacta el log (lo reescribe como el conjunto mínimo de comandos). Los archivos AOF son más grandes y lentos de cargar que RDB. Redis 7 usa un formato AOF multiparte (base + incremental).

redis
# 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

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

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

Híbrido RDB + AOF

Ejecutar RDB + AOF juntos te da el reinicio rápido de RDB y la durabilidad de AOF. Desde Redis 7, el AOF es un archivo multiparte: un snapshot base RDB + un log incremental de comandos — combinando carga rápida con mínima pérdida de datos. aof-use-rdb-preamble (yes por defecto) pone un snapshot RDB al inicio del AOF para una recuperación más rápida. Esta es la configuración de producción recomendada.

redis
# use BOTH RDB and AOF for the best of both worlds
# redis.conf:
#   save 900 1          # RDB snapshots
#   appendonly yes      # AOF enabled
#   aof-use-rdb-preamble yes  # RDB header in AOF (faster load)

# on restart, Redis loads AOF (more complete)
# the AOF file can start with an RDB snapshot (faster load)
# followed by incremental AOF commands

# disaster recovery: keep both RDB and AOF backups
# RDB for fast restores, AOF for minimal data loss

# check what's enabled
CONFIG GET save
CONFIG GET appendonly

# monitor persistence operations
INFO persistence

Backup y restauración

Haz backup del archivo RDB (compacto, rápido) con regularidad — es un snapshot consistente incluso con Redis en marcha (copy-on-write). Para AOF, haz backup del directorio appendonly completo (multiparte de Redis 7). Restaura deteniendo Redis, reemplazando los archivos y rearrancando. Para recuperarte de un comando erróneo, edita el AOF para eliminarlo antes de reiniciar. Prueba siempre los backups con redis-check-rdb/aof.

redis
# backup: copy the RDB file while Redis runs
cp /var/lib/redis/dump.rdb /backup/dump-$(date +%F).rdb

# or trigger a BGSAVE first for a consistent snapshot
BGSAVE
# wait for LASTSAVE to update, then copy the file

# AOF backup: copy the AOF manifest + files
cp /var/lib/redis/appendonly.aof.* /backup/

# restore: stop Redis, replace the data files, start
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)
redis-check-rdb /var/lib/redis/dump.rdb
redis-check-aof /var/lib/redis/appendonly.aof

Compromisos de la persistencia

La elección de persistencia depende de tus necesidades de durabilidad. Caché pura: desactiva la persistencia para máxima velocidad. Datos críticos: RDB+AOF (recomendado). Un patrón común: desactivar la persistencia en el primario (por rendimiento) y persistir en una réplica (descarga la I/O de disco). El AOF everysec es el punto óptimo — como mucho 1 segundo de pérdida de datos con impacto mínimo en el rendimiento. Prueba siempre la recuperación.

redis
# choosing a persistence strategy:

# 1. RDB only (cache, re-buildable data)
#    save 3600 1
#    appendonly no
#    -> fast restart, some data loss on crash

# 2. AOF only (durability-critical, everysec)
#    save ""
#    appendonly yes
#    appendfsync everysec
#    -> up to 1s data loss, larger files

# 3. RDB + AOF (recommended production default)
#    save 3600 1
#    appendonly yes
#    aof-use-rdb-preamble yes
#    -> durability + fast restart

# 4. No persistence (pure cache, ephemeral)
#    save ""
#    appendonly no
#    -> maximum speed, all data lost on restart

# 5. Replica-only persistence (offload from primary)
#    primary: no persistence (max performance)
#    replica: RDB + AOF (persist here instead)
11

Clustering

Conceptos básicos de Redis Cluster

Redis Cluster reparte los datos entre nodos usando 16,384 hash slots. CRC16(key) % 16384 determina el slot. Las operaciones multi-clave (MGET, transacciones) requieren claves en el mismo slot — usa hash tags ({user:1}) para forzar que las claves relacionadas vayan juntas. Cada primario puede tener réplicas para alta disponibilidad. El clúster gestiona el failover automáticamente cuando falla un primario.

redis
# Redis Cluster shards data across multiple nodes (16,384 slots)
# each key maps to a slot: CRC16(key) % 16384

# 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 status
redis-cli -p 7000 CLUSTER INFO
redis-cli -p 7000 CLUSTER NODES

# count slots assigned
CLUSTER COUNTKEYSINSLOT 1234

# get the slot for a key
CLUSTER KEYSLOT mykey   # e.g., 1234

# multi-key operations require keys in the SAME slot
# 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 {})

Hash tags y operaciones multi-clave

Los hash tags ({...}) fuerzan que las claves caigan en el mismo slot, habilitando operaciones multi-clave en un clúster. Pero úsalos con criterio — abusar de una etiqueta (p. ej., {users}:1, {users}:2) crea un hotspot en un shard. Diseña los hash tags en torno a los patrones de acceso: agrupa claves que se acceden juntas (los datos de un usuario, los artículos de un pedido) y mantiene separadas las claves no relacionadas. Este es el reto central de modelado de datos en clúster.

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

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)
# - too narrow -> can't do multi-key ops

Resharding del clúster

El resharding mueve slots entre nodos sin tiempo de inactividad — Redis migra las claves de una en una mientras atiende peticiones. Añade nodos y luego rebalancea para repartir la carga. La herramienta CLI --cluster gestiona la orquestación compleja. Ejecuta siempre --cluster check tras los cambios. El resharding es lento (migración clave a clave), así que planifica la capacidad con antelación en lugar de reshardear bajo carga.

redis
# move slots from one node to another (resharding)
redis-cli --cluster reshard host1:7000
# prompts for: how many slots, target node, source nodes

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

# add a new replica to an existing primary
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>

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

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

Failover del clúster

El failover del clúster es automático: si un primario está inalcanzable más allá de cluster-node-timeout (15s por defecto), su réplica es promovida. El failover manual es para mantenimiento (actualizaciones sin parada). TAKEOVER arriesga split-brain — úsalo solo en emergencias. Sin réplicas, un primario que falla deja sus slots indisponibles (clúster caído). Ejecuta siempre con réplicas en producción. CLUSTER NODES muestra la topología.

redis
# when a primary fails, its replica is promoted automatically
# manual failover (for maintenance):
redis-cli -p 7001 CLUSTER FAILOVER         # replica -> primary
redis-cli -p 7001 CLUSTER FAILOVER FORCE   # without primary agreement
redis-cli -p 7001 CLUSTER FAILOVER TAKEOVER # force, may split brain

# view the cluster topology
CLUSTER NODES
CLUSTER SHARDS    # (7.0+)

# a node flagged as FAIL after timeout is removed
# cluster- node-timeout 15000   (15 seconds in redis.conf)

# if a cluster has no replica for a failing primary,
# that slot range becomes unavailable until the primary returns
# (or you manually fix it)

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

Cluster vs Sentinel vs instancia única

Instancia única para desarrollo. Sentinel para alta disponibilidad cuando los datos caben en una máquina (un primario + réplicas + sentinels para monitorizar/hacer failover). Cluster para escalado horizontal cuando los datos superan una máquina o el throughput de escritura es muy alto. El clúster añade complejidad (hash tags, límites multi-clave). Los servicios gestionados (Redis Cloud, ElastiCache, MemoryDB) asumen la carga operativa — prefierelos salvo que tengas fuertes motivos para autoalojar.

redis
# Single Redis: one instance, no HA, no scaling
#    simplest, fine for dev/small cache

# Sentinel: 1 primary + replicas + sentinel monitors
#    HA (automatic failover), no sharding
#    good when dataset fits on one machine
#    sentinel.conf: sentinel monitor mymaster host 6379 2

# Cluster: sharded across N primaries + replicas
#    HA + horizontal scaling
#    good for large datasets / high throughput
#    more complex (multi-key limitations)

# choose:
# - dev / tiny cache              -> single
# - production, data fits in RAM  -> sentinel (HA)
# - data > single machine RAM     -> cluster (sharding)
# - very high write throughput    -> cluster (shard writes)

# managed Redis (Redis Cloud, ElastiCache) handles
# sentinel/cluster ops for you
12

Sentinel (alta disponibilidad)

Configuración de Sentinel

Sentinel ofrece alta disponibilidad sin sharding: monitoriza un primario, promueve una réplica ante fallos y reconfigura los clientes. El quorum (el último número) es cuántos sentinels deben coincidir en que el primario está caído — fíjalo en (N/2)+1 para N sentinels. Despliega 3 sentinels en máquinas separadas para tolerancia a fallos. down-after-milliseconds debería ser > que la vibración de la red; demasiado bajo causa failovers falsos.

redis
# 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

Comandos de Sentinel

Los clientes se conectan a los Sentinels para descubrir el primario actual y luego se conectan a él. Tras un failover, los clientes vuelven a consultar a los Sentinels para encontrar el nuevo primario. SENTINEL failover dispara un failover manual (para actualizaciones rodantes). ckquorum verifica que tienes suficientes sentinels para el quorum — ejecútalo en la monitorización. Todas las librerías cliente importantes de Redis soportan Sentinel de forma nativa.

redis
# query sentinel state
redis-cli -p 26379 SENTINEL masters          # all monitored primaries
redis-cli -p 26379 SENTINEL master mymaster  # details of one primary
redis-cli -p 26379 SENTINEL replicas mymaster
redis-cli -p 26379 SENTINEL sentinels mymaster

# find the current primary address
SENTINEL get-master-addr-by-name mymaster

# force a failover (manual, for maintenance)
SENTINEL failover mymaster

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

# check the number of OK sentinels
SENTINEL ckquorum mymaster
# "OK 3 usable Sentinels" or "NOQUORUM" warning

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

Proceso de failover

El failover es automático pero causa una breve interrupción de escrituras (segundos). SDOWN es la opinión de un sentinel; ODOWN es el consenso del quorum. El líder sentinel elegido escoge la réplica más actualizada para promoverla. Cuando el antiguo primario regresa, se convierte en réplica — las escrituras que aceptó durante la partición de red se PIERDEN (riesgo de split-brain). Suscríbete a +switch-master para alertas.

redis
# when a primary is down longer than down-after-milliseconds:
# 1. sentinels mark it 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-*

Réplicas de lectura y escalado

Las réplicas descargan lecturas del primario — útil para cargas de muchas lecturas (analítica, reporting). La replicación es asíncrona, así que los datos de la réplica pueden ir rezagados (normalmente milisegundos, pero puede crecer bajo carga). Usa READONLY para leer de réplicas. Las réplicas escribibles (4.0+) aceptan escrituras no replicadas — útil para datos temporales o cachés por réplica, pero las escrituras se pierden en el failover. Monitoriza el retardo de las réplicas.

redis
# replicas can serve reads (eventually consistent)
REPLICAOF 192.168.1.10 6379    # become a replica of this primary
REPLICAOF NO ONE               # promote to primary (manual)

# check replication status
INFO replication
# role:slave, master_host, master_link_status:up, ...

# replica lag (bytes and seconds lagging behind primary)
# master_repl_offset vs slave_repl_offset

# clients can route reads to replicas for read scaling
# but beware: replica data may be stale (replication lag)

# Redis Sentinel + clients: configure read preference
#   READONLY command enables reads on a replica

# writable replicas (Redis 4.0+): accept writes that are
# local-only (not replicated) — useful for ephemeral data
#   replica-read-only no   (in redis.conf)

Interior de la replicación

La replicación es asíncrona y unidireccional (de primario a réplica). La sincronización inicial envía un RDB completo y luego el backlog de comandos; PSYNC permite resincronización parcial tras desconexiones cortas (usando el backlog de replicación — ajusta repl-backlog-size). Un cambio de replication ID (en el reinicio del primario o en un failover) fuerza una resincronización completa. La replicación en cadena (réplica de una réplica) reduce la carga del primario en fan-outs grandes.

redis
# replication is asynchronous: primary -> replica (one-way)
# initial sync: full RDB transfer + buffered commands
# subsequent: streaming command log

# trigger a full resync (force replica to reload everything)
redis-cli -p 6380 REPLICAOF NO ONE
redis-cli -p 6380 REPLICAOF 192.168.1.10 6379

# partial resync (PSYNC): if the replica disconnects briefly,
# it can resume from the replication backlog (no full resync)
#   repl-backlog-size 1mb    (tune for longer disconnects)

# monitor replication in real-time
redis-cli -p 6379 INFO replication
# master_repl_offset, slave_read_repl_offset, backlog_size

# chain replication: a replica of a replica (tree topology)
# reduces load on the primary for many replicas
REPLICAOF replica-host 6380   # chain off another replica

# replication ID changes on every primary restart -> full resync
13

Streams

Conceptos básicos de streams (XADD/XREAD)

Los streams son la estructura de mensajería duradera de Redis — de solo adición, reproducibles y con consumer groups. Los IDs se basan en timestamps (auto-generados con *). XREAD con $ hace tail del stream (solo entradas nuevas); con 0 lee desde el principio. MAXLEN acota el stream (~ para aproximado es mucho más rápido). Los streams resuelven el problema de falta de persistencia de Pub/Sub y son la forma recomendada de construir colas fiables.

redis
# streams are append-only logs with IDs (durable, replayable)
# XADD: add an entry (auto-generate ID with *)
XADD mystream * sensor temp 25.5
# returns an ID like "1700000000000-0" (timestamp-sequence)

# add with a specific ID (must be greater than the last)
XADD mystream 1700000001000-0 sensor temp 26.0

# read entries
XREAD COUNT 10 STREAMS mystream 0        # from the beginning
XREAD COUNT 10 STREAMS mystream $        # new entries only (tail)

# block for new entries (like BLPOP for lists)
XREAD BLOCK 30000 STREAMS mystream $     # blocks up to 30s

# get the length
XLEN mystream                            # number of entries

# capped stream (keep only last N entries)
XADD mystream MAXLEN 1000 * field value
XADD mystream MAXLEN ~ 1000 * field value  # ~ = approx (faster)

Consumer groups

Los consumer groups permiten procesamiento paralelo: cada entrada se entrega exactamente a un consumidor del grupo. '>' lee entradas nuevas; '0' lee las entradas pendientes (sin ack) de este consumidor. XACK marca una entrada como procesada. Las entradas pendientes (entregadas pero sin ack) forman un log de procesamiento — usa XPENDING para encontrar mensajes atascados y XCLAIM para reasignarlos a otro consumidor tras un timeout.

redis
# create a consumer group at a specific position
XGROUP CREATE mystream mygroup $        # only new entries
XGROUP CREATE mystream mygroup 0        # all existing entries
XGROUP CREATE mystream mygroup 0 MKSTREAM  # create stream if missing

# read entries as a consumer (assigns pending entries)
XREADGROUP GROUP mygroup consumer1 COUNT 10 STREAMS mystream >
# '>' = never-delivered entries

# read pending entries (for this consumer, not yet acked)
XREADGROUP GROUP mygroup consumer1 STREAMS mystream 0

# acknowledge processing (removes from pending)
XACK mystream mygroup <id1> <id2>

# view pending entries (pending entries list)
XPENDING mystream mygroup
# returns: count, min-id, max-id, consumers

# view a consumer's pending entries
XPENDING mystream mygroup - + 10 consumer1

Procesamiento y recuperación de streams

XAUTOCLAIM es clave para un procesamiento fiable: reasigna las entradas que llevan demasiado tiempo pendientes (consumidor caído o detenido) a un consumidor sano. min-idle-time evita robar entradas que aún se están procesando. XTRIM acota el tamaño del stream (esencial para la memoria). XRANGE lee un rango por ID. XINFO revela el estado del stream/grupo/consumidor para monitorizar. Esto es una cola de mensajes completa y duradera.

redis
# XCLAIM: reassign a pending entry to another consumer
# (after the original consumer died or is too slow)
XCLAIM mystream mygroup consumer2 60000 <entry-id>
# 60000 = min idle time (ms) before claiming

# XAUTOCLAIM (6.2+): auto-claim stale pending entries
XAUTOCLAIM mystream mygroup consumer2 60000 0 COUNT 10
# claims entries idle > 60s, returns them to consumer2

# view stream info
XINFO STREAM mystream FULL
XINFO GROUPS mystream
XINFO CONSUMERS mystream mygroup

# delete an entry (rarely needed)
XDEL mystream <id>

# trim the stream (free memory)
XTRIM mystream MAXLEN 10000
XTRIM mystream MINID 1700000000000   # remove older than this ID

# range queries
XRANGE mystream - +                   # all entries
XRANGE mystream 1700000000000 - 1700000009999 -

Casos de uso de los streams

Los streams destacan en colas fiables, event sourcing y datos de series temporales. El patrón consumer group (XADD + XREADGROUP + XACK) es un reemplazo completo de las colas basadas en listas, con reintentos integrados (entradas pendientes) y recuperación (XAUTOCLAIM). Para series temporales, MAXLEN mantiene la memoria acotada. Los streams son la estructura de Redis más completa en funciones — úsalos siempre que necesites durabilidad y procesamiento ordenado.

redis
# 1. Reliable task queue (replaces lists + BRPOPLPUSH)
XADD tasks * type email payload '{"to":"[email protected]"}'
XREADGROUP GROUP workers worker1 COUNT 1 STREAMS tasks >
# process and XACK on success

# 2. Event sourcing / audit log
XADD events * user 1 action login ip 1.2.3.4
# replay with XRANGE for reconstruction

# 3. Real-time analytics (time-windowed)
XADD metrics * cpu 75 mem 60
XRANGE metrics - +           # query by time range

# 4. Chat history (capped)
XADD chat:room:1 MAXLEN ~ 1000 * user alice msg "hello"
XREAD COUNT 20 STREAMS chat:room:1 0

# 5. IoT sensor data (with TTL via trimming)
XADD sensors:temp MAXLEN ~ 86400 * value 22.5  # keep last day

Streams frente a otras colas

Los streams son la cola nativa de Redis — más simples que Kafka/RabbitMQ y suficientes para la mayoría de cargas que caben en RAM. Carecen del paralelismo a nivel de partición de Kafka (un stream = un shard), pero los consumer groups aportan paralelismo de workers. Para throughput muy alto o durabilidad en disco, gana Kafka. Para enrutado complejo, gana RabbitMQ. Para la mayoría de apps que ya usan Redis, los streams son la opción por defecto para mensajería fiable.

redis
# Redis Streams vs Lists (for queues):
# Lists: LPUSH/BRPOP, simple, NO retry/recovery
# Streams: consumer groups, ACK, pending, XAUTOCLAIM

# Redis Streams vs Kafka:
# Streams: in-memory (RAM-bounded), simpler, single-node or cluster
# Kafka: disk-based, partitioned, higher throughput at scale

# Redis Streams vs RabbitMQ:
# Streams: simpler, fewer features, in-memory
# RabbitMQ: rich routing, exchanges, acknowledgments, disk

# Streams capacity: limited by RAM (use MAXLEN/MINID to trim)
# Streams persistence: RDB/AOF (like any Redis data)

# choose Streams when:
# - you need a queue but already use Redis
# - dataset fits in RAM
# - you want simplicity over Kafka's scale
# - you need consumer groups with retry
14

HyperLogLog, bitmaps y geo

HyperLogLog (cardinalidad)

HyperLogLog (HLL) cuenta elementos únicos con ~0.81% de error usando 12KB fijos — cuenta miles de millones de elementos con memoria constante. Perfecto para analítica como visitantes únicos diarios/semanales/mensuales. PFMERGE combina HLLs (p. ej., únicos mensuales a partir de los diarios). El compromiso es la aproximación — usa un Set cuando necesites conteos exactos o pruebas de pertenencia (SISMEMBER), y HLL cuando solo necesites el conteo.

redis
# HyperLogLog: approximate unique count with fixed 12KB memory
# perfect for counting unique visitors, IPs, etc. at scale

# add elements (returns 1 if the cardinality changed)
PFADD visitors:2025-01-01 "user:1" "user:2" "user:3"

# get the approximate unique count
PFCOUNT visitors:2025-01-01        # ~3

# merge multiple HLLs (e.g., monthly uniques from daily)
PFMERGE visitors:2025-01 visitors:2025-01-01 visitors:2025-01-02

# accuracy: ~0.81% standard error
# memory: always ~12KB regardless of element count (up to 2^64)

# vs a Set for unique counting:
# SADD + SCARD: exact, but O(N) memory (grows with count)
# PFADD + PFCOUNT: approximate, fixed 12KB memory
# 1 million uniques: Set ~10MB, HLL always 12KB

Bitmaps a fondo

Los bitmaps almacenan un bit por usuario — 1 millón de usuarios = 125KB, 4 mil millones = 512MB. BITOP AND/OR/XOR/NOT combina bitmaps (retención, análisis de fuga de usuarios). BITPOS encuentra el primer bit activado. Casos de uso: usuarios activos diarios, feature flags, asistencia, grupos de pruebas A/B. Limitación: requiere IDs de usuario enteros densos (los huecos desperdician espacio). Para datos dispersos, prefiere un Set o HyperLogLog.

redis
# bitmaps: boolean operations on a string's bits
# ideal for per-user flags over a large user base (user ID = bit position)

# mark user 7 as "active today"
SETBIT active:2025-01-01 7 1

# check if user 7 was active
GETBIT active:2025-01-01 7          # 1

# count active users
BITCOUNT active:2025-01-01

# users active on BOTH days (AND)
BITOP AND active:both active:2025-01-01 active:2025-01-02
BITCOUNT active:both

# users active on EITHER day (OR)
BITOP OR active:either active:2025-01-01 active:2025-01-02

# users active on day 1 but NOT day 2 (XOR or AND NOT)
BITOP XOR diff active:2025-01-01 active:2025-01-02

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

# memory: 1 million users = 125KB (1 bit per user)

Geoespacial (GEO)

Los comandos GEO almacenan puntos geográficos y soportan consultas por radio/caja — construidos sobre sorted sets (puntuación = geohash). GEOSEARCH (6.2+, sustituye a GEORADIUS) encuentra puntos cercanos con opciones ricas (WITHCOORD, WITHDIST, ASC/DESC). La distancia se calcula sobre una esfera. La precisión es buena para la mayoría de apps. Para SIG complejos (polígonos, rutas), usa una base de datos espacial dedicada. GEO es perfecto para funciones de 'buscar cercanos'.

redis
# GEO: built on sorted sets, stores (lng, lat, name) points
# add locations (longitude, latitude, name)
GEOADD places -73.99 40.73 "Park" -73.98 40.75 "Museum" -74.00 40.70 "Cafe"

# get coordinates of a member
GEOPOS places "Park"               # [["-73.99","40.73"]]

# distance between two members (meters by default)
GEODIST places "Park" "Museum"     # "1623.5"
GEODIST places "Park" "Museum" km  # "1.623"

# find members within a radius (meters)
GEOSEARCH places FROMMEMBER "Park" BYRADIUS 1000 m ASC
# members within 1km of Park, sorted by distance

# find members within a bounding box
GEOSEARCH places FROMLONLAT -73.99 40.73 BYBOX 2 2 km

# GEOSEARCH also returns distance and coordinates
GEOSEARCH places FROMMEMBER "Park" BYRADIUS 500 m WITHCOORD WITHDIST

Operaciones geoespaciales

GEO está implementado sobre sorted sets — el geohash de las coordenadas es la puntuación. Esto significa que puedes usar comandos Z* para algunas operaciones (ZREM, ZRANGE). GEOSEARCH devuelve resultados ricos (distancia, coordenadas, geohash). COUNT limita los resultados (úsalo con ASC para los N más cercanos). GEOSEARCHSTORE guarda resultados para procesarlos después. La precisión del geohash se degrada cerca de los polos — suficiente para la mayoría de apps reales.

redis
# add multiple points at once
GEOADD cities -122.41 37.78 "San Francisco" -74.00 40.71 "New York"

# get the geohash of a member
GEOHASH places "Park"              # ["dr5reg..."]

# remove a member (uses ZREM internally)
ZREM places "Cafe"

# count members in an area (using ZCOUNT on the underlying zset)
ZCOUNT places -180 180             # all members

# GEOSEARCH with a center point and limiting results
GEOSEARCH places FROMLONLAT -73.99 40.73 \
  BYRADIUS 2000 m ASC COUNT 5      # nearest 5 within 2km

# GEOSEARCHSTORE: store results in a new key (6.2+)
GEOSEARCHSTORE nearby FROMLONLAT -73.99 40.73 BYRADIUS 1000 m

# the underlying structure is a sorted set, so:
ZRANGE places 0 -1                 # list all members
ZSCORE places "Park"               # geohash score

Elegir tipos especializados

Redis ofrece muchas estructuras especializadas más allá de las cinco básicas. HyperLogLog para cardinalidad aproximada, bitmaps para flags booleanos densos, GEO para proximidad. Los módulos añaden filtros Bloom (prueba de pertenencia con falsos positivos), Top-K (los más frecuentes) y RedisTimeSeries (series temporales optimizadas). Ajusta la estructura a la forma de tus datos y a tus necesidades de precisión — la elección correcta puede ahorrar órdenes de magnitud de memoria.

redis
# Cardinality counting (unique elements):
#   exact, need membership test  -> Set (SADD/SISMEMBER/SCARD)
#   approximate, huge scale      -> HyperLogLog (PFADD/PFCOUNT)
#   per-time-bucket uniques      -> HLL per day, PFMERGE for ranges

# Boolean flags over a dense ID space:
#   small number of flags        -> Set of active IDs
#   millions of users            -> Bitmap (SETBIT/BITCOUNT)
#   multiple counters compactly  -> BITFIELD

# Geographic points:
#   "find nearby" queries        -> GEO (GEOADD/GEOSEARCH)
#   complex GIS                  -> use PostGIS/external

# Time-series data:
#   simple, capped               -> Stream (XADD MAXLEN)
#   dedicated TS module          -> RedisTimeSeries (module)

# Probabilistic structures (modules):
#   Bloom filter                 -> RedisBloom (BF.ADD/BF.EXISTS)
#   Top-K                        -> RedisBloom (TOPK)
15

Seguridad

Autenticación y ACLs

Las ACLs de Redis 6+ reemplazan el modelo de contraseña única — crea usuarios con permisos acotados. La sintaxis: on (activado), >password, ~pattern (patrones de claves), +command/-command, +@category/-@category (p. ej., +@read, -@dangerous). Crea siempre un usuario de mínimos privilegios para cada app. Guarda las ACLs en un archivo para que persistan. Nunca uses el usuario por defecto en producción — desactívalo o ponle una contraseña fuerte.

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

# Redis 6+: ACL system with users and permissions
# add a user with limited access
ACL SETUSER appuser on >secretpassword ~app:* +get +set +del -@dangerous

# list users
ACL LIST
ACL WHOAMI                # current user

# view a user's permissions
ACL GETUSER appuser

# delete a user
ACL DELUSER appuser

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

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

Cifrado TLS/SSL

TLS cifra los datos en tránsito — esencial en 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, activa TLS también en la comunicación entre nodos. El puerto 0 desactiva el texto plano; durante la migración puedes mantener ambos puertos temporalmente.

redis
# enable TLS in redis.conf (Redis 6+)
# generate certs first (or use a real CA):
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-cluster yes              # TLS between cluster nodes
tls-replication yes          # TLS between primary/replica
tls-auth-clients yes         # require client certs

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

Seguridad de red

Redis no tiene control de acceso de red nativo — usa bind + protected-mode + un firewall. NUNCA expongas Redis a internet (innumerables brechas por Redis abiertos sin autenticación). protected-mode bloquea conexiones externas cuando no hay contraseña. rename-command desactiva comandos peligrosos (FLUSHALL, CONFIG, KEYS), pero las ACLs (6.0+) son el enfoque moderno. Pon Redis en una subred privada; accede vía VPN o bastión.

redis
# bind to specific interfaces (never 0.0.0.0 in prod)
bind 127.0.0.1 10.0.0.5
protected-mode yes            # blocks external access if no password

# require authentication
requirepass "strong-random-password"

# rename dangerous commands (or disable them)
rename-command FLUSHALL ""
rename-command FLUSHDB ""
rename-command CONFIG "CONFIG_9f8a7b"
rename-command KEYS ""

# Redis 6+: better to use ACLs instead of rename-command
# ACL SETUSER default -flushall -config -keys

# disable debug commands
# ACL SETUSER default -@dangerous

# use a firewall / security group to restrict access
# Redis should NEVER be directly internet-accessible
# (the 2018+ ransom attacks scanned for open Redis instances)

Auditoría y logging

SLOWLOG registra los comandos lentos para auditar el rendimiento — fija el umbral en tu SLO (p. ej., 10ms). MONITOR registra cada comando (enorme impacto en el rendimiento — solo para depurar). LATENCY MONITOR ayuda a encontrar picos de latencia. CLIENT LIST muestra los clientes conectados (vigila fugas). Fija loglevel en 'notice' en producción (debug es demasiado verboso). Envía los logs a un sistema central para su análisis.

redis
# log slow commands (slowlog)
CONFIG SET slowlog-log-slower-than 10000   # 10ms in microseconds
CONFIG SET slowlog-max-len 128             # keep 128 entries
SLOWLOG GET 10                             # last 10 slow commands
SLOWLOG RESET

# log to a file (redis.conf)
logfile /var/log/redis/redis.log
loglevel notice    # debug|verbose|notice|warning

# monitor all commands (debugging only — huge perf impact)
MONITOR

# latency monitoring
CONFIG SET latency-monitor-threshold 100   # 100ms
LATENCY HISTORY event-name
LATENCY DOCTOR                              # analysis report

# client list (who's connected)
CLIENT LIST
CLIENT GETNAME
CLIENT SETNAME "my-app"

Buenas prácticas de seguridad

La seguridad de Redis es por capas: red (bind/firewall), autenticación (contraseña/ACL), transporte (TLS), restricción de comandos (ACL/rename) y auditoría (slowlog/monitor). La regla número uno: nunca expongas Redis directamente a internet — no tiene rate limiting ni protección contra fuerza bruta integradas. Cifra los archivos RDB/AOF a nivel de disco (contienen tus datos en texto plano). Mantén Redis actualizado con los parches de seguridad.

redis
# 1. NEVER expose Redis to the public internet
bind 127.0.0.1
protected-mode yes

# 2. Use strong passwords or ACLs
requirepass "<64-char-random-string>"
# or ACLs with least privilege

# 3. Enable TLS for transit encryption
tls-port 6379

# 4. Restrict dangerous commands
ACL SETUSER default -@dangerous -flushall -keys

# 5. Use a firewall / security group
# allow only app servers on the Redis port

# 6. Rotate credentials regularly
ACL SETUSER appuser on >newpassword ~app:* +@read +@write

# 7. Audit access
LOGICALDB MONITOR  # or use an audit module

# 8. Encrypt sensitive data at rest (disk encryption)
# RDB/AOF files can contain sensitive data

# 9. Keep Redis updated (security patches)
# 10. Isolate environments (separate dev/staging/prod)
16

Rendimiento y optimización

Fundamentos de rendimiento

Redis es de un solo hilo para la ejecución de comandos — un comando lento bloquea a la totalidad de los clientes. Nunca uses KEYS, SMEMBERS ni DEL sobre estructuras grandes en producción. Usa la familia SCAN, HSCAN y UNLINK (borrado asíncrono) en su lugar. Agrupa comandos en pipeline para reducir viajes de red. Conoce el Big-O de cada comando: O(1) y O(log N) son seguros; los comandos O(N) deben acotarse (LRANGE con rangos pequeños).

redis
# Redis is single-threaded (mostly) — avoid blocking commands
# DANGEROUS on large datasets (block the server):
KEYS *              # use SCAN instead
SMEMBERS bigset     # use SSCAN
HGETALL bighash     # use HSCAN
DEL hugekey         # use UNLINK (async delete)
FLUSHDB             # use FLUSHDB ASYNC

# use UNLINK instead of DEL for large keys (non-blocking)
UNLINK bigkey       # deletes in a background thread

# favor pipelining and batch commands
MGET k1 k2 k3       # one round-trip, not three GETs
LPUSH list a b c    # one command, not three

# prefer structurally efficient commands
# O(1): GET, SET, HGET, SISMEMBER, ZSCORE
# O(log N): ZADD, ZRANGE
# O(N): LRANGE, SMEMBERS, KEYS, SORT

Pipelining y operaciones por lotes

El pipelining es la mayor palanca de rendimiento de Redis — agrupar comandos en un solo viaje de red puede dar aceleraciones de 10-100x. Cada viaje cuesta latencia de red (~0.1-1ms); 1000 comandos individuales = 100-1000ms, pero en pipeline = ~1ms. No abuses del pipelining (las respuestas encoladas consumen memoria). Haz benchmark con redis-benchmark -P para encontrar tu punto óptimo. Las transacciones usan pipelining automáticamente.

redis
# pipelining: send many commands without waiting for replies
# (reduces round-trip time — huge speedup over network)

# example (Node.js with ioredis):
const pipeline = redis.pipeline()
for (let i = 0; i < 1000; i++) {
  pipeline.set(`key:${i}`, "value")
}
await pipeline.exec()        # one round-trip for 1000 commands

# transactions (MULTI/EXEC) are automatically pipelined
redis.multi().set("k", "v").incr("c").exec()

# MSET/MGET batch in one command
MSET k1 v1 k2 v2 k3 v3
MGET k1 k2 k3

# benchmark pipelining
redis-benchmark -t set -n 100000 -P 16   # -P = pipeline size

# don't pipeline too many at once (memory for queued replies)
# batch in groups of 100-1000

Optimización de memoria

La memoria es la restricción principal de Redis. Usa la estructura adecuada: hashes para objetos (la codificación listpack es 5-10x menor que claves separadas). Ajusta los umbrales de codificación para mantener las estructuras en forma compacta. El 'key bucketing' (agrupar claves pequeñas en un hash) reduce drásticamente la sobrecarga por clave. Fija maxmemory + una política de eviction para evitar OOM. Monitoriza used_memory y el ratio de fragmentación.

redis
# use the right data structure (memory vs speed trade-offs)
# store small objects as hashes (listpack encoding is compact)
HSET user:1 name "Alice" age 30   # better than 3 string keys

# tune encoding thresholds (redis.conf)
hash-max-listpack-entries 128     # hash -> hashtable above this
hash-max-listpack-value 64        # field value size limit
list-max-listpack-size -2         # listpack max size
set-max-intset-entries 512        # intset -> hashtable above this
zset-max-listpack-entries 128

# use hashes for many small keys (key bucketing)
# instead of SET user:1:clicks 5; SET user:2:clicks 3
# use HSET clicks user:1 5 user:2 3

# monitor memory
INFO memory | grep used_memory_human
MEMORY STATS

# set maxmemory and an eviction policy
maxmemory 4gb
maxmemory-policy allkeys-lru

Políticas de eviction

La política de eviction controla el comportamiento cuando la memoria se llena. Para una caché pura: allkeys-lru o allkeys-lfu (LFU es mejor para patrones de acceso sesgados). Para una base de datos: noeviction (las escrituras fallan antes que perder datos). Para uso mixto: volatile-lru (expulsa solo claves con TTL, conserva las persistentes). LFU (4.0+) rastrea la frecuencia de acceso, a menudo superando a LRU. Monitoriza evicted_keys para dimensionar maxmemory correctamente.

redis
# when maxmemory is reached, Redis evicts keys per the policy
# maxmemory-policy options:

# no eviction (writes fail with OOM error)
maxmemory-policy noeviction

# LRU (Least Recently Used) — approximate LRU
allkeys-lru         # evict any key (cache use case)
volatile-lru        # only evict keys with TTL set

# LFU (Least Frequently Used) — better for skewed access
allkeys-lfu
volatile-lfu

# random eviction
allkeys-random
volatile-random

# TTL-based (evict soonest-expiring)
volatile-ttl

# for a cache: allkeys-lru or allkeys-lfu (best hit rate)
# for a database: noeviction (never lose data silently)
# mixed (some persistent, some cache): volatile-lru

Benchmarking

redis-benchmark mide throughput y latencia bajo carga. -c (concurrencia) simula clientes; -P (pipelining) prueba el rendimiento por lotes. --latency muestra el tiempo de ida y vuelta en tiempo real. Para resultados precisos, ejecuta el benchmark desde una máquina cercana a Redis (la red domina). Redis 6+ soporta --threads para benchmarking multihilo. Rendimiento típico de un nodo: 100K+ ops/seg en hardware normal.

redis
# redis-benchmark: built-in performance testing
redis-benchmark -t set,get -n 100000 -c 50
# -t: test commands, -n: number of requests, -c: concurrent clients

# test with pipelining
redis-benchmark -t set -n 100000 -c 50 -P 16

# test a specific command with a specific key
redis-benchmark -t get -n 100000 -r 100000 -q
# -r: random keys (INSERT random keys for testing)

# latency check (100 requests, shows distribution)
redis-cli --latency
redis-cli --latency-history    # rolling update
redis-cli --latency-dist       # histogram

# in-memory test (no network overhead)
redis-benchmark -t set -n 100000 -q --threads 4

# monitor while benchmarking
redis-cli INFO stats | grep instantaneous_ops_per_sec
17

Administración

Información del servidor y monitorización

INFO es el comando principal de monitorización — revisa las secciones de memoria, clientes, persistencia y estadísticas con regularidad. MEMORY DOCTOR y LATENCY DOCTOR aportan análisis automatizado. SLOWLOG atrapa los comandos lentos. CLIENT LIST muestra todas las conexiones (vigila fugas — cada una consume memoria). Configura monitorización externa (Prometheus + redis_exporter, Datadog) para gráficos históricos y alertas de memoria, conexiones y retardo de replicación.

redis
# 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 keyspace         # keys per database

# real-time stats
LATENCY DOCTOR        # latency analysis
MEMORY DOCTOR         # memory analysis

# live monitoring (subscribe to a special channel)
SUBSCRIBE __redis__:invalidate

# slow query log
SLOWLOG GET 10
SLOWLOG LEN

# client connections
CLIENT LIST
CLIENT KILL ID <id>   # disconnect a client

Gestión de clientes

CLIENT LIST identifica conexiones por dirección, nombre y comando actual — inestimable para encontrar fugas o clientes atascados. CLIENT SETNAME etiqueta conexiones para identificarlas fácilmente (fíjalo en tu app al conectar). CLIENT PAUSE bloquea brevemente a los clientes para migraciones/snapshots seguros. Fija un timeout para limpiar conexiones inactivas. maxclients evita el agotamiento de conexiones (cada cliente consume cierta memoria).

redis
# list all connected clients
CLIENT LIST
# id, addr, name, age, idle, flags, db, cmd

# name your connections (for identification)
CLIENT SETNAME "my-app-worker-1"

# get the current client's info
CLIENT INFO

# get the current client's ID
CLIENT ID

# kill a client
CLIENT KILL ADDR 1.2.3.4:12345
CLIENT KILL ID 42
CLIENT KILL TYPE normal    # kill all normal clients

# pause clients (for maintenance, 10 seconds)
CLIENT PAUSE 10000

# set a timeout for idle clients
CONFIG SET timeout 300    # 5 minutes

# max clients
CONFIG SET maxclients 10000

Configuración

CONFIG SET cambia ajustes en tiempo de ejecución (sin reiniciar); CONFIG REWRITE los persiste en redis.conf. Prueba siempre los cambios de configuración en staging. Ajustes clave de producción: maxmemory + política de eviction (evitar OOM), save + appendonly (persistencia), tcp-keepalive (detectar clientes muertos), timeout (limpiar conexiones inactivas). Versiona tu redis.conf. CONFIG GET * lo muestra por completo — útil para auditorías.

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

# change config at runtime
CONFIG SET maxmemory 4gb
CONFIG SET maxmemory-policy allkeys-lru
CONFIG SET slowlog-log-slower-than 10000

# persist config changes to redis.conf
CONFIG REWRITE

# view all config (large output)
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

Depuración y resolución de problemas

OBJECT ENCODING revela la representación interna (depuración de memoria). OBJECT IDLETIME encuentra claves frías (candidatas a eviction). MEMORY USAGE por clave identifica los devoradores de memoria. DEBUG SLEEP prueba cómo tu app gestiona la latencia. LATENCY rastrea eventos (expiración, eviction, claves rápidas). La desfragmentación activa (4.0+) reclama automáticamente memoria fragmentada en línea. Usa los comandos DEBUG con moderación en producción.

redis
# check if a key exists and its type
EXISTS mykey
TYPE mykey
OBJECT ENCODING mykey
OBJECT IDLETIME mykey     # seconds since last access

# memory usage per key
MEMORY USAGE mykey

# find keys blocking the server (DEBUG SLEEP for testing)
DEBUG SLEEP 2             # blocks for 2 seconds (testing only)

# check the latency
LATENCY HISTORY event
LATENCY GRAPH event

# object frequency (LFU mode)
OBJECT FREQ mykey

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

# last saved RDB timestamp
LASTSAVE

# active defragmentation (4.0+)
CONFIG SET activedefrag yes
MEMORY MALLOC-STATS

Actualizaciones y mantenimiento

Para actualizaciones sin parada, usa la replicación: actualiza primero las réplicas, haz failover y luego actualiza el antiguo primario. En clústers, haz reinicios rodantes de un nodo a la vez (primero los primarios con failover). Haz siempre backup (BGSAVE + copia del RDB) antes de actualizar. Lee las notas de la versión por si hay cambios incompatibles. Prueba en staging. Redis mantiene compatibilidad hacia atrás entre versiones menores, pero las versiones mayores pueden tener pasos de migración.

redis
# upgrade a standalone Redis:
# 1. save the dataset
SAVE
# 2. stop Redis
redis-cli SHUTDOWN
# 3. replace the binary
# 4. start the new version
redis-server /etc/redis/redis.conf

# upgrade a primary/replica pair (zero downtime):
# 1. upgrade the REPLICA first
SHUTDOWN
# 2. start new version on replica
# 3. promote replica to primary (SENTINEL FAILOVER)
# 4. upgrade the old primary (now a replica)
# 5. failback if desired

# upgrade a cluster:
# 1. upgrade one node at a time (rolling)
# 2. for each node: CLUSTER FAILOVER (if primary), upgrade, restart

# always back up before upgrading
# check the release notes for breaking changes
# test the upgrade in staging first

# rolling restart of a cluster (script)
for node in $nodes; do
  redis-cli -h $node CLUSTER FAILOVER
  redis-cli -h $node SHUTDOWN
  ssh $node "systemctl start redis"
done
18

Patrones comunes

Patrón de caché (Cache-Aside)

Cache-aside es el patrón de Redis más común: lee de la caché, recurre a la BD en fallo de caché y llena la caché. Fija un TTL para acotar la obsolescencia. En las escrituras, o escribes a través (write-through: actualiza la caché al escribir en BD) o invalidas (borras la clave de caché). La invalidación es más segura (sin carrera al rellenar), pero write-through mantiene la caché caliente. Protección contra cache stampede: usa un lock o el patrón 'dogpile' para evitar que muchas peticiones golpeen la BD a la vez en un fallo de caché.

redis
# cache-aside: app checks cache, falls back to DB, fills cache
# pseudo-code:
function get_user(id):
  # 1. check cache
  data = GET("user:" + id)
  if data:
    return JSON.parse(data)

  # 2. cache miss -> query database
  data = db.query("SELECT * FROM users WHERE id = ?", id)

  # 3. fill cache (with TTL to avoid stale data)
  SET("user:" + id, JSON.stringify(data), "EX", 3600)

  return data

# write-through: update cache when DB changes
function update_user(id, data):
  db.update(id, data)
  SET("user:" + id, JSON.stringify(data), "EX", 3600)

# cache invalidation:
DEL("user:" + id)   # when the DB record is deleted

Bloqueos distribuidos

Los bloqueos distribuidos con SET NX EX son simples pero requieren cuidado: fija siempre un TTL (evita deadlocks si el titular se cae) y usa un token único para liberar solo tu propio lock (comprobación y borrado atómicos vía Lua). Para más seguridad ante escenarios de fallo, el algoritmo Redlock usa múltiples instancias Redis independientes. Los locks no son perfectamente seguros (deriva de reloj, pausas de GC) — para garantías de corrección fuertes, considera un sistema de consenso (etcd, ZooKeeper). Los locks de Redis van bien para la mayoría de coordinación práctica.

redis
# SET NX with expiry = simple distributed lock
SET lock:resource "token-abc" NX EX 10
# returns OK if acquired, nil if already held

# release: only delete if the value matches (avoid releasing others' locks)
# (requires a Lua script for atomicity)
EVAL "
  if redis.call('GET', KEYS[1]) == ARGV[1] then
    return redis.call('DEL', KEYS[1])
  end
  return 0
" 1 lock:resource "token-abc"

# Redlock algorithm (multi-instance, higher safety):
# 1. get the time
# 2. SET NX on N (usually 5) independent Redis instances
# 3. if acquired on majority (3/5) within validity window -> locked
# 4. otherwise, release on all instances and retry

# lock options:
#   EX 10        # expire after 10 seconds (safety)
#   NX           # only if not exists
#   "token"      # unique value per lock holder (for safe release)

Rate limiting

La ventana fija (INCR+EXPIRE) es lo más simple pero permite ráfagas de 2x en los límites de ventana. La ventana deslizante (sorted set de timestamps) es más precisa pero gasta más memoria. El token bucket permite ráfagas hasta un máximo. Cada enfoque puede ser atómico con scripts Lua (importante para la corrección bajo concurrencia). Para rate limiting por usuario a gran escala, la ventana fija suele bastar y es muy eficiente en memoria.

redis
# fixed window rate limiter (simple)
# INCR + EXPIRE on first request
count = INCR("rate:user:1")
if count == 1:
  EXPIRE("rate:user:1", 60)   # 60-second window
if count > 100:
  return "Rate limited"

# sliding window rate limiter (sorted set)
now = current_time_millis()
ZADD("rate:user:1", now, now)         # add current request
ZREMRANGEBYSCORE("rate:user:1", 0, now - 60000)  # remove old
EXPIRE("rate:user:1", 60)
count = ZCARD("rate:user:1")          # current count
if count > 100:
  return "Rate limited"

# token bucket (Lua script for atomicity)
# maintains a bucket of tokens refilled over time
# see: https://redis.io/docs/patterns/distributed-locks/

# GCRA (Generic Cell Rate Algorithm) — elegant single-key version

Leaderboard y ranking

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

redis
# sorted set = perfect for leaderboards
ZADD leaderboard 100 "alice" 250 "bob" 150 "carol"

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

# a player's rank
ZREVRANK leaderboard "alice"     # 0-indexed from top

# 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

Almacén de sesiones

Redis es el almacén de sesiones clásico: rápido, soporta TTL (expiración automática) y se comparte entre servidores de la app. Usa un hash por sesión con un TTL deslizante (refréscalo en cada petición). Rastrea las sesiones de un usuario en un set para funciones de 'cerrar sesión en todas partes'. En un clúster, usa hash tags ({user:1}) para mantener la sesión de un usuario y su índice de sesiones en el mismo shard. Rota los IDs de sesión al hacer login o cambiar privilegios por seguridad.

redis
# Redis is ideal for web sessions (fast, expiring, shared)
# store session as a hash with TTL
HSET session:abc123 user_id 1 last_active 1700000000 data "..."
EXPIRE session:abc123 1800     # 30-minute timeout

# update session (and refresh TTL)
HSET session:abc123 last_active 1700001000
EXPIRE session:abc123 1800     # sliding expiration

# destroy a session
DEL session:abc123

# list active sessions for a user (index by user)
SADD user:1:sessions "session:abc123"
SMEMBERS user:1:sessions       # all session IDs

# cluster-friendly: use a hash tag for the user's sessions
SADD {user:1}:sessions "session:abc123"
# enables multi-key operations on the user's session data

# rotate session ID on privilege change (security)
RENAME session:old session:new
EXPIRE session:new 1800
19

Scripting con Lua

Conceptos básicos de EVAL

EVAL ejecuta scripts Lua atómicamente — mientras un script corre, no se ejecuta ningún otro comando, lo que lo hace ideal para operaciones atómicas de varios pasos. KEYS y ARGV pasan datos desde el llamador; nunca construyas claves por concatenación de strings dentro del script (viola las reglas del clúster). redis.call lanza errores (interrumpe), redis.pcall los devuelve. Los scripts se cachean por su hash SHA1, así que las llamadas repetidas usan EVALSHA por eficiencia.

redis
# run a Lua script inline
EVAL "return redis.call('SET', KEYS[1], ARGV[1])" 1 mykey "hello"
# 1 = number of keys
# mykey = KEYS[1]
# "hello" = ARGV[1]

# return types: string/integer/boolean/table (nil/true/false)
EVAL "return 42" 0
EVAL "return {1, 2, 3}" 0
EVAL "return redis.call('GET', KEYS[1])" 1 mykey

# 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 caché de scripts

EVALSHA ejecuta un script previamente cargado por su hash SHA1, evitando reenviar el cuerpo del script en cada llamada — un gran ahorro de ancho de banda para apps que ejecutan el mismo script repetidamente. En fallo de caché (tras SCRIPT FLUSH o un reinicio), Redis devuelve NOSCRIPT; los clientes lo capturan y recurren a EVAL + SCRIPT LOAD. Usa siempre librerías (redis-py, ioredis) que gestionen esto de forma transparente.

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

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

# check if a script is cached
SCRIPT EXISTS "fa00..." "abcd..."
# returns: 1) 1  2) 0

# flush the script cache
SCRIPT FLUSH

# list all running scripts (NOSCRIPT errors = cache miss -> reload)
SCRIPT DEBUG SYNC   # blocking debug mode
SCRIPT DEBUG NO     # disable

Operaciones atómicas

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

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

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

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

Redis Functions (7.0+)

Redis Functions (7.0+) son el reemplazo moderno de los scripts EVAL ad-hoc: se registran, tienen nombre y se versionan como los procedimientos almacenados de una base de datos. Una librería agrupa varias funciones; FCALL las invoca. Las funciones se persisten en RDB/AOF (sobreviven a reinicios), a diferencia de la caché efímera de EVAL. Hacen el scripting más mantenible para lógica no trivial, y son más fáciles de auditar y versionar.

redis
# register a library of functions
FUNCTION LOAD "#!lua name=mylib
redis.register_function('myset', function(keys, args)
  return redis.call('SET', keys[1], args[1])
end)

redis.register_function('double', function(keys, args)
  local v = tonumber(redis.call('GET', keys[1]))
  return redis.call('SET', keys[1], v * 2)
end)
"

# call a function
FCALL myset 1 mykey "hello"
FCALL double 1 counter

# list libraries
FUNCTION LIST
FUNCTION LIST WITHCODE

# delete a library
FUNCTION DELETE mylib

# dump and restore (for backup / migration)
FUNCTION DUMP
FUNCTION RESTORE <payload>

Depuración de scripts

Usa redis.log() para emitir mensajes al log de Redis al depurar sin afectar a los valores devueltos. redis-cli --ldb es un depurador interactivo de Lua: fija breakpoints, avanza paso a paso e inspecciona variables locales. SCRIPT DEBUG SYNC hace que el servidor se bloquee en el script para que el depurador pueda avanzar paso a paso. Prueba siempre los scripts en staging — un bucle desbocado puede bloquear el servidor Redis entero. Mantén los scripts deterministas (sin random/time) para la corrección de la replicación.

redis
# LOG writes to the Redis log (visible in redis-cli)
EVAL "redis.log(redis.LOG_NOTICE, 'hello from lua'); return 1" 0
# levels: LOG_DEBUG, LOG_VERBOSE, LOG_NOTICE, LOG_WARNING

# return the error object on pcall failure
EVAL "local ok, err = pcall(function()
  error('something broke')
end)
return {ok=tostring(ok), err=tostring(err)}" 0

# debugger (Redis 5.0+)
SCRIPT DEBUG SYNC   # synchronous, blocking
TDEBUG              # step / continue / print
# use redis-cli --ldb to launch debugger:
#   redis-cli --ldb --eval myscript.lua key1 key2 , arg1 arg2

# print variables in the debugger
print myvar
step
continue
20

Monitorización y resolución de problemas

INFO y LATENCY

INFO es el comando de monitorización más importante — informa de memoria, clientes, replicación y throughput de una sola vez. Vigila mem_fragmentation_ratio (ideal ~1.0–1.5); >1.5 desperdicia memoria, <1 significa que Redis está haciendo swapping (catastrófico para la latencia). LATENCY DOCTOR analiza los eventos lentos recientes y sugiere correcciones. Monitoriza keyspace_misses frente a keyspace_hits para seguir tu ratio de acierto de caché.

redis
# INFO: server, clients, memory, stats, replication, cpu
INFO                # everything
INFO memory         # memory section only
INFO replication    # replica lag, master link
INFO stats          # ops/sec, keyspace hits/misses

# key metrics to watch:
#   used_memory_rss        # RSS from OS (real footprint)
#   mem_fragmentation_ratio # >1.5 = fragmentation, <1 = swapping (bad!)
#   connected_clients       # client connections
#   instantaneous_ops_per_sec
#   keyspace_misses         # cache hit ratio = hits / (hits + misses)

# LATENCY: samples slow events
LATENCY HISTORY event-name
LATENCY DOCTOR      # human-readable diagnosis
LATENCY RESET

# LATENCY GRAPH event-name (ASCII art)

SLOWLOG y CLIENT LIST

SLOWLOG captura los comandos más lentos que el umbral configurado (10ms por defecto) — inestimable para encontrar las consultas que causan picos de latencia. Las operaciones de KEYSPACE como KEYS * y SMEMBERS sobre sets enormes son culpables habituales. CLIENT LIST muestra cada conexión con su tiempo de inactividad y comando actual; usa CLIENT SETNAME para etiquetar las conexiones de tu app y así identificar de qué pool proviene un cliente atascado.

redis
# SLOWLOG: record slow commands (over slowlog-log-slower-than, default 10ms)
CONFIG SET slowlog-log-slower-than 10000   # 10ms in microseconds
CONFIG SET slowlog-max-len 128             # keep last 128 entries

SLOWLOG GET          # last 10 slow commands
SLOWLOG GET 5        # last 5
SLOWLOG RESET        # clear

# each entry: id, timestamp, duration (us), command args, client, addr

# CLIENT LIST: see all connected clients
CLIENT LIST
# fields: id, addr, fd, name, age, idle, flags, db, cmd, ...

# kill a stuck client
CLIENT KILL ADDR 10.0.0.1:12345
CLIENT KILL ID 42

# name your connections for easier debugging
CLIENT SETNAME my-app-worker

MEMORY y OBJECT

MEMORY USAGE informa de los bytes exactos de una clave (con SAMPLES 0 para exactitud total en colecciones grandes). OBJECT ENCODING revela el formato interno de Redis — las estructuras pequeñas usan codificaciones compactas (listpack, ziplist) eficientes en CPU y memoria, que ascienden automáticamente a tablas hash/skiplists al crecer. Conocer la codificación ayuda a explicar por qué una clave es más grande o lenta de lo esperado.

redis
# MEMORY USAGE: bytes used by a single key
MEMORY USAGE key
MEMORY USAGE bigset SAMPLES 0   # scan all elements (accurate)

# MEMORY STATS: detailed allocator stats
MEMORY STATS

# MEMORY DOCTOR: diagnosis
MEMORY DOCTOR

# OBJECT ENCODING: see internal representation
OBJECT ENCODING mylist      # quicklist / ziplist / listpack / hashtable
OBJECT REFCOUNT mykey
OBJECT IDLETIME mykey       # seconds since last access
OBJECT FREQ mykey           # LFU access frequency (only with maxmemory-policy LFU)

# why is my key so big? use DEBUG OBJECT (careful, can be slow)
DEBUG OBJECT mykey

Bigkeys y escaneo del keyspace

Nunca uses KEYS en producción — bloquea el servidor. SCAN es la alternativa basada en cursor y sin bloqueo; itera hasta que el cursor vuelva a 0. --bigkeys y --memkeys son helpers de la CLI construidos sobre SCAN que muestran las claves más grandes sin bloquear. Las claves grandes (especialmente colecciones con millones de elementos) causan picos de latencia durante la expiración/eviction — encuéntralas y divídelas (p. ej., shardiza un sorted set enorme por tiempo).

redis
# find big keys safely (production-safe, samples)
redis-cli --bigkeys
# scans keyspace, reports largest of each type

# more accurate: --memkeys (memory usage per key)
redis-cli --memkeys
redis-cli --hotkeys      # with LFU policy, finds frequently-accessed keys

# SCAN: iterate keys without blocking (never use KEYS *)
SCAN 0 MATCH user:* COUNT 100
# returns: next-cursor, [key1, key2, ...]
SCAN <next-cursor> ...
# cursor 0 = done

# scan a hash field-by-field
HSCAN myhash 0 COUNT 100
SSCAN myset 0 MATCH prefix*
ZSCAN myzset 0

# inspect a key's TTL (left to live)
TTL mykey           # seconds (-1 = no expire, -2 = no key)
PTTL mykey          # milliseconds

Salud del clúster y failover

CLUSTER NODES y CLUSTER INFO son las comprobaciones principales de salud del clúster — busca cluster_state:ok y que cada slot esté asignado (16384 en total). CLUSTER FAILOVER en una réplica dispara un cambio de maestro controlado; FORCE se salta la sincronización inicial (más rápido, pero con leve riesgo de pérdida de datos) y TAKEOVER se salta el consenso del clúster (solo en emergencias). Ejecuta siempre --cluster check tras reshardings o incidentes para detectar slots huérfanos o estados de split-brain.

redis
# cluster node status
CLUSTER NODES
# fields: id, addr, flags (master/slave/fail?), slots, ping/pong

# cluster-wide health
CLUSTER INFO
# cluster_state:ok / cluster_slots_assigned / cluster_slots_ok
# cluster_known_nodes

# slot ownership (which node owns a key)
CLUSTER KEYSLOT mykey    # hash slot number
CLUSTER COUNTKEYSINSLOT 1234

# reshard slots (use redis-cli --cluster reshard)
redis-cli --cluster reshard 127.0.0.1:7000 \
  --cluster-from <node-id> --cluster-to <node-id> \
  --cluster-slots 1000 --cluster-yes

# manual failover (on a replica)
CLUSTER FAILOVER          # wait for sync
CLUSTER FAILOVER FORCE    # skip sync (faster, slight data loss risk)
CLUSTER FAILOVER TAKEOVER # no consensus (emergency only)

# verify cluster after changes
redis-cli --cluster check 127.0.0.1:7000
redis-cli --cluster fix 127.0.0.1:7000    # auto-repair minor issues

Was this helpful?