Redis pub/sub

Un Dynamic Snapshot sirve todo el contenido desde un snapshot en memoria del servidor y lo refresca en caliente cuando publicas, sin rebuild ni una llamada al API por lectura. El patrón tiene dos piezas: de dónde se lee el snapshot (snapshotLoader) y quién dispara el refresco (refreshSnapshot()).

En esta versión el JSON vive en Redis. Un publisher exporta el snapshot con exportSnapshot(), hace SET + PUBLISH, y todas las instancias suscritas se refrescan a la vez con un único mensaje.

Cómo funciona

• Origen: Redis. El snapshotLoader lee la key del snapshot.
• Disparo con pub/sub: en lugar de un POST por instancia, un único PUBLISH notifica a todas las réplicas suscritas y cada una llama a refreshSnapshot().

Nota

Con este cableado el disparo llega por el canal de Redis, así que ya no necesitas el endpoint HTTP de refresco como mecanismo principal. El ejemplo conserva el route.ts de la versión por endpoint solo como refresco manual opcional.

Cuándo elegirla

• Pensada para escalado horizontal: refresca N instancias con un solo mensaje, sin webhooks por instancia ni N llamadas al API.
• Requiere un Redis accesible por todas las réplicas.

Paso a paso

Parte del proyecto de la versión por endpoint. Cambiamos el snapshotLoader por Redis, añadimos la suscripción y un publisher.

1. Levanta Redis e instala dependencias:

   docker run -d --name redis -p 6379:6379 redis:7
   npm i redis
   npm i -D tsx dotenv   # para ejecutar el publisher en TypeScript fuera de Next.js

   .env

   REDIS_URL=redis://localhost:6379

2. Crea la conexión a Redis (dentro de Next.js el .env se carga solo):

   lib/redis.ts

   import { createClient as createRedis } from 'redis';
   
   export const redis = createRedis({ url: process.env.REDIS_URL });
   export const redisReady = redis.connect();

3. Cambia el snapshotLoader para leer de Redis y suscríbete al canal. Al primer uso, cada instancia escucha y se refresca sola cuando el publisher avisa. Si el snapshot aún no existe en Redis, no cacheamos el fallo, para que el siguiente request lo reintente:

   lib/content-island.ts

   import { createClient } from '@content-island/api-client';
   import { redis, redisReady } from './redis';
   
   const accessToken = process.env.CONTENT_ISLAND_TOKEN!;
   const SNAPSHOT_KEY = 'content-island:snapshot';
   const CHANNEL = 'content-island:updated';
   
   const globalForClient = globalThis as unknown as {
     contentIslandClient?: ReturnType<typeof createClient>;
     primed?: Promise<unknown> | null;
   };
   
   export const contentIslandClient =
     globalForClient.contentIslandClient ??
     createClient({
       accessToken,
       mode: 'snapshot',
       // El loader lee el snapshot de Redis.
       snapshotLoader: async () => {
         await redisReady;
         return (await redis.get(SNAPSHOT_KEY)) ?? '';
       },
     });
   
   globalForClient.contentIslandClient = contentIslandClient;
   
   // Al primer uso, esta instancia se suscribe al canal y se refresca sola cada
   // vez que el publisher avisa. También hace la carga inicial del snapshot.
   export function ensureSnapshot() {
     if (!globalForClient.primed) {
       globalForClient.primed = (async () => {
         await redisReady;
         const sub = redis.duplicate();
         await sub.connect();
         await sub.subscribe(CHANNEL, () => {
           contentIslandClient.refreshSnapshot().catch(console.error);
         });
         await contentIslandClient.refreshSnapshot(); // carga inicial
       })().catch(err => {
         // No cacheamos el fallo: si el snapshot aún no existe en Redis, el
         // siguiente request lo reintenta en vez de reusar una promesa rechazada.
         globalForClient.primed = null;
         throw err;
       });
     }
     return globalForClient.primed;
   }

4. Crea el publisher: exporta, hace SET y PUBLISH. Fuera de Next.js carga el .env con dotenv:

   scripts/publish-redis.mts

   import 'dotenv/config';
   import { exportSnapshot } from '@content-island/api-client';
   import { createClient as createRedis } from 'redis';
   
   const redis = createRedis({ url: process.env.REDIS_URL });
   await redis.connect();
   
   const snapshot = await exportSnapshot({ accessToken: process.env.CONTENT_ISLAND_TOKEN! });
   await redis.set('content-island:snapshot', JSON.stringify(snapshot));
   await redis.publish('content-island:updated', '1');
   
   await redis.quit();
   console.log('✅ snapshot publicado en Redis');

   Añade un script en el package.json para lanzarlo:

   package.json

   "scripts": {
     "publish:redis": "tsx scripts/publish-redis.mts"
   }

5. Pruébalo con dos instancias (que es la gracia). Haz una primera carga en Redis y arranca dos apps en puertos distintos:

   npm run publish:redis   # primera carga en Redis
   
   PORT=3000 npm run dev   # en una terminal
   PORT=3001 npm run dev   # en otra

   Dos instancias en desarrollo

   Next.js no permite arrancar dos instancias en modo desarrollo desde el mismo proyecto: ambos next dev comparten el mismo directorio .next y entran en conflicto. Para probar el pub/sub con dos instancias reales, duplica el proyecto en dos carpetas separadas (cada una con su propio .next) y arranca cada copia en un puerto distinto, apuntando ambas al mismo Redis.

   Publica contenido nuevo y lanza npm run publish:redis una sola vez. Recarga las dos páginas: ambas actualizan su exportedAt a la vez, con un único PUBLISH.

Ejemplo

El repositorio de ejemplos implementa el patrón en TanStack Start; los pasos anteriores son la adaptación a Next.js (solo cambia el pegamento del framework): content-island/examples-dynamic-snapshot → 03-redis-pub-sub.

Referencias

• Modo snapshot · exportSnapshot() · refreshSnapshot()
• Redis (Docker)