Cómo integrar Redis de Azure en una solución cloud nativa
Redis suele aparecer en una arquitectura como una pieza sencilla: un sitio donde guardar datos temporalmente para no repetir trabajo. Y en parte es eso.
Pero cuando lo llevamos a producción, Redis deja de ser simplemente una caché rápida y empieza a formar parte del modelo operativo de la solución. Afecta a la latencia, al coste, a la resiliencia, a la seguridad, a la experiencia de usuario y a la presión que ejercemos sobre bases de datos, APIs externas o servicios cloud.
Por eso integrar Redis de Azure no debería consistir únicamente en copiar una cadena de conexión y hacer un GET o un SET. La integración debería responder a algunas preguntas importantes:
- Qué datos merece la pena cachear.
- Durante cuánto tiempo.
- Cómo se invalida la información.
- Qué ocurre si Redis no está disponible.
- Cómo se autentica la aplicación.
- Qué permisos necesita realmente.
- Cómo se observa el comportamiento en producción.
- Cómo evitamos convertir la caché en una nueva fuente de problemas.
En este artículo veremos cómo integrar Azure Managed Redis en una solución moderna, usando TypeScript como ejemplo, autenticación con Microsoft Entra ID y una arquitectura pensada para producción. La idea no es construir una demo aislada, sino entender cómo Redis encaja dentro de una aplicación real.
Redis no arregla una mala arquitectura
Redis es muy rápido, pero no es magia. Si una consulta a base de datos es lenta, si una API externa tarda demasiado o si un dashboard recalcula información pesada en cada petición, Redis puede ayudar mucho. Pero no debería usarse para esconder indefinidamente problemas de diseño.
Una buena integración con Redis empieza por identificar claramente el coste que queremos evitar. Por ejemplo:
- Consultas repetidas a una base de datos.
- Llamadas frecuentes a APIs de terceros.
- Cálculos derivados que no cambian en cada petición.
- Sesiones de usuario.
- Resultados agregados para dashboards.
- Datos de configuración que se leen constantemente.
- Limitadores de tasa.
- Colas o coordinación ligera entre procesos.
Lo importante es que Redis tenga un papel claro. Cuando se usa sin criterio, la caché termina llena de claves difíciles de entender, TTLs arbitrarios, datos obsoletos y dependencias implícitas que nadie quiere tocar.
Redis puede hacer una solución más rápida y estable, pero solo si se integra como una pieza de arquitectura, no como un parche.
Azure Managed Redis como servicio administrado
En Azure existen varias formas de trabajar con Redis. Si estás creando una solución nueva, la opción que conviene mirar primero es Azure Managed Redis, la oferta administrada más reciente de Microsoft para Redis sobre Azure.
Azure Managed Redis proporciona un almacén en memoria de baja latencia y alto rendimiento, operado como servicio administrado. Esto significa que no tenemos que desplegar ni mantener servidores Redis manualmente, ni ocuparnos de buena parte del trabajo operativo de infraestructura.
La aplicación se conecta a un endpoint Redis, pero el servicio se encarga de aspectos como disponibilidad, escalado, configuración de red, autenticación, replicación y mantenimiento de la plataforma.
Esto no elimina nuestras responsabilidades, pero cambia el tipo de trabajo que hacemos. En lugar de administrar máquinas, nos centramos en decidir cómo usar bien Redis dentro del producto.
Azure Managed Redis o Azure Cache for Redis
Durante mucho tiempo, el servicio más habitual fue Azure Cache for Redis. Si ya tienes una solución existente sobre Azure Cache for Redis, muchos de los patrones de este artículo siguen siendo válidos: conexión segura, TTLs, cache-aside, observabilidad, invalidación y resiliencia.
Sin embargo, para proyectos nuevos conviene revisar Azure Managed Redis porque Microsoft lo está posicionando como la experiencia más actual para Redis en Azure.
La diferencia práctica para una solución no está solo en el nombre del servicio. Azure Managed Redis pone mucho foco en integración con Microsoft Entra ID, opciones de alta disponibilidad, datos persistentes, módulos Redis y escenarios modernos como caché semántica o búsqueda vectorial.
Mi recomendación sería esta:
- Si estás empezando una solución nueva, evalúa Azure Managed Redis primero.
- Si mantienes Azure Cache for Redis, revisa las guías de migración antes de hacer cambios grandes.
- Si solo necesitas un patrón de caché básico, diseña la aplicación de forma que la capa Redis pueda cambiar sin tocar todo el sistema.
La abstracción interna importa más de lo que parece.
Dónde encaja Redis en la arquitectura
Una forma limpia de integrar Redis es situarlo detrás de una capa de servicio propia. No conviene que cada controlador, cada componente o cada tarea programada construya sus propias claves y hable directamente con Redis.
El patrón sería algo así:
Frontend / API consumer
| v
API / Controller
| v
Servicio de dominio
| v
Servicio de caché
| v
Azure Managed Redis
| v
Base de datos / API externa / cálculo pesado
La capa de caché se encarga de los detalles de Redis: conexión, serialización, TTL, claves, errores e invalidación. La capa de dominio decide qué dato necesita y qué nivel de frescura es aceptable.
Esta separación evita que Redis se convierta en una dependencia dispersa por toda la aplicación.
El patrón cache-aside
El patrón más habitual para empezar es cache-aside. La idea es sencilla:
- La aplicación intenta leer el dato desde Redis.
- Si existe, lo devuelve.
- Si no existe, consulta la fuente real.
- Guarda el resultado en Redis con un TTL.
- Devuelve el dato al consumidor.
En código, el flujo mental sería este:
const cachedValue = await cache.get(key);
if (cachedValue) {
return cachedValue;
}
const freshValue = await database.findSomething(id);
await cache.set(key, freshValue, {
ttlSeconds: 300,
});
return freshValue;
Este patrón tiene una ventaja importante: la fuente de verdad sigue siendo la base de datos, la API externa o el sistema principal. Redis acelera la lectura, pero no se convierte automáticamente en el origen definitivo de los datos.
Para muchas aplicaciones web, dashboards internos y APIs de consulta, esto es exactamente lo que queremos.
Diseñar las claves antes de escribir código
Uno de los errores más comunes al usar Redis es improvisar las claves. Al principio parece algo menor. Una clave por aquí, otra clave por allá, un user:${id} y algún data:${id}. Pero cuando la solución crece, las claves se convierten en un contrato interno. Conviene tratarlas con cuidado.
Una buena clave debería decir:
- A qué dominio pertenece.
- Qué versión de estructura usa.
- Qué entidad representa.
- Qué filtros o parámetros incluye.
- Si el dato es privado, compartido o global.
Por ejemplo:
dashboard:v1:tenant:acme:summarycustomer:v2:tenant:acme:id:12345settings:v1:globalrate-limit:v1:login:ip:203.0.113.10
El prefijo con versión es especialmente útil. Si mañana cambia la forma de serializar el dato o el contrato de respuesta, puedes pasar de v1 a v2 sin tener que borrar inmediatamente todas las claves antiguas. El TTL terminará limpiando lo viejo.
Crear la instancia en Azure
Antes de escribir código, hay varias decisiones de infraestructura que merece la pena cerrar.
Primero, la región. Lo normal es desplegar Redis en la misma región que la aplicación principal para reducir latencia y evitar costes innecesarios de tráfico entre regiones.
Segundo, el tamaño. No elijas el SKU únicamente por memoria. Redis también necesita CPU, red y capacidad de conexiones concurrentes. Una caché pequeña puede quedarse corta no por almacenamiento, sino por ancho de banda o saturación de conexiones.
Tercero, la red. Para producción, lo recomendable es evitar exposición pública cuando sea posible y usar acceso privado desde la red donde vive la aplicación.
Cuarto, la autenticación. En soluciones modernas, la prioridad debería ser Microsoft Entra ID con identidades gestionadas o service principals, no claves compartidas pegadas en variables de entorno.
Quinto, la alta disponibilidad. Si Redis forma parte del camino crítico de la aplicación, hay que diseñar pensando en failover, reconexiones y degradación controlada.
Estas decisiones son arquitectura, no solo configuración.
Configuración mínima de la aplicación
Para el ejemplo vamos a suponer una aplicación Node.js con TypeScript. Las variables mínimas podrían ser:
REDIS_ENDPOINT = my-cache.westeurope.redis.azure.net:10000
En Azure Managed Redis, el endpoint incluye host y puerto. En muchos escenarios verás el puerto 10000 para conexiones TLS.
Para instalar las dependencias:
npm install redis @redis/client @redis/entraid @azure/identity
Usaremos:
@azure/identitypara autenticarnos conDefaultAzureCredential.@redis/entraidpara conectar Redis con Microsoft Entra ID.@redis/clientcomo cliente Redis para Node.js.
En local, DefaultAzureCredential puede apoyarse en tu sesión de Azure CLI. En producción, puede usar la identidad gestionada del recurso donde se ejecuta la aplicación, como App Service, Azure Functions, Container Apps, AKS o una máquina virtual.
Crear un cliente Redis reutilizable
La conexión a Redis no debería crearse en cada petición HTTP. Lo habitual es crear un cliente reutilizable y mantenerlo durante la vida del proceso. Esto reduce latencia, evita abrir demasiadas conexiones y facilita gestionar reconexiones.
Un ejemplo de cliente para Azure Managed Redis con Microsoft Entra ID sería:
import { DefaultAzureCredential } from "@azure/identity";
import {
EntraIdCredentialsProviderFactory,
REDIS_SCOPE_DEFAULT,
} from "@redis/entraid";
import { createCluster, type RedisClusterType } from "@redis/client";
import { isIP } from "node:net";
let redisClient: RedisClusterType | null = null;
function getRequiredEnv(name: string): string {
const value = process.env[name];
if (!value) {
throw new Error(`Missing required environment variable: ${name}`);
}
return value;
}
export async function getRedisClient(): Promise<RedisClusterType> {
if (redisClient?.isOpen) {
return redisClient;
}
const redisEndpoint = getRequiredEnv("REDIS_ENDPOINT");
const [redisHostName] = redisEndpoint.split(":");
const credential = new DefaultAzureCredential();
const credentialsProvider =
EntraIdCredentialsProviderFactory.createForDefaultAzureCredential({
credential,
scopes: REDIS_SCOPE_DEFAULT,
options: {},
tokenManagerConfig: {
expirationRefreshRatio: 0.8,
},
});
const client = createCluster({
rootNodes: [
{
url: `rediss://${redisEndpoint}`,
},
],
defaults: {
credentialsProvider,
socket: {
tls: true,
connectTimeout: 15_000,
keepAlive: 5_000,
reconnectStrategy: (retries) => Math.min(retries * 200, 5_000),
},
},
nodeAddressMap: (incomingAddress) => {
const [hostNameOrIp, port] = incomingAddress.split(":");
return {
host: isIP(hostNameOrIp) ? redisHostName : hostNameOrIp,
port: Number(port),
};
},
});
client.on("error", (error) => {
console.error("Redis connection error", {
message: error.message,
});
});
await client.connect();
redisClient = client;
return redisClient;
}
Hay varios detalles importantes aquí. Primero, usamos rediss://, es decir, conexión cifrada. Segundo, no guardamos una contraseña de Redis en el código. Tercero, usamos DefaultAzureCredential, por lo que el mecanismo de autenticación cambia según el entorno. Cuarto, el cliente se reutiliza. Quinto, definimos una estrategia de reconexión sencilla para evitar que un fallo temporal tumbe toda la aplicación de forma innecesaria.
En una aplicación grande, este cliente viviría en un módulo de infraestructura, no dentro de un controlador HTTP.
Una capa de caché con JSON
Redis guarda strings, hashes, listas, sets y otras estructuras. Para muchos casos de aplicación, una primera capa sencilla basada en JSON es suficiente. Podemos crear un pequeño wrapper:
import { getRedisClient } from "./redisClient";
type CacheOptions = {
ttlSeconds: number;
};
export async function getJsonFromCache<T>(key: string): Promise<T | null> {
const redis = await getRedisClient();
const value = await redis.get(key);
if (!value) {
return null;
}
return JSON.parse(value) as T;
}
export async function setJsonInCache<T>(
key: string,
value: T,
options: CacheOptions,
): Promise<void> {
const redis = await getRedisClient();
await redis.set(key, JSON.stringify(value), {
EX: options.ttlSeconds,
});
}
export async function deleteFromCache(key: string): Promise<void> {
const redis = await getRedisClient();
await redis.del(key);
}
Este wrapper es pequeño, pero ya nos da una frontera clara. El resto de la aplicación no necesita saber si usamos GET, SET, EX, serialización JSON o un cliente concreto. Más adelante podríamos añadir compresión, métricas, trazas, prefijos automáticos, validación de esquemas o manejo de errores sin cambiar todas las capas superiores.
Implementar un helper cache-aside
Para evitar repetir el mismo patrón en muchos servicios, podemos crear una función remember. La idea es parecida a decir: "dame este dato desde caché y, si no existe, ejecuto esta función para obtenerlo".
import { getJsonFromCache, setJsonInCache } from "./cache";
type RememberOptions<T> = {
key: string;
ttlSeconds: number;
loader: () => Promise<T>;
};
export async function remember<T>({
key,
ttlSeconds,
loader,
}: RememberOptions<T>): Promise<T> {
const cachedValue = await getJsonFromCache<T>(key);
if (cachedValue !== null) {
return cachedValue;
}
const freshValue = await loader();
await setJsonInCache(key, freshValue, { ttlSeconds });
return freshValue;
}
Con esto, los servicios de dominio quedan mucho más limpios.
import { remember } from "../infrastructure/cache/remember";
import { dashboardRepository } from "../repositories/dashboardRepository";
type DashboardSummary = {
tenantId: string;
activeUsers: number;
month
Comments
No comments yet. Start the discussion.