Caché en Node.js: Redis, Memcached y memoria integrada

Caché en JavaScript (Node.js): Redis y otras herramientas

El caché es una de las formas más efectivas de mejorar el rendimiento de las aplicaciones web en Node.js. Permite reducir el tiempo de respuesta, disminuir la carga en las bases de datos y reducir los costos de infraestructura. En este artículo, analizaremos las principales herramientas de caché en el entorno Node.js: Redis, Memcached y el caché integrado en memoria (in-memory cache). Aprenderá cuándo elegir cada herramienta y verá ejemplos prácticos de código.

¿Por qué es necesario el caché en Node.js?

Node.js es de un solo hilo pero asíncrono. Cada solicitud a una base de datos o API externa implica una espera (I/O). El caché permite guardar el resultado de una operación costosa (por ejemplo, una consulta SQL compleja o el análisis de HTML) y entregarlo instantáneamente. Los casos de uso principales son:

• Guardar resultados de consultas a la BD (especialmente las agregadas)
• Almacenar en caché respuestas de API externas (clima, tipos de cambio)
• Almacenar sesiones de usuarios
• Almacenamiento temporal de datos calculados (por ejemplo, renderizado de plantillas)

1. Redis — el rey del caché

Redis es un almacén de datos en memoria que se utiliza a menudo como caché. Funciona en un proceso separado, admite estructuras de datos complejas (cadenas, hashes, listas, conjuntos) y tiene mecanismos TTL (tiempo de vida de la clave) integrados.

Instalación y conexión

Para trabajar, necesita un servidor Redis instalado (localmente o en Docker). En Node.js usamos el paquete redis:

npm install redis

Ejemplo: almacenamiento en caché con TTL

const redis = require('redis');const client = redis.createClient();

client.on('error', (err) => console.error('Error de Redis:', err));

// Función asíncrona para obtener datos con cachéasync function getCachedData(key, fetchFunction, ttlSeconds = 60) {  // Intentar obtener del caché  const cached = await client.get(key);  if (cached) {    return JSON.parse(cached);  }

  // Si no está, llamar a la función costosa  const freshData = await fetchFunction();

  // Guardar en caché con TTL  await client.setEx(key, ttlSeconds, JSON.stringify(freshData));  return freshData;}

// Uso: almacenar en caché el resultado de una consulta a la BDconst users = await getCachedData('users:list', () => db.query('SELECT * FROM users'), 120);

Ventajas de Redis

• Alto rendimiento (millones de operaciones por segundo)
• Soporte para TTL, pub/sub, transacciones
• Persistencia (se puede guardar en disco)
• Adecuado para sistemas distribuidos (varios servidores Node.js)

Desventajas

• Requiere un servidor/contenedor separado
• Consume memoria RAM
• Excesivo para aplicaciones simples de un solo hilo

2. Memcached — ligero y rápido

Memcached es otro caché en memoria popular, pero más simple que Redis: solo cadenas, sin persistencia, sin estructuras complejas. Ideal para almacenamiento en caché simple de datos.

Instalación y ejemplo

npm install memcached

const Memcached = require('memcached');const memcached = new Memcached('localhost:11211');

async function getCachedData(key, fetchFunction, ttlSeconds = 60) {  return new Promise((resolve, reject) => {    memcached.get(key, async (err, data) => {      if (data) return resolve(JSON.parse(data));

      const freshData = await fetchFunction();      memcached.set(key, JSON.stringify(freshData), ttlSeconds, (err) => {        if (err) reject(err);        resolve(freshData);      });    });  });}

¿Cuándo usar Memcached?

• Se necesita solo un caché simple de clave-valor
• No se requiere conservar datos después de un reinicio
• Recursos limitados (Memcached es más ligero que Redis)

3. En