Conectar a Redis

Visión General

Redis es un almacén de estructuras de datos en memoria usado para caching, gestión de sesiones, análisis en tiempo real y brokers de mensajes. Conectarse a Redis y usar sus tipos de datos principales de forma eficiente es una habilidad backend fundamental. Lo siguiente cubre operaciones básicas en Python, JavaScript y Java.

Cuándo Usar

• For alternatives, see Connect to MySQL.

Usa este recurso cuando:

• Implementas capas de cache para reducir la carga de la base de datos
• Construyes almacenes de sesiones para aplicaciones web stateless
• Creas leaderboards en tiempo real, rate limiters o colas de mensajes

Solución

Python

import redis

r = redis.Redis(
    host='localhost',
    port=6379,
    db=0,
    decode_responses=True
)

# Strings
r.set('user:1:name', 'Alice', ex=3600)
name = r.get('user:1:name')

# Lists
r.lpush('queue:tasks', 'task_1')
task = r.brpop('queue:tasks', timeout=5)

# Hashes
r.hset('user:1', mapping={'email': 'alice@example.com', 'role': 'admin'})
user = r.hgetall('user:1')

JavaScript

const Redis = require('ioredis');

const redis = new Redis({
    host: 'localhost',
    port: 6379,
    db: 0
});

// Strings
await redis.set('user:1:name', 'Alice', 'EX', 3600);
const name = await redis.get('user:1:name');

// Lists
await redis.lpush('queue:tasks', 'task_1');
const task = await redis.brpop('queue:tasks', 5);

// Hashes
await redis.hset('user:1', 'email', 'alice@example.com', 'role', 'admin');
const user = await redis.hgetall('user:1');

Java

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

public class RedisExample {
    private final JedisPool pool = new JedisPool("localhost", 6379);

    public void stringOps() {
        try (Jedis jedis = pool.getResource()) {
            jedis.setex("user:1:name", 3600, "Alice");
            String name = jedis.get("user:1:name");
        }
    }

    public void listOps() {
        try (Jedis jedis = pool.getResource()) {
            jedis.lpush("queue:tasks", "task_1");
            var task = jedis.brpop(5, "queue:tasks");
        }
    }

    public void hashOps() {
        try (Jedis jedis = pool.getResource()) {
            jedis.hset("user:1", "email", "alice@example.com");
            jedis.hset("user:1", "role", "admin");
            Map<String, String> user = jedis.hgetAll("user:1");
        }
    }
}

Explicación

Redis almacena datos en memoria, haciendo lecturas y escrituras extremadamente rápidas (sub-milisegundo). Los Strings son el tipo más simple, frecuentemente usados para cachear objetos serializados. Las Lists implementan colas (LPUSH + BRPOP para consumo bloqueante). Los Hashes almacenan objetos con múltiples campos de forma compacta. Los tres ejemplos usan una gestión de conexiones sólida: Python redis.Redis maneja reconexiones, JavaScript ioredis soporta clustering y pub/sub, y Java JedisPool reutiliza conexiones vía pooling.

Variantes

Tecnología	Enfoque	Notas
Python	redis-py	Cliente oficial, soporta async vía aredis
JavaScript	node-redis	Alternativa a ioredis, soporte nativo de Promise
Java	Lettuce	Cliente Redis reactivo y async para Spring

Lo que funciona

1. Usa pooling de conexiones en todos los lenguajes para evitar agotamiento de conexiones
2. Establece expiración explícita (EX, PX, EXAT) en claves de cache para prevenir crecimiento descontrolado de memoria
3. Usa decode_responses=True en Python para obtener strings en lugar de bytes
4. Prefiere BRPOP / BLPOP para consumo de colas para evitar busy-waiting
5. Usa pipelines de Redis (.pipeline() / .multi()) para batch de múltiples comandos y reducir RTT

Errores Comunes

1. Almacenar objetos grandes (>1 MB) en claves individuales, causando picos de latencia
2. No manejar fallos de conexión, causando errores en cascada cuando Redis no está disponible
3. Usar Redis como base de datos primaria en lugar de cache o almacén transitorio
4. Olvidar establecer TTLs, provocando agotamiento de memoria y kills por OOM
5. Usar el comando KEYS en producción, que bloquea toda la instancia de Redis

Buenas prácticas adicionales

6. Usa SCAN en lugar de KEYS en producción. KEYS bloquea toda la instancia de Redis. SCAN itera en lotes pequeños:

for key in r.scan_iter(match="user:*", count=100):
    print(key)

7. Configura maxmemory y maxmemory-policy. Configura Redis para evictar claves cuando la memoria está llena:

# redis.conf
maxmemory 2gb
maxmemory-policy allkeys-lru

8. Usa EXPIRE para claves de sesión. Siempre establece un TTL en datos de sesión para prevenir crecimiento descontrolado:

r.setex('session:abc123', 3600, json.dumps(session_data))

9. Monitorea estadísticas con INFO. Rastrea uso de memoria, clientes conectados y estadísticas de comandos:

info = r.info()
print(f"Memoria usada: {info['used_memory_human']}")
print(f"Clientes conectados: {info['connected_clients']}")
print(f"Hits keyspace: {info['keyspace_hits']}")
print(f"Misses keyspace: {info['keyspace_misses']}")

10. Usa SENTINEL para alta disponibilidad. Redis Sentinel provee failover automático cuando un master cae. Usa clientes conscientes de sentinel en todos los lenguajes.

Tips de Rendimiento

1. Usa PIPELINE para operaciones masivas. Reduce round-trips de red enviando múltiples comandos en un solo batch.

2. Usa MGET / MSET para operaciones de múltiples claves. Más rápido que llamadas GET/SET individuales:

values = r.mget('key1', 'key2', 'key3')
r.mset({'key1': 'val1', 'key2': 'val2'})

3. Usa HGETALL con moderación en hashes grandes. Si un hash tiene muchos campos, usa HSCAN para iterar:

for field, value in r.hscan_iter('large_hash', count=100):
    print(field, value)

4. Habilita lazyfree-lazy-eviction en Redis 4.0+. El borrado async previene picos de latencia durante la evicción de claves:

# redis.conf
lazyfree-lazy-eviction yes
lazyfree-lazy-expire yes
lazyfree-lazy-server-del yes

5. Usa OBJECT ENCODING para inspeccionar el almacenamiento. Redis usa encodings compactos para estructuras de datos pequeñas. Verifica si tus claves usan encodings eficientes:

encoding = r.object('encoding', 'mykey')
print(f"Encoding: {encoding}")  # ej. ziplist, hashtable, int