Conceptos Básicos de Caching

8 ejemplos para empezar con el caching para APIs de Node.js - 6 básicos y 2 intermedios.

Prerrequisitos

npm install ioredis
npm install -D typescript@5.6 tsx @types/node

Ejecuta Redis localmente: docker run -d -p 6379:6379 redis:7. Consulta ioredis para detalles de conexión.

Ejemplos Básicos

1. Lectura Cache-Aside

import Redis from "ioredis";
 
const redis = new Redis(process.env.REDIS_URL!);
 
export async function getProduct(sku: string, loadFromDb: (sku: string) => Promise<Product | null>) {
  const key = `product:${sku}`;
  const cached = await redis.get(key);
  if (cached) return JSON.parse(cached) as Product;
 
  const product = await loadFromDb(sku);
  if (product) {
    await redis.set(key, JSON.stringify(product), "EX", 300);
  }
  return product;
}

• La aplicación es dueña de la consistencia - la DB es la fuente de verdad
• TTL (EX 300) limita la obsolescencia
• En caso de fallo de caché, solo una ruta de código carga la DB

Relacionado: ioredis - configuración del cliente

2. Estrategia TTL

• Un TTL más corto es más simple que una invalidación perfecta para lecturas de bajo riesgo
• Documenta la obsolescencia máxima por endpoint en la documentación de la API

3. Eliminación de Caché en Escritura

export async function updateProduct(sku: string, data: Partial<Product>, save: () => Promise<Product>) {
  const updated = await save();
  await redis.del(`product:${sku}`);
  return updated;
}

• Escribe primero en la DB, luego invalida la caché
• Para claves relacionadas, usa un patrón de eliminación o mantén un conjunto de índice inverso
• La falta de invalidación causa lecturas obsoletas hasta que expire el TTL

4. Claves con Espacio de Nombres

const NS = `api:${process.env.APP_ENV}:v1`;
 
function productKey(sku: string) {
  return `${NS}:product:${sku}`;
}

• Prefija por entorno para que el entorno de staging nunca acceda a las claves de producción
• Incrementa v1 a v2 en cambios de forma de caché que rompen la compatibilidad
• Evita la cardinalidad de claves ilimitada (sin cadenas de búsqueda de usuario sin procesar)

5. Degradación Elegante en Caso de Caída de Redis

export async function getWithFallback<T>(
  fetchCache: () => Promise<T | null>,
  fetchOrigin: () => Promise<T>
): Promise<T> {
  try {
    const hit = await fetchCache();
    if (hit !== null) return hit;
  } catch (err) {
    console.warn({ msg: "cache_unavailable", err: (err as Error).message });
  }
  return fetchOrigin();
}

• Una interrupción de Redis no debería afectar los endpoints de lectura
• Registra los errores de caché; alerta sobre fallos sostenidos
• Las escrituras que dependen de Redis (bloqueos, límites de tasa) aún pueden fallar

6. Costo de Serialización JSON

await redis.set(key, JSON.stringify(value), "EX", ttl);
const raw = await redis.get(key);
const value = raw ? (JSON.parse(raw) as T) : null;

• Los objetos grandes afectan la CPU y el ancho de banda - cachea DTOs, no grafos ORM completos
• Considera MessagePack solo cuando el perfilado demuestre que JSON es un cuello de botella
• Consulta Costo de Serialización JSON

Ejemplos Intermedios

7. Prevención de Estampidas (Bloqueo Single-Flight)

async function getOrLoad(key: string, ttlSec: number, loader: () => Promise<string>) {
  const hit = await redis.get(key);
  if (hit) return hit;
 
  const lockKey = `${key}:lock`;
  const acquired = await redis.set(lockKey, "1", "EX", 10, "NX");
  if (!acquired) {
    await new Promise((r) => setTimeout(r, 50));
    return (await redis.get(key)) ?? loader();
  }
  try {
    const value = await loader();
    await redis.set(key, value, "EX", ttlSec);
    return value;
  } finally {
    await redis.del(lockKey);
  }
}

• Cuando expira una clave "caliente", un cargador la repuebla; otros esperan o reintentan obtenerla
• El TTL del bloqueo evita interbloqueos si el cargador falla
• Alternativa: expiración temprana probabilística

Relacionado: Bloqueos Distribuidos - advertencias de bloqueo

8. Cache-Aside vs Read-Through

• Las APIs de Node casi siempre implementan cache-aside explícitamente
• Los workers de cola calientan las cachés después de actualizaciones masivas de la DB

Preguntas Frecuentes

Relacionado

• ioredis - conexión y pipelines
• Almacenes de Sesiones - sesiones de Redis
• Bloqueos Distribuidos - coordinación
• Mejores Prácticas de Caching - lista de verificación del equipo
• Conceptos Básicos de Rendimiento - presupuestos de latencia

Versiones de la pila: Esta página fue escrita para Node.js 24.18.0 (LTS Activo), npm 10+, TypeScript 5.6+, Express 5, Fastify 5 y NestJS 11.