Websockets en Node.js: qué cambia con más de un servidor

A Node.js se le dan bien los websockets: un solo proceso mantiene abierta cada conexión en un único event loop, y un servidor que pasa cada mensaje a todos los conectados son unas quince líneas con la biblioteca ws. Con más de un proceso o más de un servidor, cada uno conoce solo sus propias conexiones, así que cada evento tiene que cruzar un canal que compartan, y el inicio de sesión, los reinicios y los proxies necesitan cada uno su propia respuesta.
Este artículo muestra ese pequeño servidor, qué cambia el segundo proceso, qué exige ejecutar varios servidores y cómo enviar eventos desde Node.js sin ningún servidor websocket.
Un servidor websocket en Node.js
Un websocket es una conexión en los dos sentidos entre un navegador y un servidor que se queda abierta, así que cualquiera de los dos lados puede enviar en cualquier momento. Node.js trae un cliente websocket integrado desde la versión 22, el mismo WebSocket que tiene un navegador. Un servidor es otra cosa: la guía de Node.js sobre websockets explica que aceptar conexiones sigue exigiendo una biblioteca. La habitual es ws:
npm install wsimport WebSocket, { WebSocketServer } from 'ws';
const wss = new WebSocketServer( { port: 8080 } );
wss.on( 'connection', ( socket ) => {
socket.on( 'error', console.error );
// Pass each message to everyone connected.
socket.on( 'message', ( data, isBinary ) => {
for ( const client of wss.clients ) {
if ( client.readyState === WebSocket.OPEN ) {
client.send( data, { binary: isBinary } );
}
}
} );
} );Una página se conecta con la API WebSocket que tienen todos los navegadores:
const socket = new WebSocket( 'ws://localhost:8080' );
socket.onopen = () => socket.send( 'hello' );
socket.onmessage = ( event ) => console.log( event.data );Arráncalo con node server.mjs, abre esa página en dos pestañas y cada una imprime lo que envía la otra. Cuando el servidor funcione en una dirección pública, nuestro test de WebSocket se conecta a él desde un navegador y explica cualquier código de cierre. Si el navegador solo indica que la conexión falló, nuestro artículo sobre el error 1006 de WebSocket explica cómo encontrar la causa.
Dos cosas de ese servidor deciden todo lo que viene después. Cada conexión sigue abierta mientras lo esté su página, a menudo durante horas. Y wss.clients vive en la memoria de este único proceso.
Por qué un solo proceso da para mucho
Node.js se creó para conexiones que esperan. Su event loop atiende muchas a la vez, y una conexión sin nada que decir no le cuesta ni un thread ni un worker. Es lo contrario de PHP y de Python en WSGI, donde una conexión abierta tiene ocupado a un worker entero.
Los límites están en otra parte. Tu JavaScript se ejecuta en un solo thread, así que un proceso usa un núcleo de la CPU, y un proceso en una máquina es una sola cosa que puede fallar. Para usar más núcleos arrancas más procesos, con el módulo cluster o con un gestor de procesos. Para una máquina que puede fallar arrancas un segundo servidor. Los dos traen el mismo cambio.
Qué cambia el segundo proceso
Con el módulo cluster, el proceso primario acepta cada conexión nueva y se la entrega a uno de los workers, por turnos. Cada worker ejecuta el servidor de arriba, cada uno con su propio wss.clients. Un mensaje que llega al worker 1 va a los navegadores del worker 1, y los navegadores del worker 2 nunca se enteran.
En tu portátil esto se nota como dos pestañas que se ven entre sí solo a veces, según dónde haya caído cada una. La documentación de Node.js lo dice en una línea: Node.js no aporta lógica de enrutamiento. Después aconseja no apoyarse en objetos en memoria, y un conjunto de conexiones abiertas es justo eso.
La solución es un canal que compartan todos los procesos, normalmente Redis. Cada proceso publica lo que recibe y entrega a sus propios navegadores lo que haya publicado cualquier proceso:
import { createClient } from 'redis';
const publisher = createClient( { url: process.env.REDIS_URL } );
const subscriber = publisher.duplicate();
await Promise.all( [ publisher.connect(), subscriber.connect() ] );
// What any process published goes to the browsers of this one.
await subscriber.subscribe( 'events', ( message ) => {
for ( const client of wss.clients ) {
if ( client.readyState === WebSocket.OPEN ) client.send( message );
}
} );
wss.on( 'connection', ( socket ) => {
socket.on( 'message', ( data ) => publisher.publish( 'events', data.toString() ) );
} );Esa es toda la idea, y vale igual para dos procesos en una máquina que para veinte servidores. Ten en cuenta lo que deja sin resolver. El pub/sub de Redis entrega como mucho una vez, así que un proceso que en ese momento se estaba reconectando a Redis nunca recibe el evento, y tampoco un navegador que se estaba reconectando a tu servidor.
Qué exigen varios servidores
El canal compartido es el primer punto. El resto de la lista llega con el load balancer:
- Un proxy configurado para el upgrade. Un websocket empieza como una petición HTTP que pide un upgrade. La documentación de nginx explica que un proxy no reenvía por sí solo las cabeceras
UpgradeyConnection, así que las dos se ponen a mano, y que una conexión que pasa por el proxy sin datos durante 60 segundos se cierra por defecto. - Un heartbeat. Por eso el servidor envía un ping a cada conexión cada cierto tiempo. Así los proxies no cierran una que está callada, y aparecen las conexiones que murieron sin avisar. El README de ws tiene el patrón: marca cada socket, envíale un ping y termina los que no hayan respondido para la siguiente ronda.
- Saber quién se conecta. El
WebSocketde un navegador acepta una dirección y subprotocolos, sin forma de poner una cabecera. Por eso el servidor lee la cookie de sesión, o un token de vida corta en la dirección, en el eventoupgradedel servidor HTTP, antes de que exista la conexión. Ahí comprueba también la cabeceraOrigin, porque una página de cualquier otro sitio puede abrir un websocket con tu servidor, y el estándar deja en tus manos rechazarlo. - Sticky sessions, a veces. Un websocket puro es una sola conexión, y se queda en el servidor al que llegó. Una biblioteca que puede recurrir al long polling por HTTP hace varias peticiones para una misma sesión, y todas tienen que llegar al mismo proceso, así que el load balancer tiene que fijar cada navegador a uno.
- Deploys. Un reinicio corta todas las conexiones de ese proceso. El
WebSocketde un navegador no se reconecta por sí solo, así que lo hace el código de tu página, tras una espera que crece y que es distinta en cada navegador, o todos vuelven en el mismo segundo. Lo que se envió mientras una página estaba desconectada se pierde, a menos que guardes los eventos recientes y los reenvíes desde el último que vio. - Lectores lentos.
send()vuelve al instante, y lo que una conexión lenta todavía no ha recogido espera en la memoria de tu proceso.bufferedAmountdice cuánto, así que el servidor puede saltarse o cerrar una conexión que se ha quedado demasiado atrás.
Nada de esto es inusual, y muchos equipos lo hacen bien. Aun así, es un segundo sistema junto a tu app, con su propio Redis, sus propias reglas de proxy y sus propios días malos.
O no mantengas ningún servidor websocket
Un servicio de tiempo real alojado saca las conexiones de tus servidores. Los navegadores se conectan al servicio. Tu código de Node.js envía cada evento en una petición HTTPS corta, desde el proceso o el servidor que haya atendido el cambio, y el servicio lo entrega a cada página que deba recibirlo. Ninguna conexión vive en tus procesos, así que deja de importar cuántos ejecutes.
| Configuración | Dónde viven las conexiones | Qué añades |
|---|---|---|
| Un proceso | En su memoria | Nada |
| Varios procesos o servidores | En cada uno | Un canal compartido, reglas de proxy, heartbeats, reenvío |
| Un servicio alojado | En sus servidores | Una petición por cada evento |
Node.js en WordPlus Cloud
Con WordPlus Cloud, un solo paquete cubre las dos mitades, el servidor y la página:
npm install @wordplus/realtimeTu servidor declara sus salas una sola vez, cada una con una regla para quién puede unirse, y monta un router. Esto es Express, con el usuario sacado de la sesión:
import express from 'express';
import session from 'express-session';
import { createRealtime } from '@wordplus/realtime/server';
const realtime = createRealtime( {
site: process.env.WORDPLUS_SITE,
secret: process.env.WORDPLUS_SECRET,
localKey: process.env.WORDPLUS_LOCAL_KEY,
} );
// The room of an order, order:1042: its customer may join, and the last 20 updates are kept.
realtime.room( 'order:{id}', { history: 20 }, async ( user, { id } ) => {
if ( user === null ) return false;
const order = await db.orders.find( id );
return order?.customerId === user;
} );
const app = express();
app.use( session( { secret: process.env.SESSION_SECRET, resave: false, saveUninitialized: false } ) );
// Answers the pages that ask to join a room, and serves the browser files of the SDK.
app.use( '/api/realtime', realtime.node( ( req ) => req.session.userId ?? null ) );
app.use( express.json() );
// After your own work is saved, tell everyone in the room.
app.post( '/orders/:id/status', async ( req, res ) => {
const order = await db.orders.setStatus( req.params.id, req.body.status );
await realtime.to( `order:${ order.id }` ).emit( 'updated', { status: order.status } );
res.json( { ok: true } );
} );La página se une a la sala a través de tu bundler, con la clave de tu app en lugar de esta:
import { connect } from '@wordplus/realtime';
const rt = await connect( { app: 's1500000007' } );
const order = rt.join( 'order:1042' );
order.on( 'updated', ( data ) => showStatus( data.status ) );Ese emit es una petición HTTPS, así que funciona igual en un proceso, en ocho workers de cluster y en una función serverless. Más allá de eso:
- Nada que compartir entre tus servidores. En ellos no se guarda nada de tiempo real, así que cualquiera responde a cualquier petición y envía a cualquier sala.
- Nada se pierde al reconectar. Una sala guarda sus últimos eventos, así que una página que vuelve recibe lo que se perdió, en orden.
- Todas las páginas de un usuario.
realtime.toUser( 42 ).emit( 'notice', { text: 'Your order shipped' } )llega a todas las pestañas y dispositivos que tenga abiertos. Un usuario sin nada abierto no recibe nada, así que envía un correo para lo que tenga que llegarle sí o sí. - Una conexión para todas las pestañas. Las pestañas de un navegador comparten una conexión, así que una persona con tres pestañas abiertas cuenta una sola vez.
- Sellado en tránsito. Lo que tu servidor envía a una sala con regla viaja cifrado con claves que solo tienen tu servidor y tus usuarios.
- Más que eventos. Quién está en línea, llamadas que suenan en todas las pestañas, llamadas en grupo y transmisiones en directo llegan por la misma conexión, con una pantalla de llamada, un chat y un reproductor listos para usar de Better Messages, o tu propia interfaz sobre la misma API.
El mismo paquete funciona también sin Express, en un servidor Node.js puro, en Fastify o en Hono. Para Next.js, websockets en hosting serverless es un artículo aparte.
Cuándo te conviene más tu propio servidor
Un servicio alojado no sirve para todo. Tu código de Node.js se entera de lo que envían las páginas a través de un webhook, una petición HTTP que puede llegar más de una vez, y no a través de un bucle en directo con cada conexión. Un juego o un sistema de control en el que tu proceso tenga que responder a cada mensaje en milisegundos debe ir en su propio servidor. Lo mismo vale para un protocolo propio que otros programas hablen sobre un websocket puro. Y una herramienta pequeña con un proceso y unos cientos de personas quizá nunca necesite más que las quince líneas del principio de este artículo.
Empieza por la guía
La guía de Express tiene toda la configuración, y la demo de Express es una pequeña tienda construida sobre ella, en la que un pedido pasa a enviado en otra ventana en cuanto haces clic. La misma lista se ve un poco distinta en Python, donde FastAPI se encuentra con ella con más de un worker.
WordPlus Cloud for Apps tiene un precio según las conexiones simultáneas, a partir de 1.000, con facturación mensual o anual, y nuestro artículo sobre los precios de tiempo real explica cómo funciona contar por conexión. Nuestra página de la API de WebSocket muestra salas, presencia y eventos en cada stack, y los precios para apps tienen las cifras. ¿Preguntas sobre tu integración? Escríbenos.