Redis: No Solo para Caché - 10 Casos de Uso Prácticos para Desarrolladores

1. Caché de Consultas de Base de Datos

Contexto técnico: Las consultas complejas a bases de datos relacionales, especialmente aquellas con múltiples JOIN, pueden convertirse en un cuello de botella, degradando el throughput de la aplicación.

Solución con Redis: Implementar un patrón de caché de consultas almacenando el resultado serializado (por ejemplo, JSON), utilizando la consulta SQL o un hash de la misma como clave.

// Ejemplo usando node-redis
import { createClient } from 'redis';

const client = createClient();
await client.connect();

async function getProductsByCategory(categoryId) {
    const cacheKey = `query:products:category:${categoryId}`;

    // Intento de recuperación desde caché
    const cachedResult = await client.get(cacheKey);
    if (cachedResult) {
        console.log('Cache Hit - Retornando desde Redis');
        return JSON.parse(cachedResult);
    }

    // Cache Miss - Consulta a la base de datos primaria
    console.log('Cache Miss - Consultando BD');
    const dbResult = await db.query(
        'SELECT * FROM products WHERE category_id = ?',
        [categoryId]
    );

    // Almacenamiento en caché con expiración (TTL)
    await client.set(cacheKey, JSON.stringify(dbResult), {
        EX: 3600 // Expira en 1 hora
    });

    return dbResult;
}
            

Beneficios: Reduce drásticamente la latencia, descarga la base de datos primaria y permite absorber picos de tráfico sin reventar el motor relacional.

Buenas prácticas:

• Invalidar el caché cuando cambien los datos relevantes (ej. mediante eventos o colas).
• Evitar TTL demasiado largos en datos muy dinámicos.
• Generar claves con nombres consistentes y versionadas (ej. v1:query:products:category:123).

2. Almacén de Sesiones de Usuario (Session Store)

Contexto técnico: En arquitecturas con múltiples instancias de aplicación (por ejemplo, detrás de un balanceador de carga), el estado de sesión no puede vivir en memoria local.

Solución con Redis: Utilizar Redis como almacén centralizado y de alta velocidad para los datos de sesión, aprovechando su capacidad de establecer tiempos de expiración (TTL).

// Integración con express-session
import session from 'express-session';
import RedisStore from 'connect-redis';

const redisStore = new RedisStore({
    client: client,
});

app.use(session({
    store: redisStore,
    secret: process.env.SESSION_SECRET,
    resave: false,
    saveUninitialized: false,
    cookie: {
        secure: 'auto',
        maxAge: 1000 * 60 * 60 * 24 // 1 día
    }
}));

// Uso del almacén de sesiones con Hash
async function updateUserSession(userId, sessionData) {
    const sessionKey = `user:session:${userId}`;
    await client.hSet(sessionKey, {
        lastLogin: new Date().toISOString(),
        userAgent: sessionData.userAgent,
        ip: sessionData.ip
    });
    await client.expire(sessionKey, 86400); // Expira en 24h
}
            

Beneficios: Sesiones consistentes en arquitecturas distribuidas, alta disponibilidad y posibilidad de invalidad sesiones masivamente (por ejemplo, al cambiar políticas de seguridad).

3. Sistema de Mensajería Pub/Sub en Tiempo Real

Contexto técnico: Aplicaciones que requieren notificaciones instantáneas, chats o actualizaciones en tiempo real (por ejemplo, dashboards).

Solución con Redis: Aprovechar el modelo nativo de Publicador/Suscriptor (Pub/Sub), donde los publicadores envían mensajes a canales y los suscriptores los reciben.

// Suscriptor
const subscriber = client.duplicate();
await subscriber.connect();

await subscriber.subscribe('notifications:user:123', (message) => {
    console.log(`Notificación recibida: ${message}`);
});

// Publicador
const publisher = client.duplicate();
await publisher.connect();

await publisher.publish(
    'notifications:user:123',
    '¡Tienes un nuevo mensaje!'
);
            

Beneficios: Baja latencia y alta escalabilidad para comunicaciones en tiempo real entre servicios.

Nota: El Pub/Sub nativo no almacena mensajes. Si necesitas durabilidad o reintentos, combina Redis con colas persistentes o streams.

4. Rate Limiting y Protección de APIs

Contexto técnico: Es necesario proteger los endpoints de API contra abuso, ataques de fuerza bruta y garantizar la calidad de servicio.

Solución con Redis: Implementar un rate limiter utilizando comandos atómicos como INCR y EXPIRE, ideales para contadores distribuidos.

class RateLimiter {
    constructor(redisClient) {
        this.client = redisClient;
    }

    async isAllowed(userId, endpoint, maxRequests, windowSeconds) {
        const key = `ratelimit:${userId}:${endpoint}`;

        // Pipeline para atomicidad: INCR + EXPIRE
        const multi = this.client.multi();
        multi.incr(key);
        multi.expire(key, windowSeconds, 'NX'); // Solo establece expiración si no existe

        const results = await multi.exec();
        const requestCount = results[0];

        return requestCount <= maxRequests;
    }
}

// Uso
const limiter = new RateLimiter(client);
const allowed = await limiter.isAllowed('user123', '/api/login', 5, 300); // 5 intentos cada 5 min
if (!allowed) {
    throw new Error('Límite de tasa excedido');
}
            

Beneficios: Defensa eficaz contra ataques, control de recursos en arquitecturas distribuidas y cumplimiento de políticas de uso.

Variaciones avanzadas: ventanas deslizantes, bloqueo temporal de IPs y límites por combinación de usuario + endpoint + IP.

5. Almacenamiento de Carritos de Compra

Contexto técnico: En e-commerce, el carrito de compra es un estado temporal pero crítico, que requiere acceso rápido, consistencia y expiración automática.

Solución con Redis: Modelar el carrito como un Hash de Redis, donde cada campo representa un productId y su valor la cantidad.

async function addToCart(userId, productId, quantity) {
    const cartKey = `cart:${userId}`;
    await client.hSet(cartKey, productId, quantity);
    await client.expire(cartKey, 604800); // Expira en 1 semana
}

async function getCart(userId) {
    const cartKey = `cart:${userId}`;
    return await client.hGetAll(cartKey);
}
            

Beneficios: Rendimiento ultrarrápido, manejo automático de expiración de datos temporales y reducción de carga en la base de datos transaccional.

6. Contadores Atómicos y Estadísticas en Tiempo Real

Contexto técnico: Sistemas que requieren incrementar contadores de forma concurrente (vistas, likes, shares) sin condiciones de carrera.

Solución con Redis: Utilizar los comandos INCR, INCRBY y HINCRBY, que son atómicos por naturaleza.

async function trackVideoView(videoId) {
    const key = `video:stats:${videoId}`;

    // Incrementa múltiples contadores atómicamente en un Hash
    const multi = client.multi();
    multi.hIncrBy(key, 'totalViews', 1);
    multi.hIncrBy(key, 'viewsToday', 1);
    await multi.exec();
}

async function getVideoStats(videoId) {
    const key = `video:stats:${videoId}`;
    return await client.hGetAll(key);
}
            

Beneficios: Consistencia de datos en entornos de alta concurrencia y velocidad extrema para analíticas en tiempo real.

7. Leaderboards y Clasificaciones con Sorted Sets

Contexto técnico: Juegos o plataformas que necesitan mostrar rankings actualizados en tiempo real (puntuaciones, reputación, logros).

Solución con Redis: Los Sorted Sets (ZSET) son la estructura ideal: asocian una puntuación (score) a cada miembro y los mantienen ordenados automáticamente.

async function updatePlayerScore(playerId, score) {
    await client.zAdd('game:leaderboard', {
        value: playerId,
        score: score
    });
}

async function getTopPlayers(limit = 10) {
    return await client.zRangeWithScores(
        'game:leaderboard',
        0,
        limit - 1,
        { REV: true } // Orden descendente
    );
}
            

Beneficios: Consultas de ranking complejas en O(log(N)) y datos siempre ordenados sin necesidad de ordenar en la capa de aplicación.

8. Colas de Tareas Asíncronas

Contexto técnico: Descargar procesos pesados (envío de emails, procesamiento de imágenes, notificaciones) para no bloquear la respuesta al usuario.

Solución con Redis: Implementar una cola simple utilizando Listas y los comandos LPUSH/BRPOP.

// Producer - Añade tareas a la cola
async function addEmailTask(emailData) {
    await client.lPush('queue:emails', JSON.stringify(emailData));
}

// Consumer - Procesa tareas de la cola (usualmente en un worker process)
async function processEmailQueue() {
    while (true) {
        // Búsqueda bloqueante hasta que haya una tarea
        const task = await client.brPop('queue:emails', 0);
        const emailData = JSON.parse(task.element);

        // Procesar el email...
        await sendEmail(emailData);
    }
}
            

Beneficios: Desacoplamiento de servicios, reintentos controlados y mejora drástica de la capacidad de respuesta de la aplicación.

9. Almacenamiento de Resultados de Cálculos Intensivos

Contexto técnico: Resultados de funciones pesadas (procesamiento de datos, modelos de machine learning, agregaciones complejas) que son costosos de recalcular y se reutilizan.

Solución con Redis: Cachear el resultado usando una clave derivada de los parámetros de entrada.

import crypto from 'crypto';

async function getExpensiveCalculation(inputParams) {
    const inputHash = crypto.createHash('md5')
        .update(JSON.stringify(inputParams))
        .digest('hex');

    const cacheKey = `calc:${inputHash}`;

    const cachedResult = await client.get(cacheKey);
    if (cachedResult) return JSON.parse(cachedResult);

    // Simulación de cálculo intensivo
    const result = await intensiveCalculation(inputParams);

    await client.set(cacheKey, JSON.stringify(result), { EX: 3600 });
    return result;
}
            

Beneficios: Ahorro significativo de ciclos de CPU, reducción de costos y mejor experiencia de usuario.

10. Caché de Respuestas de APIs Externas

Contexto técnico: Las llamadas a APIs de terceros (pasarelas de pago, servicios de clima, autenticación) suelen tener latencia alta y límites de uso (rate limits).

Solución con Redis: Almacenar las respuestas, respetando los tiempos de actualización de los datos y los headers de caché que puedan proveer.

async function fetchWithCache(apiUrl) {
    const cacheKey = `api:${apiUrl}`;
    const cached = await client.get(cacheKey);

    if (cached) return JSON.parse(cached);

    const response = await fetch(apiUrl);
    const data = await response.json();

    // Cachear por un tiempo determinado
    await client.set(cacheKey, JSON.stringify(data), { EX: 600 }); // 10 min

    return data;
}
            

Beneficios: Mitigación de latencia externa, protección contra límites de uso y mayor resiliencia ante caídas de proveedores externos.

Conexión con Node.js y TypeScript

import { createClient, RedisClientType } from 'redis';

// Creación de cliente con TypeScript
const client /** @type {RedisClientType} */ = createClient({
    url: `redis://${process.env.REDIS_USER}:${process.env.REDIS_PASSWORD}@${process.env.REDIS_HOST}:${process.env.REDIS_PORT}`,
    socket: {
        connectTimeout: 60000,
        lazyConnect: true
    }
});

client.on('error', (err) => console.error('Redis Client Error:', err));
client.on('connect', () => console.log('Conectado a Redis'));

await client.connect();
            

En producción, es recomendable conectar Redis a través de redes privadas, usar autenticación fuerte, TLS cuando esté disponible y monitorear latencia, memoria y número de claves.

Estrategias de Persistencia y Respaldo

En entornos de producción, es crucial comprender y configurar las estrategias de persistencia de Redis para minimizar la pérdida de datos:

• RDB (Redis Database): Crea snapshots puntuales de los datos. Ideal para backups y recuperación rápida. Consume menos recursos, pero puede perder datos entre snapshots si se produce un fallo.
• AOF (Append Only File): Registra cada operación de escritura. Ofrece mayor durabilidad (menor pérdida de datos potencial), pero utiliza más espacio de almacenamiento y puede ser algo más lento.

La configuración híbrida (RDB + AOF) suele ser la más robusta para la mayoría de los casos, ya que equilibra rendimiento y durabilidad.

En topologías más avanzadas, puedes combinar:

• Replica sets: nodos secundarios en solo lectura para alta disponibilidad.
• Redis Cluster: particionamiento automático de datos para escalar horizontalmente.
• Sentinel: supervisión y failover automático del nodo maestro.