Qué es Redis y para qué sirve

Cuando una página tarda porque cada visita consulta la base de datos, casi nunca el problema es que la base sea mala. Es que el mismo dato se lee miles de veces. Redis nació para eso: guardar en memoria lo que se lee todo el tiempo y devolverlo casi sin espera.

Hoy va más allá de la caché. Según su documentación oficial, es un almacén de datos en memoria que se usa como caché, base de datos de documentos, base de datos vectorial, motor de streaming y message broker.

¿Qué es Redis?#

Redis es un servidor de estructuras de datos que mantiene el conjunto de datos en la memoria RAM. Te conectas por red, envías comandos como SET y GET y recibes la respuesta. El proyecto de código abierto existe desde 2009.

El modelo básico es clave-valor: cada dato tiene una clave (texto) y un valor. La diferencia con un diccionario común es que el valor puede ser una estructura completa (lista, conjunto, hash) y que el servidor entiende esas estructuras, con operaciones atómicas sobre ellas.

¿Por qué Redis es tan rápido?#

El motivo principal es la memoria. Leer de la RAM es mucho más rápido que leer de disco, y Redis mantiene el conjunto de datos ahí. El acceso también es directo por clave, sin planificación de consultas ni joins, y los comandos son simples y específicos para cada estructura.

El precio de esa velocidad es la capacidad: la RAM cuesta más por gigabyte que el disco, así que el conjunto de datos de Redis tiene que caber en la memoria que contrates.

¿Qué estructuras de datos tiene Redis?#

Redis Open Source ofrece, entre otros, estos tipos:

• Strings: una secuencia de bytes. Sirve para texto, JSON serializado y contadores.
• Hashes: pares campo-valor, como un objeto con propiedades.
• Listas: listas de strings en orden de inserción, buenas para colas simples.
• Conjuntos (sets): strings únicos y sin orden, con prueba de pertenencia en O(1).
• Conjuntos ordenados (sorted sets): strings únicos ordenados por una puntuación, ideales para rankings.
• Streams: un log de eventos al que solo se agrega, para procesar eventos en el orden en que ocurrieron.
• Otros: bitmaps, índices geoespaciales, HyperLogLog, JSON, series temporales y conjuntos vectoriales.

Toda clave puede tener un tiempo de vida (TTL). Cuando se acaba, Redis borra la clave por sí solo. Así se limpia una caché y así expira una sesión.

¿Para qué sirve Redis en la práctica?#

Los usos más comunes:

• Caché: guardar el resultado de una consulta lenta o de una llamada a una API por unos segundos o minutos.
• Sesiones: mantener la sesión del usuario en un lugar que varios procesos de la aplicación puedan leer.
• Contadores y límite de solicitudes: INCR incrementa un número de forma atómica, lo que resuelve el conteo de accesos y el rate limit.
• Rankings: un sorted set mantiene las puntuaciones ordenadas sin que tengas que reordenar nada.
• Colas y pub/sub: listas, streams y canales de publicación pasan trabajo o mensajes entre procesos.
• Bots: guardar cooldowns, configuraciones por servidor o estado temporal de comandos.

Ejemplo: caché de consultas en Node.js#

El siguiente código usa node-redis (se instala con npm install redis) y el patrón cache-aside: intenta la caché y, si no encuentra el dato, lo busca en la fuente y lo guarda con un TTL de 60 segundos. La URL de conexión va en una variable de entorno.

import { createClient } from "redis";

const redis = createClient({ url: process.env.REDIS_URL });
redis.on("error", (err) => console.error("Redis Client Error", err));
await redis.connect();

// Simula una consulta lenta a la base de datos principal
async function loadUserFromDatabase(id) {
  await new Promise((resolve) => setTimeout(resolve, 300));
  return { id, name: "Ada" };
}

async function getUser(id) {
  const key = `user:${id}`;

  const cached = await redis.get(key);
  if (cached) return JSON.parse(cached); // cache hit

  const user = await loadUserFromDatabase(id); // cache miss
  await redis.set(key, JSON.stringify(user), {
    expiration: { type: "EX", value: 60 },
  });
  return user;
}

console.log(await getUser(1)); // ~300 ms
console.log(await getUser(1)); // lo responde Redis
await redis.quit();

Define REDIS_URL con el formato redis://usuario:contraseña@host:6379 (o rediss:// cuando el servidor exige TLS). Guarda el archivo como cache.mjs y ejecútalo con node cache.mjs: la primera llamada tarda unos 300 ms, y la segunda llega directo desde Redis. Fíjate en la convención tipo:id (user:1) para las claves: Redis no tiene espacios de nombres, y la documentación recomienda ese patrón.

¿Los datos de Redis sobreviven a un reinicio?#

Sobreviven si activas la persistencia. Redis tiene dos formas, que se pueden combinar:

• RDB: toma instantáneas del conjunto de datos a intervalos (por ejemplo, save 60 1000 escribe cada 60 segundos si cambiaron al menos 1000 claves). Es compacto y reinicia rápido, pero un apagado inesperado puede perder los últimos minutos.
• AOF (append-only file): registra cada escritura y las reaplica al arrancar. Con appendonly yes y la política por defecto appendfsync everysec, pierdes como máximo cerca de un segundo de escrituras.

También puedes desactivar la persistencia, algo común cuando Redis es solo una caché. La documentación sugiere usar RDB y AOF juntos si quieres un nivel de seguridad de datos comparable al de PostgreSQL.

¿Qué pasa cuando la memoria se llena?#

Defines un límite con maxmemory (por ejemplo, maxmemory 100mb). Al alcanzarlo, Redis sigue la política maxmemory-policy. Con noeviction, rechaza nuevas escrituras y devuelve error. Con allkeys-lru, borra las claves menos usadas recientemente, que es un buen valor para una caché. Existen además variantes volatile-*, que solo eliminan claves con TTL.

Aquí se separan una caché y una base de datos: en una caché, borrar claves viejas es justo lo que quieres. Para datos que no pueden desaparecer, usa noeviction y monitorea el uso.

¿Cuándo no usar Redis?#

• Datos grandes y relacionales: si el conjunto no cabe en la RAM o necesitas joins, consultas ad hoc y restricciones, una base como PostgreSQL encaja mejor. Mira también cómo elegir una base de datos.
• Documentos con consultas flexibles: MongoDB está hecho para eso.
• Datos críticos sin persistencia: en una configuración de caché sin persistencia, un reinicio borra todo.
• Recorrer todas las claves: el comando KEYS bloquea el servidor en bases grandes. Usa SCAN, que recorre las claves por partes.

Una combinación común es usar Redis junto a una base principal: la base guarda la verdad y Redis acelera las lecturas. Para decidir dónde ejecutar la base, lee cómo alojar una base de datos.

¿Redis o Valkey?#

Valkey es un proyecto BSD respaldado por la Linux Foundation que incluye código de Redis con licencia BSD. Redis Open Source, desde la versión 8, se ofrece bajo RSALv2, SSPLv1 o AGPLv3, a tu elección. Lee la licencia si piensas redistribuir o revender el software y revisa la compatibilidad con la versión y los módulos que usas.

Cómo hacerlo en Square Cloud#

El ejemplo de caché de arriba corre, cambiando solo la conexión, en el hosting de Redis de Square Cloud, disponible desde el plan Standard (desde R$44,99 al mes); el Hobby no incluye bases de datos. Creas Redis en el panel, siempre en una versión reciente, y eliges su memoria desde 512 MB, que sale de la RAM del plan. Como el conjunto de datos tiene que caber en esa memoria, dimensiónala según lo que ocupan tus datos, con margen. La base queda lista en segundos en el mismo datacenter que tus aplicaciones, con una latencia media de cerca de 1 ms.

La conexión exige TLS: la URL del panel empieza con rediss://, y tu cliente debe confiar en la CA del certificado que descargas ahí (en node-redis, pasa el archivo en socket.ca). Guarda la URL en REDIS_URL, la misma variable del ejemplo. Hay una única base de datos lógica, así que la convención tipo:id en las claves es lo que separa caché, sesiones y colas. Los clientes inactivos se desconectan tras 5 minutos: node-redis se reconecta solo, pero revisa ese comportamiento si usas otro cliente.

El Redis alojado tiene persistencia y admite PUBLISH/SUBSCRIBE, lo que cubre sesiones, contadores y pub/sub además de la caché. Puedes tomar snapshots manuales cuando quieras, y todo plan que incluye bases de datos hace también un snapshot automático diario, que se restaura en la misma base, en otro Redis o en una base nueva.

Mira los detalles y crea la instancia en Hosting de Redis.