Casos de uso de Redis: caché, colas y limitación

Has construido una aplicación web que funciona, pero a medida que crece el tráfico, notas cargas de página lentas, cuellos de botella en la base de datos y caídas ocasionales. Estos son problemas comunes de escalabilidad. Redis, un almacén de datos en memoria, puede resolver muchos de estos problemas de forma elegante. En este artículo, exploraremos tres casos de uso prácticos de Redis: caché, colas y limitación de tasa. Aprenderás a implementar cada uno con ejemplos de código y mejores prácticas.

¿Por qué Redis?

Redis es un almacén de clave-valor en memoria de código abierto conocido por su velocidad y versatilidad. Admite estructuras de datos como cadenas, listas, conjuntos, hashes y conjuntos ordenados, lo que lo hace adecuado para una amplia gama de tareas. Debido a que mantiene los datos en memoria, las lecturas y escrituras son extremadamente rápidas, a menudo por debajo del milisegundo. Aunque no es un reemplazo de una base de datos principal, destaca como una herramienta complementaria para el rendimiento y la coordinación.

1. Caché con Redis

La caché es el caso de uso más común de Redis. Al almacenar datos de acceso frecuente en Redis, reduces la carga en tu base de datos principal y aceleras las respuestas.

Cómo implementar la caché

1. Consulta Redis primero: Cuando llega una solicitud, busca los datos en Redis usando una clave única.
2. En caso de fallo de caché: Si los datos no están en Redis, obtenlos de tu base de datos.
3. Almacena en Redis: Guarda el resultado en Redis con un tiempo de expiración (TTL) para evitar datos obsoletos.
4. Devuelve los datos: Envía los datos al cliente.

Aquí tienes un ejemplo simple en Python usando redis-py:

import redis
import json

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

def get_user(user_id):
    cache_key = f"user:{user_id}"
    cached = r.get(cache_key)
    if cached:
        return json.loads(cached)
    # Simular obtención de BD
    user = fetch_user_from_db(user_id)
    r.setex(cache_key, 3600, json.dumps(user))  # cachear por 1 hora
    return user

Mejores prácticas:

• Usa nombres de clave significativos con dos puntos, por ejemplo, user:123.
• Establece un TTL para evitar datos obsoletos y consumo excesivo de memoria.
• Considera estrategias de invalidación de caché: write-through, write-behind o expiración basada en tiempo.
• Para objetos complejos, serializa con JSON o MessagePack.

2. Colas con Redis

Las listas y streams de Redis son perfectos para construir colas de mensajes simples. Te permiten desacoplar tareas que consumen tiempo (como enviar correos electrónicos o procesar imágenes) del flujo principal de solicitudes, mejorando la capacidad de respuesta.

Usar listas como colas

Las listas de Redis admiten operaciones atómicas de push y pop. Usa LPUSH para agregar trabajos a la izquierda y BRPOP para bloquear y extraer desde la derecha, creando una cola FIFO.

# Productor: agregar un trabajo
r.lpush('job_queue', json.dumps({'task': 'send_email', 'to': 'user@example.com'}))

# Consumidor: procesar trabajos
while True:
    _, job_data = r.brpop('job_queue', timeout=30)
    job = json.loads(job_data)
    process_job(job)

Consideraciones:

• Confiabilidad: Las listas no son persistentes por defecto; habilita la persistencia AOF o RDB si es necesario.
• Entrega al menos una vez: Usa BRPOPLPUSH para mover trabajos a una lista de procesamiento y luego eliminarlos al completarse.
• Streams: Para casos de uso más avanzados (grupos de consumidores, confirmaciones), considera Redis Streams.

3. Limitación de tasa con Redis

La limitación de tasa protege tu API del abuso y garantiza un uso justo. Las operaciones atómicas y la expiración de Redis lo hacen ideal para implementar limitadores de tasa.

Limitación de tasa de ventana fija

En una ventana fija, permites N solicitudes por ventana de tiempo (por ejemplo, 100 solicitudes por hora). Usa INCR y EXPIRE para rastrear los conteos.

def is_rate_limited(user_id, limit=100, window=3600):
    key = f"rate:{user_id}"
    current = r.incr(key)
    if current == 1:
        r.expire(key, window)
    return current > limit

La ventana deslizante con conjuntos ordenados proporciona una limitación más fluida. Almacena las marcas de tiempo de las solicitudes en un conjunto ordenado y elimina las entradas antiguas.

def is_rate_limited_sliding(user_id, limit=100, window=3600):
    key = f"rate:{user_id}"
    now = time.time()
    pipeline = r.pipeline()
    pipeline.zremrangebyscore(key, 0, now - window)
    pipeline.zadd(key, {now: now})
    pipeline.zcard(key)
    pipeline.expire(key, window)
    _, _, count, _ = pipeline.execute()
    return count > limit

Mejores prácticas:

• Usa una clave única por usuario o IP.
• Combínalo con middleware para una integración limpia.
• Considera usar módulos de Redis como redis-cell para algoritmos avanzados.

Comparación de casos de uso

Preguntas frecuentes

¿Redis es persistente?

Redis ofrece persistencia a través de instantáneas RDB y registros AOF, pero es principalmente un almacén en memoria. Para datos críticos, siempre ten una copia de seguridad o usa una base de datos principal.

¿Puedo usar Redis para almacenar sesiones?

Sí, Redis se usa comúnmente para el almacenamiento de sesiones debido a su velocidad y expiración automática. Te permite compartir sesiones entre múltiples servidores.

¿Qué sucede si Redis se cae?

Si Redis no está disponible, tu aplicación debe recurrir de forma elegante a la base de datos o devolver datos en caché desde una caché local. Implementa interruptores de circuito para evitar fallos en cascada.

¿Listo para optimizar tu aplicación web? Comienza integrando Redis para caché, colas o limitación de tasa. Para tareas rápidas como formatear JSON o analizar registros, echa un vistazo a nuestro JSON Formatter y Nginx Log Analyzer.