Casos de uso de Redis: Caché, Colas y Limitación de Tasa

Has construido una aplicación web que está ganando tracción, pero a medida que crece el tráfico, notas consultas lentas a la base de datos y timeouts ocasionales. Tu servidor lucha bajo la carga y los usuarios se quejan de la latencia. Necesitas un almacén de datos en memoria rápido para descargar tareas repetitivas y gestionar picos de tráfico. Redis es la solución preferida para muchos desafíos de backend, y en este artículo exploraremos tres casos de uso prácticos: caché, colas y limitación de tasa.

¿Por qué Redis?

Redis es un almacén de clave-valor en memoria de código abierto, conocido por su velocidad y versatilidad. Soporta estructuras de datos como cadenas, hashes, listas, conjuntos y conjuntos ordenados, lo que lo hace adecuado para una amplia gama de tareas. A diferencia de las bases de datos tradicionales, Redis mantiene los datos en RAM, ofreciendo latencia inferior al milisegundo. También ofrece opciones de persistencia, replicación y clustering para alta disponibilidad.

1. Caché con Redis

El 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 los tiempos de respuesta. Por ejemplo, si tu aplicación muestra una lista de productos populares, puedes cachear el resultado de la consulta durante unos minutos.

Cómo implementar el caché

1. Verifica el caché: Antes de consultar la base de datos, comprueba si los datos existen en Redis.
2. Si se encuentra (acierto de caché): Devuelve los datos cacheados.
3. Si no se encuentra (fallo de caché): Consulta la base de datos, almacena el resultado en Redis con un tiempo de expiración (TTL) y devuelve los datos.

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

import redis
import json

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

def get_products():
    cache_key = 'products:popular'
    cached = r.get(cache_key)
    if cached:
        return json.loads(cached)
    # Simular consulta a base de datos
    products = [{'id': 1, 'name': 'Product A'}, {'id': 2, 'name': 'Product B'}]
    r.setex(cache_key, 300, json.dumps(products))  # Cachear durante 5 minutos
    return products

Mejores prácticas: Usa claves de caché significativas, establece TTLs apropiados y considera estrategias de invalidación de caché. Para datos que cambian con frecuencia, usa TTLs cortos o implementa caché de escritura directa.

2. Colas con Redis

Las listas y streams de Redis son excelentes para construir colas de mensajes simples. Permiten desacoplar tareas que consumen tiempo (como enviar correos electrónicos o procesar imágenes) del ciclo de solicitud-respuesta, mejorando la experiencia del usuario y la escalabilidad.

Usar listas como cola

Puedes usar LPUSH para agregar trabajos a una lista y BRPOP para extraer trabajos atómicamente desde el otro extremo. Esto crea una cola FIFO.

Productor:

r.lpush('email_queue', json.dumps({'to': 'user@example.com', 'subject': 'Welcome'}))

Consumidor (en un proceso worker):

while True:
    _, job = r.brpop('email_queue', timeout=30)
    if job:
        process_email(json.loads(job))

Consideraciones: Las listas de Redis son simples pero carecen de características avanzadas como confirmaciones. Para necesidades más robustas, considera Redis Streams, que soportan grupos de consumidores y confirmación de mensajes.

3. Limitación de tasa con Redis

La limitación de tasa protege tu API del abuso y asegura un uso justo. Las operaciones atómicas de Redis lo hacen ideal para implementar limitadores de tasa. Un algoritmo común es el contador de ventana deslizante, pero un enfoque de ventana fija más simple también funciona bien.

Limitador de tasa de ventana fija

Incrementa un contador para cada usuario y establece una expiración. Si el contador excede el límite, deniega la solicitud.

def is_allowed(user_id, limit=100, window=60):
    key = f'rate_limit:{user_id}'
    current = r.incr(key)
    if current == 1:
        r.expire(key, window)
    return current