Des websockets avec Node.js : ce qui change au-delà d’un serveur

Node.js tient bien les websockets : un seul processus garde chaque connexion ouverte sur une seule boucle d’événements, et un serveur qui transmet chaque message à tous ceux qui sont connectés prend une quinzaine de lignes avec la bibliothèque ws. Au-delà d’un processus ou d’un serveur, chacun ne connaît que ses propres connexions, si bien que chaque événement doit traverser un canal qu’ils partagent, et que l’authentification, les redémarrages et les proxys demandent chacun leur propre réponse.
Cet article montre ce petit serveur, ce que change le second processus, ce qu’il faut pour faire tourner plusieurs serveurs, et comment envoyer des événements depuis Node.js sans aucun serveur websocket.
Un serveur websocket avec Node.js
Un websocket est une connexion bidirectionnelle entre un navigateur et un serveur qui reste ouverte, si bien que chaque côté peut envoyer à tout moment. Node.js intègre un client websocket depuis la version 22, le même WebSocket que celui du navigateur. Pour un serveur, c’est une autre affaire : le guide de Node.js sur les websockets indique qu’il faut encore une bibliothèque pour accepter des connexions. La plus courante est 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 } );
}
}
} );
} );Une page se connecte avec l’API WebSocket que possède chaque navigateur :
const socket = new WebSocket( 'ws://localhost:8080' );
socket.onopen = () => socket.send( 'hello' );
socket.onmessage = ( event ) => console.log( event.data );Lancez-le avec node server.mjs, ouvrez cette page dans deux onglets, et chacun affiche ce que l’autre envoie. Une fois que le serveur tourne sur une adresse publique, notre test WebSocket s’y connecte depuis un navigateur et explique tout code de fermeture. Si le navigateur indique seulement que la connexion a échoué, notre article sur l’erreur WebSocket 1006 montre comment en trouver la cause.
Dans ce serveur, deux choses décident de tout ce qui suit. Chaque connexion reste ouverte aussi longtemps que sa page, souvent pendant des heures. Et wss.clients vit dans la mémoire de ce seul processus.
Pourquoi un seul processus va loin
Node.js a été conçu pour les connexions qui attendent. Sa boucle d’événements en traite beaucoup à la fois, et une connexion qui n’a rien à dire ne lui coûte ni thread ni worker. C’est l’inverse de PHP et de Python sur WSGI, où une connexion ouverte occupe un worker entier.
Les limites sont ailleurs. Votre JavaScript s’exécute sur un seul thread, si bien qu’un processus n’utilise qu’un seul cœur du processeur, et un seul processus sur une seule machine, c’est un seul point qui peut tomber en panne. Pour plus de cœurs, vous lancez plus de processus, avec le module cluster ou un gestionnaire de processus. Pour une machine qui peut tomber en panne, vous lancez un second serveur. Les deux apportent le même changement.
Ce que change le second processus
Avec le module cluster, le processus principal accepte chaque nouvelle connexion et la confie à l’un des workers, à tour de rôle. Chaque worker fait tourner le serveur ci-dessus, chacun avec son propre wss.clients. Un message qui arrive dans le worker 1 part vers les navigateurs du worker 1, et ceux du worker 2 n’en entendent jamais parler.
Sur votre ordinateur portable, cela donne deux onglets qui ne se voient qu’une partie du temps, selon l’endroit où chacun a atterri. La documentation de Node.js le dit en une ligne : Node.js ne fournit aucune logique de routage. Elle déconseille ensuite de s’appuyer sur des objets en mémoire, et un ensemble de connexions ouvertes est exactement cela.
La solution est un canal que tous les processus partagent, en général Redis. Chaque processus publie ce qu’il reçoit, et distribue à ses propres navigateurs ce que n’importe quel processus a publié :
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() ) );
} );Voilà toute l’idée, et elle vaut pour deux processus sur une même machine comme pour vingt serveurs. Attention à ce qu’elle laisse en suspens. Le pub/sub de Redis distribue au plus une fois, si bien qu’un processus qui se reconnectait à Redis à ce moment-là ne reçoit jamais l’événement, pas plus qu’un navigateur qui se reconnectait à vous.
Ce qu’il faut avec plusieurs serveurs
Le canal partagé est le premier point. Le reste de la liste arrive avec le load balancer :
- Un proxy configuré pour l’upgrade. Un websocket commence par une requête HTTP qui demande un upgrade. La documentation de nginx explique qu’un proxy ne transmet pas de lui-même les en-têtes
UpgradeetConnection, si bien que les deux se définissent à la main, et qu’une connexion passant par le proxy sans aucune donnée pendant 60 secondes est fermée par défaut. - Un heartbeat. Le serveur envoie donc un ping à chaque connexion à intervalle régulier. Cela empêche les proxys de fermer une connexion silencieuse, et cela repère celles qui sont mortes sans prévenir. Le README de ws en donne le schéma : marquer chaque socket, lui envoyer un ping, et couper celles qui n’ont pas répondu au tour suivant.
- Savoir qui se connecte. Le
WebSocketdu navigateur prend une adresse et des sous-protocoles, sans aucun moyen de définir un en-tête. Le serveur lit donc le cookie de session, ou un token de courte durée placé dans l’adresse, dans l’événementupgradedu serveur HTTP, avant que la connexion n’existe. Il y vérifie aussi l’en-têteOrigin, car une page de n’importe quel autre site peut ouvrir un websocket vers votre serveur, et le standard vous laisse le soin de le refuser. - Des sticky sessions, parfois. Un simple websocket est une seule connexion, et elle reste sur le serveur qu’elle a atteint. Une bibliothèque capable de se rabattre sur le long polling HTTP fait plusieurs requêtes pour une même session, et toutes doivent atteindre le même processus, si bien que le load balancer doit attacher chaque navigateur à un seul.
- Déploiements. Un redémarrage coupe toutes les connexions de ce processus. Le
WebSocketdu navigateur ne se reconnecte pas de lui-même, c’est donc le code de votre page qui s’en charge, après un délai qui s’allonge et qui diffère pour chaque navigateur, sans quoi ils reviennent tous dans la même seconde. Ce qui a été envoyé pendant l’absence d’une page est perdu, à moins que vous ne gardiez les événements récents pour les rejouer à partir du dernier qu’elle a vu. - Lecteurs lents.
send()rend la main aussitôt, et ce qu’une connexion lente n’a pas encore pris attend dans la mémoire de votre processus.bufferedAmountdit combien, si bien que le serveur peut sauter ou fermer une connexion qui a pris trop de retard.
Rien de tout cela n’est inhabituel, et beaucoup d’équipes le font bien. Cela reste tout de même un second système à côté de votre application, avec son Redis, ses règles de proxy et ses mauvais jours.
Ou ne gardez aucun serveur websocket
Un service temps réel hébergé retire les connexions de vos serveurs. Les navigateurs se connectent au service. Votre code Node.js envoie chaque événement par une seule courte requête HTTPS, depuis le processus ou le serveur qui a traité le changement, quel qu’il soit, et le service le distribue à chaque page qui doit le recevoir. Aucune connexion ne vit dans vos processus, si bien que leur nombre cesse de compter.
| Mise en place | Où vivent les connexions | Ce que vous ajoutez |
|---|---|---|
| Un seul processus | Dans sa mémoire | Rien |
| Plusieurs processus ou serveurs | Dans chacun d’eux | Canal partagé, règles de proxy, heartbeats, rejeu |
| Un service hébergé | Sur ses serveurs | Une requête par événement |
Node.js sur WordPlus Cloud
Avec WordPlus Cloud, un seul paquet fournit les deux moitiés, le serveur et la page :
npm install @wordplus/realtimeVotre serveur déclare ses salons une fois pour toutes, avec pour chacun une règle qui dit qui peut le rejoindre, et monte un seul router. Voici ce que cela donne avec Express, où l’utilisateur vient de la session :
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 page rejoint le salon en passant par votre bundler, avec la clé de votre application à la place de celle-ci :
import { connect } from '@wordplus/realtime';
const rt = await connect( { app: 's1500000007' } );
const order = rt.join( 'order:1042' );
order.on( 'updated', ( data ) => showStatus( data.status ) );Cet emit est une seule requête HTTPS, si bien qu’il tourne de la même façon dans un seul processus, dans huit workers du module cluster et dans une fonction serverless. Au-delà :
- Rien à partager entre vos serveurs. Rien de ce qui est temps réel n’y est gardé, si bien que n’importe lequel répond à n’importe quelle requête et envoie à n’importe quel salon.
- Rien de perdu à la reconnexion. Un salon garde ses derniers événements, si bien qu’une page qui revient reçoit ce qu’elle a manqué, dans l’ordre.
- Toutes les pages d’un même utilisateur.
realtime.toUser( 42 ).emit( 'notice', { text: 'Your order shipped' } )atteint chaque onglet et chaque appareil qu’il a ouverts. Un utilisateur qui n’a rien d’ouvert ne reçoit rien, alors envoyez un e-mail pour ce qui doit lui parvenir. - Une seule connexion pour tous les onglets. Les onglets d’un même navigateur partagent une seule connexion, si bien qu’une personne avec trois onglets ouverts ne compte qu’une fois.
- Scellé en chemin. Ce que votre serveur envoie à un salon doté d’une règle voyage chiffré, avec des clés que seuls votre serveur et vos utilisateurs détiennent.
- Plus que des événements. La liste des personnes en ligne, les appels qui sonnent dans chaque onglet, les appels de groupe et les diffusions en direct passent par la même connexion, avec un écran d’appel, un chat et un lecteur prêts à l’emploi venus de Better Messages, ou votre propre interface sur la même API.
Le même paquet tourne aussi sans Express, dans un serveur Node.js pur, dans Fastify ou dans Hono. Pour Next.js, les websockets sur un hébergement serverless ont leur propre article.
Quand votre propre serveur convient mieux
Un service hébergé ne convient pas à tous les usages. Votre code Node.js reçoit ce que les pages envoient par un webhook, une requête HTTP qui peut arriver plus d’une fois, et non par une boucle en direct sur chaque connexion. Un jeu ou un système de contrôle où votre processus doit répondre à chaque message en quelques millisecondes a sa place sur son propre serveur. Il en va de même d’un protocole à vous, que d’autres programmes parlent sur un simple websocket. Et un petit outil, avec un seul processus et quelques centaines de personnes, n’aura peut-être jamais besoin de plus que les quinze lignes du début de cet article.
Commencez par le guide
Le guide Express détaille toute la mise en place, et la démo Express est une petite boutique construite dessus, où une commande passe à « expédiée » dans une autre fenêtre au moment où vous cliquez. La même liste prend une forme un peu différente en Python, où FastAPI la retrouve au-delà d’un seul worker.
WordPlus Cloud for Apps a un prix selon les connexions simultanées, à partir de 1 000, facturé au mois ou à l’année, et notre article sur les tarifs du temps réel explique comment fonctionne le décompte à la connexion. Notre page sur l’API WebSocket montre les salles, la présence et les événements dans chaque stack, et les tarifs pour les applications donnent les chiffres. Des questions sur votre intégration ? Écrivez-nous.