Módulo 1: Redis Fundamentals

Instalación de Redis y redis-cli

Siguiente →

Descripción

Esta cápsula es donde Redis pasa de concepto abstracto a herramienta concreta corriendo en tu máquina. En 30 segundos vas a tener Redis funcionando con Docker, conectarte con redis-cli, y ejecutar tus primeros comandos. Es deliberadamente práctica: cada concepto se experimenta en el CLI antes de avanzar.

Hay tres formas de instalar Redis: Docker (recomendado, funciona idéntico en cualquier OS), Homebrew (macOS) y apt (Linux). Cubriremos las tres, pero el resto de la guía asume Docker porque elimina toda variabilidad de sistema operativo. Si te trabas 20 minutos con problemas de instalación nativa, Docker resuelve todo en 10 segundos.

Después de instalar, dedicaremos la mayor parte de la cápsula a redis-cli — la herramienta de interacción y debugging más importante de Redis. No es solo una shell para ejecutar comandos: es el sandbox donde aprenderás cada data type del módulo, donde debuggearás problemas en producción, y donde explorarás bases de datos Redis ajenas. Dominarlo ahora paga dividendos en cada cápsula siguiente.

Instalación con Docker (recomendado)

Levantar Redis en un contenedor

Si tienes Docker instalado y corriendo (verifica con docker ps — debe responder sin error), un solo comando levanta Redis:

docker run -d --name redis-dev -p 6379:6379 redis:7

Desglose del comando:

  • docker run — crea y arranca un contenedor
  • -d — modo detached (corre en background, no bloquea tu terminal)
  • --name redis-dev — le pone nombre redis-dev al contenedor (más fácil que el ID hash)
  • -p 6379:6379 — mapea el puerto 6379 del contenedor al 6379 de tu máquina (Redis usa 6379 por default)
  • redis:7 — la imagen oficial de Redis, versión 7 (la última estable)

Output esperado:

Unable to find image 'redis:7' locally
7: Pulling from library/redis
...
Status: Downloaded newer image for redis:7
a1b2c3d4e5f6...

La primera vez tarda 10-30 segundos (descarga la imagen). Las siguientes veces es instantáneo (la imagen ya está en cache).

Verificar que Redis responde

docker ps

Output esperado:

CONTAINER ID   IMAGE      COMMAND                  STATUS         PORTS                    NAMES
a1b2c3d4e5f6   redis:7    "docker-entrypoint.s…"   Up 5 seconds   0.0.0.0:6379->6379/tcp   redis-dev

Si ves redis-dev en estado Up, Redis está corriendo. El puerto 6379 está accesible desde tu máquina.

Comandos útiles del contenedor

# Detener Redis (los datos se pierden si no configuraste persistencia)
docker stop redis-dev

# Reiniciar Redis
docker start redis-dev

# Ver logs (útil para debugging)
docker logs redis-dev

# Eliminar el contenedor por completo (libera el nombre redis-dev)
docker rm redis-dev

# Ver uso de recursos
docker stats redis-dev

Persistencia básica (opcional para este módulo)

Por default, Redis en Docker pierde los datos cuando paras el contenedor. Para este módulo no importa — vas a estar experimentando, no guardando datos críticos. Si quieres persistencia ahora:

docker run -d --name redis-dev \
  -p 6379:6379 \
  -v redis-data:/data \
  redis:7 redis-server --appendonly yes

-v redis-data:/data crea un volumen Docker que persiste los datos. --appendonly yes activa AOF (Append-Only File), una estrategia de persistencia. Suficiente para desarrollo.

Instalación nativa (alternativa)

Si prefieres no usar Docker, aquí están las alternativas. Funcionan igual al final, pero requieren más cuidado con versiones y configuración.

macOS con Homebrew

# Instalar
brew install redis

# Arrancar como servicio (corre en background)
brew services start redis

# O arrancar manualmente
redis-server

# Detener servicio
brew services stop redis

Ubuntu / Debian

# Instalar
sudo apt update
sudo apt install redis-server

# Arrancar como servicio
sudo systemctl start redis-server
sudo systemctl enable redis-server  # Auto-start al boot

# Detener
sudo systemctl stop redis-server

Windows

Redis nativo no soporta Windows oficialmente. Opciones reales:

  1. WSL2 (Windows Subsystem for Linux): Instala Ubuntu en WSL2, luego sigue las instrucciones de Ubuntu arriba
  2. Docker Desktop: La forma más limpia, idéntica a macOS/Linux
  3. Memurai (https://www.memurai.com/): port no oficial de Redis para Windows nativo

Recomendación: Usa Docker Desktop. Te ahorra problemas y replica el comportamiento de producción (donde Redis casi siempre corre en Linux).

Conectarse con redis-cli

redis-cli es la herramienta cliente que viene con Redis. Te conecta al servidor para ejecutar comandos interactivamente.

Si instalaste Redis con Docker

redis-cli está dentro del contenedor. Tres formas de usarlo:

Opción A: Ejecutar redis-cli dentro del contenedor

docker exec -it redis-dev redis-cli

Esto te abre una shell de redis-cli conectada al Redis del contenedor.

Opción B: Instalar redis-cli en tu máquina (más cómodo a largo plazo)

# macOS
brew install redis  # Esto instala el cliente sin arrancar el server

# Ubuntu/Debian
sudo apt install redis-tools

Luego conectas al Redis del contenedor desde tu máquina:

redis-cli
# o explícitamente:
redis-cli -h localhost -p 6379

Opción C: Usar el cliente del contenedor sin entrar en shell

docker exec -it redis-dev redis-cli ping
# PONG

Útil para comandos rápidos sin entrar en sesión interactiva.

Si instalaste Redis nativo

redis-cli ya está disponible en tu PATH:

redis-cli

El primer comando: PING

Una vez dentro de redis-cli, el indicador cambia a 127.0.0.1:6379>. Escribe:

127.0.0.1:6379> PING
PONG

Si ves PONG, Redis está funcionando y conectado. Es la forma estándar de verificar que un servidor Redis responde — lo usarás en health checks de tu API en módulos posteriores.

Comandos fundamentales

Vamos a recorrer los comandos esenciales que necesitas para manipular cualquier dato en Redis. La sintaxis general es:

COMANDO key [argumentos]

Las claves (keys) son strings. Pueden ser cualquier texto: user:1, cache:product:42, rate_limit:ip:192.168.1.1. Por convención, se usan dos puntos : como separador para emular jerarquía (Redis no tiene namespaces reales — user:1 es solo una string que parece jerárquica).

SET y GET — el "Hello World" de Redis

127.0.0.1:6379> SET greeting "Hola Redis"
OK

127.0.0.1:6379> GET greeting
"Hola Redis"

SET guarda un valor. GET lo lee. Lo más simple posible.

Sobreescribir un valor

127.0.0.1:6379> SET greeting "Hola Mundo"
OK

127.0.0.1:6379> GET greeting
"Hola Mundo"

SET siempre sobreescribe el valor anterior. No hay error ni warning — el valor previo se reemplaza.

Si la key no existe

127.0.0.1:6379> GET nonexistent
(nil)

(nil) significa "no existe". No es un error — es la forma de Redis de decir "no tengo nada para esa key."

DEL — eliminar keys

127.0.0.1:6379> SET temp "este valor se va"
OK

127.0.0.1:6379> DEL temp
(integer) 1

127.0.0.1:6379> GET temp
(nil)

DEL retorna (integer) 1 si eliminó la key, 0 si la key no existía. Puedes eliminar múltiples keys a la vez:

127.0.0.1:6379> SET key1 "a"
OK
127.0.0.1:6379> SET key2 "b"
OK
127.0.0.1:6379> DEL key1 key2 key3
(integer) 2

Eliminó key1 y key2 (existían), pero no key3 (no existía). Por eso retornó 2.

EXISTS — verificar existencia sin leer

127.0.0.1:6379> SET user:42 "Alex"
OK

127.0.0.1:6379> EXISTS user:42
(integer) 1

127.0.0.1:6379> EXISTS user:99
(integer) 0

1 = existe, 0 = no existe. Más eficiente que GET cuando solo quieres saber si la key existe (no necesitas el valor).

KEYS — listar keys (con cuidado)

127.0.0.1:6379> SET user:1 "Alex"
OK
127.0.0.1:6379> SET user:2 "Maria"
OK
127.0.0.1:6379> SET product:1 "Laptop"
OK

127.0.0.1:6379> KEYS *
1) "user:1"
2) "user:2"
3) "product:1"

127.0.0.1:6379> KEYS user:*
1) "user:1"
2) "user:2"

KEYS * lista TODAS las keys. KEYS user:* lista las que empiezan con user:.

⚠️ CRÍTICO: KEYS bloquea Redis mientras escanea la base de datos. En producción con millones de keys, puede congelar Redis durante segundos. Nunca uses KEYS en producción — solo en desarrollo. La alternativa profesional es SCAN (no la cubrimos aquí, pero está en las docs).

TYPE — qué data type tiene una key

127.0.0.1:6379> SET name "Alex"
OK
127.0.0.1:6379> TYPE name
string

127.0.0.1:6379> HSET user:1 name "Alex" age 30
(integer) 2
127.0.0.1:6379> TYPE user:1
hash

Útil cuando exploras una base de datos Redis ajena y no sabes qué tipo es cada key.

Expiración: TTL y EXPIRE

Una de las features más útiles de Redis es que las keys pueden expirar automáticamente. Esto es la base de caching: pones un dato con TTL (Time To Live), y Redis lo borra solo cuando expira.

EXPIRE — agregar TTL a una key existente

127.0.0.1:6379> SET session:abc123 "user_id=42"
OK

127.0.0.1:6379> EXPIRE session:abc123 60
(integer) 1

EXPIRE key segundos — la key expira en 60 segundos. Retorna 1 si la operación funcionó, 0 si la key no existe.

TTL — cuánto tiempo le queda a una key

127.0.0.1:6379> TTL session:abc123
(integer) 58

127.0.0.1:6379> TTL session:abc123
(integer) 45

Retorna segundos restantes. Si la key no tiene TTL: -1. Si la key no existe: -2.

127.0.0.1:6379> SET permanent "no expira"
OK
127.0.0.1:6379> TTL permanent
(integer) -1

127.0.0.1:6379> TTL nonexistent
(integer) -2

SET con TTL en un solo comando

127.0.0.1:6379> SET cache:product:42 "Laptop" EX 300
OK

127.0.0.1:6379> TTL cache:product:42
(integer) 298

EX 300 agrega TTL de 300 segundos al SET. Es la forma idiomática de cachear con expiración. Más eficiente que SET + EXPIRE separados (una operación atómica vs dos).

PERSIST — quitar el TTL

127.0.0.1:6379> SET cache:item "value" EX 300
OK

127.0.0.1:6379> PERSIST cache:item
(integer) 1

127.0.0.1:6379> TTL cache:item
(integer) -1

La key vuelve a ser permanente (sin expiración).

Esperar a que expire

127.0.0.1:6379> SET temp "voy a desaparecer" EX 5
OK
127.0.0.1:6379> GET temp
"voy a desaparecer"

# Espera 5 segundos...

127.0.0.1:6379> GET temp
(nil)

Redis elimina la key automáticamente cuando expira.

Comandos de exploración profesional

redis-cli no es solo para SET/GET. Es la herramienta de debugging y administración de Redis. Estos comandos los usarás en producción todo el tiempo.

DBSIZE — cuántas keys hay

127.0.0.1:6379> DBSIZE
(integer) 4

Retorna el número total de keys en la base de datos actual. Ultra rápido (no escanea, lee un counter interno).

INFO — métricas del servidor

127.0.0.1:6379> INFO
# Server
redis_version:7.2.4
redis_git_sha1:00000000
process_id:1
...

# Clients
connected_clients:1
...

# Memory
used_memory:921616
used_memory_human:900.02K
...

# Stats
total_connections_received:5
total_commands_processed:25
keyspace_hits:8
keyspace_misses:2
...

INFO retorna un dump masivo de información del servidor. Las secciones más útiles:

  • Memory: used_memory_human te dice cuánta RAM usa Redis
  • Stats: keyspace_hits vs keyspace_misses te dice tu hit rate (la base de monitoring de cache)
  • Clients: connected_clients cuántos clientes están conectados

Puedes filtrar por sección:

127.0.0.1:6379> INFO memory
# Memory
used_memory:921616
used_memory_human:900.02K
used_memory_rss:8388608
used_memory_rss_human:8.00M
...

127.0.0.1:6379> INFO stats
# Stats
total_connections_received:5
total_commands_processed:25
...

MONITOR — ver todos los comandos en tiempo real

127.0.0.1:6379> MONITOR
OK
1714069200.123456 [0 127.0.0.1:54321] "SET" "key1" "value1"
1714069201.234567 [0 127.0.0.1:54321] "GET" "key1"
1714069202.345678 [0 127.0.0.1:54322] "INCR" "counter"

MONITOR te muestra TODOS los comandos que Redis ejecuta, en tiempo real. Incluye timestamp, IP del cliente, y el comando exacto.

⚠️ CRÍTICO: MONITOR tiene overhead alto. No lo uses en producción con tráfico real — puede degradar performance. En desarrollo es invaluable para debugging. Para salir, Ctrl+C.

CLIENT LIST — ver clientes conectados

127.0.0.1:6379> CLIENT LIST
id=3 addr=127.0.0.1:54321 name= age=120 idle=5 ...
id=5 addr=127.0.0.1:54322 name= age=60 idle=2 ...

Útil para detectar conexiones zombie o saber cuántos workers están conectados.

FLUSHDB y FLUSHALL — borrar todo

127.0.0.1:6379> DBSIZE
(integer) 4

127.0.0.1:6379> FLUSHDB
OK

127.0.0.1:6379> DBSIZE
(integer) 0

FLUSHDB borra todas las keys de la base de datos actual. FLUSHALL borra todas las keys de TODAS las bases de datos.

⚠️ CRÍTICO: En producción, esto es catastrófico. Algunos equipos deshabilitan estos comandos en producción precisamente por eso. En desarrollo, úsalos sin miedo cuando necesites empezar de cero.

SELECT — múltiples bases de datos

Redis tiene 16 bases de datos numeradas (0-15) por default. Cambias con SELECT:

127.0.0.1:6379> SET test "db 0"
OK

127.0.0.1:6379> SELECT 1
OK
127.0.0.1:6379[1]> GET test
(nil)

127.0.0.1:6379[1]> SET test "db 1"
OK

127.0.0.1:6379[1]> SELECT 0
OK
127.0.0.1:6379> GET test
"db 0"

Nota cómo el prompt cambia a 127.0.0.1:6379[1]> cuando estás en DB 1. Las bases de datos están aisladas — datos en DB 0 no son visibles desde DB 1.

⚠️ NOTA: El uso de múltiples DBs es discutido. Redis Cluster no las soporta. La práctica moderna es usar prefixes en las keys (app1:user:1, app2:user:1) en lugar de bases separadas. Para esta guía nos quedamos con DB 0 (default).

Troubleshooting

Problema 1: redis-cli: command not found

Causa: redis-cli no está instalado en tu máquina (estás usando Docker pero sin cliente local).

Solución:

Opción A — usar el cliente del contenedor:

docker exec -it redis-dev redis-cli

Opción B — instalar redis-cli localmente:

# macOS
brew install redis

# Ubuntu/Debian
sudo apt install redis-tools

Problema 2: Could not connect to Redis at 127.0.0.1:6379: Connection refused

Causa: Redis no está corriendo, o está corriendo en otro puerto.

Solución:

# Verificar si Redis está corriendo (Docker)
docker ps | grep redis

# Si no aparece, levántalo:
docker run -d --name redis-dev -p 6379:6379 redis:7

# Si dice "name redis-dev already in use":
docker start redis-dev   # Si solo está parado
docker rm redis-dev && docker run -d --name redis-dev -p 6379:6379 redis:7  # Si tienes que recrearlo

Si instalaste Redis nativo:

# macOS
brew services list | grep redis  # Ver estado
brew services start redis        # Arrancar

# Linux
sudo systemctl status redis-server
sudo systemctl start redis-server

Problema 3: Puerto 6379 ya está en uso

Causa: Tienes otro Redis corriendo (quizá uno nativo y otro en Docker).

Solución:

# Ver qué proceso usa el puerto 6379
lsof -i :6379          # macOS/Linux
netstat -ano | findstr :6379   # Windows

# Si es otro Redis nativo, detenlo:
brew services stop redis        # macOS
sudo systemctl stop redis-server # Linux

# O usa otro puerto en Docker:
docker run -d --name redis-dev -p 6380:6379 redis:7
# Y conéctate con: redis-cli -p 6380

Problema 4: (error) ERR wrong number of arguments

Causa: Sintaxis incorrecta en el comando.

Solución: Consulta la documentación del comando con HELP:

127.0.0.1:6379> HELP SET
SET key value [EX seconds|PX milliseconds|...]

O en la docs oficial: https://redis.io/commands/

Problema 5: redis-cli muestra caracteres raros con strings que contienen caracteres especiales

Causa: Encoding por default. El binario está OK, solo no se renderiza bien.

Solución: Iniciar redis-cli con flag de raw output:

redis-cli --no-raw  # Output formateado (default en interactive mode)
redis-cli           # Para scripts, output raw

O usa decode_responses=True cuando uses Python (próxima cápsula).

Ejercicios

Ejercicio 1: Setup completo (Fácil)

Levanta Redis con Docker, conéctate con redis-cli, verifica con PING, y haz SET hello "world" seguido de GET hello. El output final debe ser "world".

Ver solución 
# Levantar Redis
docker run -d --name redis-dev -p 6379:6379 redis:7

# Verificar
docker ps

# Conectar
redis-cli  # o: docker exec -it redis-dev redis-cli

# Dentro de redis-cli:
PING
# PONG

SET hello "world"
# OK

GET hello
# "world"

Explicación: Es el flujo mínimo viable: levantar el server, conectar el cliente, verificar respuesta, y operar. Si los 4 pasos funcionan, Redis está listo para todo lo demás.

Ejercicio 2: TTL en práctica (Fácil)

Crea una key notification:42 con valor "Mensaje temporal" y TTL de 10 segundos. Verifica el TTL con TTL. Lee el valor con GET. Espera 12 segundos. Vuelve a leer con GET — debe retornar (nil).

Ver solución 
127.0.0.1:6379> SET notification:42 "Mensaje temporal" EX 10
OK

127.0.0.1:6379> TTL notification:42
(integer) 10

127.0.0.1:6379> GET notification:42
"Mensaje temporal"

# (esperar 12 segundos)

127.0.0.1:6379> GET notification:42
(nil)

127.0.0.1:6379> TTL notification:42
(integer) -2

Explicación: TTL retorna -2 porque la key ya no existe (Redis la borró al expirar). Esto es la base del caching: pon un dato con TTL, y Redis lo limpia solo. No hay cron jobs ni código de cleanup necesario.

Ejercicio 3: Múltiples keys con prefijo (Fácil-Medio)

Crea 5 keys siguiendo el patrón product:1, product:2, ..., product:5 con valores "Producto N". Crea 3 keys más con patrón category:1, category:2, category:3. Usa KEYS con un patrón para listar solo los productos.

Ver solución 
127.0.0.1:6379> SET product:1 "Producto 1"
OK
127.0.0.1:6379> SET product:2 "Producto 2"
OK
127.0.0.1:6379> SET product:3 "Producto 3"
OK
127.0.0.1:6379> SET product:4 "Producto 4"
OK
127.0.0.1:6379> SET product:5 "Producto 5"
OK
127.0.0.1:6379> SET category:1 "Cat 1"
OK
127.0.0.1:6379> SET category:2 "Cat 2"
OK
127.0.0.1:6379> SET category:3 "Cat 3"
OK

127.0.0.1:6379> KEYS product:*
1) "product:1"
2) "product:2"
3) "product:3"
4) "product:4"
5) "product:5"

127.0.0.1:6379> KEYS *
1) "product:1"
... (8 keys total)

Explicación: El : es solo una convención visual — Redis trata product:1 como un string normal. Pero esa convención permite usar KEYS product:* para filtrar por prefijo. Recuerda: nunca uses KEYS en producción (bloquea Redis con muchas keys).

Ejercicio 4: Eliminar todas las categorías (Medio)

Con las keys del ejercicio 3 todavía en Redis, elimina todas las que empiecen con category: en un solo comando DEL.

Ver solución 
127.0.0.1:6379> DEL category:1 category:2 category:3
(integer) 3

127.0.0.1:6379> KEYS category:*
(empty array)

127.0.0.1:6379> KEYS product:*
1) "product:1"
2) "product:2"
3) "product:3"
4) "product:4"
5) "product:5"

Explicación: DEL acepta múltiples keys como argumentos. Retorna cuántas keys fueron eliminadas (3 = todas existían). Truco profesional: para eliminar muchas keys con patrón, usa una combinación de bash + redis-cli:

redis-cli KEYS "category:*" | xargs redis-cli DEL

(En producción, usa SCAN en vez de KEYS para no bloquear Redis.)

Ejercicio 5: Hit rate básico (Medio)

Usa INFO stats para ver keyspace_hits y keyspace_misses. Haz 10 GET a una key que existe y 10 a una key que NO existe. Vuelve a ver INFO stats. Calcula tu hit rate: hits / (hits + misses).

Ver solución 
127.0.0.1:6379> SET hot_key "exists"
OK

127.0.0.1:6379> INFO stats
# Stats
keyspace_hits:5     # ejemplo, puede variar
keyspace_misses:2

# Hacer 10 GETs a la key que existe
127.0.0.1:6379> GET hot_key
"exists"
# (repetir 10 veces, o usar redis-cli loop)

# Hacer 10 GETs a una key que NO existe
127.0.0.1:6379> GET cold_key
(nil)
# (repetir 10 veces)

127.0.0.1:6379> INFO stats
# Stats
keyspace_hits:15    # 5 inicial + 10 hits
keyspace_misses:12  # 2 inicial + 10 misses

Cálculo de hit rate:

Diferencia: 10 hits y 10 misses agregados.

Hit rate = hits / (hits + misses) = 10 / (10 + 10) = 0.5 = 50%

Explicación: Hit rate es la métrica fundamental de cache performance. 50% es bajo (solo la mitad de las requests se sirven desde cache). En producción, target típico es 80%+ para cache efectivo. Si tu hit rate es <50% consistentemente, el cache no está ayudando — vale la pena auditar tu estrategia (módulo 2 cubre esto).

Truco para el loop de GETs en bash:

for i in {1..10}; do redis-cli GET hot_key; done
for i in {1..10}; do redis-cli GET cold_key; done

Ejercicio 6: Debugging con MONITOR (Medio-Difícil)

Abre dos terminales con redis-cli. En la primera, ejecuta MONITOR. En la segunda, ejecuta varios comandos: SET test 1, INCR test, EXPIRE test 60, GET test, DEL test. Observa el output en la terminal de MONITOR.

Ver solución

Terminal 1 (MONITOR):

127.0.0.1:6379> MONITOR
OK
1714069300.123 [0 127.0.0.1:54321] "SET" "test" "1"
1714069302.456 [0 127.0.0.1:54321] "INCR" "test"
1714069304.789 [0 127.0.0.1:54321] "EXPIRE" "test" "60"
1714069306.012 [0 127.0.0.1:54321] "GET" "test"
1714069308.345 [0 127.0.0.1:54321] "DEL" "test"

Terminal 2 (operaciones):

127.0.0.1:6379> SET test 1
OK
127.0.0.1:6379> INCR test
(integer) 2
127.0.0.1:6379> EXPIRE test 60
(integer) 1
127.0.0.1:6379> GET test
"2"
127.0.0.1:6379> DEL test
(integer) 1

Explicación: MONITOR es la herramienta de debugging más poderosa de Redis para entender qué está pasando en tiempo real. En desarrollo, lo usas para ver qué comandos manda tu aplicación (¿está cacheando lo que crees? ¿hay queries duplicadas?). En producción, NO lo uses — agrega ~50% de overhead en throughput. Para producción, hay alternativas: redis-cli --latency para medir latencia, slow logs (SLOWLOG GET) para queries lentas.

Resumen

En esta cápsula aprendiste:

  • Instalar Redis con Docker en 30 segundos: docker run -d --name redis-dev -p 6379:6379 redis:7
  • Alternativas de instalación (Homebrew, apt) y por qué Docker es preferible
  • Conectar redis-cli dentro del contenedor o desde tu máquina con redis-cli -h localhost -p 6379
  • Comandos fundamentales: PING, SET, GET, DEL, EXISTS, KEYS, TYPE
  • Expiración: EXPIRE, TTL, PERSIST, SET ... EX seconds (sintaxis corta)
  • Comandos de exploración: DBSIZE, INFO, MONITOR, CLIENT LIST, SELECT, FLUSHDB
  • Convención de keys: prefijos con : (ej. user:1, cache:product:42) — visual, no funcional
  • Métricas básicas de cache: keyspace_hits vs keyspace_misses para calcular hit rate

Comandos críticos para no usar en producción: KEYS *, MONITOR, FLUSHDB, FLUSHALL. Útiles en desarrollo, peligrosos en producción.

Recursos adicionales

  1. Redis Commands Reference — Lista completa de comandos con sintaxis y ejemplos
  2. Redis CLI documentation — Docs oficiales de redis-cli con flags y modos avanzados
  3. Docker Hub: redis image — Documentación oficial de la imagen Docker, todas las versiones y configuraciones
  4. Redis Persistence — Profundidad sobre RDB vs AOF cuando quieras configurar persistencia seria
  5. Redis Latency Monitoring — Cómo usar redis-cli --latency y slow logs
  6. redis-cli Cheat Sheet — Referencia rápida imprimible

¿Qué sigue?

En la Cápsula 03 dejas SET/GET simple y entras a los dos data types más usados en backend: strings con operaciones avanzadas (counters atómicos con INCR, locks con SETNX, batch ops) y hashes (objetos estructurados con campos individuales actualizables). Aquí es donde Redis empieza a sentirse poderoso, no solo rápido.

Mantén Redis corriendo en tu Docker entre cápsulas. Si lo paraste:

docker start redis-dev

Adelante.

← AnteriorIntroducción al Módulo 1: Redis FundamentalsSiguiente →Strings y Hashes