Caching en Node.js: Redis y alternativas para acelerar aplicaciones

Caching en JavaScript (Node.js): Redis y otros

El caching es una de las herramientas clave para mejorar el rendimiento de aplicaciones web en Node.js. Permite reducir el tiempo de respuesta del servidor, disminuir la carga en bases de datos y APIs externas, así como mejorar la experiencia del usuario. En este artículo, exploraremos bibliotecas y enfoques populares para el caching: desde soluciones integradas hasta el potente Redis.

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

Sin caching, cada solicitud al servidor puede provocar cálculos repetidos, consultas a la base de datos o servicios externos. Esto aumenta el tiempo de respuesta y el consumo de recursos. La caché almacena datos solicitados con frecuencia en un almacenamiento rápido (memoria RAM o base de datos in-memory), lo que permite:

• Acelerar las respuestas — la lectura desde la memoria es de 100 a 1000 veces más rápida que desde el disco.
• Reducir la carga — la base de datos procesa menos solicitudes.
• Ahorrar presupuesto — menos recursos en servicios en la nube.

1. Redis — el estándar industrial

Redis es un almacén de datos in-memory de alto rendimiento que admite estructuras de datos (cadenas, hashes, listas, conjuntos). Para Node.js se utilizan los paquetes redis o ioredis.

Instalación y conexión

npm install redis

const redis = require('redis');const client = redis.createClient({  url: 'redis://localhost:6379'});

client.on('error', (err) => console.error('Error del Cliente Redis', err));client.connect();

Operaciones básicas

// Escritura con TTL (tiempo de vida)await client.setEx('user:123', 3600, JSON.stringify({name: 'Alice', role: 'admin'}));

// Lecturaconst cached = await client.get('user:123');if (cached) {  console.log('Desde caché:', JSON.parse(cached));} else {  // consulta a la base de datos}

Funcionalidades avanzadas

• Invalidación por patrón — eliminación de todas las claves con prefijo user:*.
• Pub/Sub — notificaciones sobre cambios en la caché entre instancias.
• Redis Cluster — escalado horizontal.

2. node-cache — caché in-memory sin dependencias externas

Para proyectos pequeños o prototipos, la biblioteca node-cache es adecuada. Funciona dentro de un solo proceso de Node.js y no requiere instalar Redis.

Instalación

npm install node-cache

Ejemplo de uso

const NodeCache = require('node-cache');const myCache = new NodeCache({ stdTTL: 600, checkperiod: 120 });

// Guardamos datosmyCache.set('posts:recent', postsData, 3600);

// Leemosconst cached = myCache.get('posts:recent');if (cached) {  return cached;} else {  const fresh = await fetchPostsFromDB();  myCache.set('posts:recent', fresh);  return fresh;}

Características

• Configuración sencilla de TTL (time-to-live).
• Limpieza automática de entradas obsoletas.
• No es adecuado para sistemas distribuidos (los datos solo viven en un proceso).

3. memory-cache — una alternativa ligera

memory-cache es otra caché in-memory simple para Node.js. Se distingue por su API minimalista.

const cache = require('memory-cache');

// Escrituracache.put('api:weather', weatherData, 300000); // 5 minutos

// Lecturaconst data = cache.get('api:weather');if (!data) {  // reconsultar}

4. Estrategias de caching

La elección de la estrategia depende del tipo de datos y los requisitos de actualidad:

• Cache-Aside (Lazy Loading) — la aplicación primero verifica la caché; en caso de fallo, carga los datos y los guarda en la caché. Es el enfoque más popular.
• Write-Through — los datos se esc