Websocket in Node.js: cosa cambia oltre un solo server

Node.js regge bene i websocket: un solo processo tiene aperta ogni connessione su un unico event loop, e un server che passa ogni messaggio a tutti i collegati sta in circa quindici righe con la libreria ws. Oltre un solo processo o un solo server, ognuno conosce soltanto le proprie connessioni, quindi ogni evento deve passare per un canale condiviso da tutti, e autenticazione, riavvii e proxy richiedono ciascuno una risposta propria.
Questo articolo mostra quel piccolo server, cosa cambia con il secondo processo, cosa serve per far girare più server, e come inviare eventi da Node.js senza alcun server websocket.
Un server websocket in Node.js
Un websocket è una connessione bidirezionale tra un browser e un server che resta aperta, così ciascuna delle due parti può inviare in qualsiasi momento. Node.js ha un client websocket integrato dalla versione 22, lo stesso WebSocket che ha un browser. Un server è un’altra faccenda: la guida di Node.js sui websocket spiega che per accettare connessioni serve ancora una libreria. La più usata è 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 pagina si collega con l’API WebSocket che ogni browser ha:
const socket = new WebSocket( 'ws://localhost:8080' );
socket.onopen = () => socket.send( 'hello' );
socket.onmessage = ( event ) => console.log( event.data );Avvialo con node server.mjs, apri quella pagina in due schede, e ognuna stampa ciò che invia l’altra. Quando il server gira su un indirizzo pubblico, il nostro test WebSocket ci si collega da un browser e spiega qualsiasi codice di chiusura. Se il browser segnala soltanto che la connessione non è riuscita, il nostro articolo sull’errore WebSocket 1006 mostra come trovarne la causa.
Due cose in quel server decidono tutto ciò che segue. Ogni connessione resta aperta finché lo è la sua pagina, spesso per ore. E wss.clients vive nella memoria di questo solo processo.
Perché con un solo processo si va lontano
Node.js è nato per le connessioni che aspettano. Il suo event loop ne gestisce molte insieme, e una connessione che non ha nulla da dire non gli costa né un thread né un worker. È l’opposto di PHP e di Python su WSGI, dove una connessione aperta tiene occupato un intero worker.
I limiti sono altrove. Il tuo JavaScript gira su un solo thread, quindi un processo usa un solo core della CPU, e un solo processo su una sola macchina è una cosa sola che può guastarsi. Per usare più core avvii più processi, con il modulo cluster o un process manager. Per una macchina che può guastarsi avvii un secondo server. In entrambi i casi il cambiamento è lo stesso.
Cosa cambia con il secondo processo
Con il modulo cluster, il processo primario accetta ogni nuova connessione e la passa a turno a uno dei worker. Ogni worker esegue il server qui sopra, ciascuno con un proprio wss.clients. Un messaggio che arriva nel worker 1 va ai browser del worker 1, e i browser del worker 2 non ne sanno mai nulla.
Sul tuo portatile si presenta come due schede che si vedono a vicenda solo ogni tanto, a seconda di dove è finita ciascuna. La documentazione di Node.js lo dice in una riga: Node.js non fornisce alcuna logica di routing. Poi sconsiglia di fare affidamento sugli oggetti in memoria, e un insieme di connessioni aperte è esattamente questo.
La soluzione è un canale condiviso da tutti i processi, di solito Redis. Ogni processo pubblica ciò che riceve, e consegna ai propri browser ciò che ha pubblicato qualsiasi processo:
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() ) );
} );L’idea è tutta qui, e vale allo stesso modo per due processi su una macchina e per venti server. Attenzione però a ciò che lascia scoperto. Il pub/sub di Redis consegna al massimo una volta, quindi un processo che in quel momento si stava riconnettendo a Redis non riceve mai l’evento, e nemmeno un browser che si stava riconnettendo a te.
Cosa serve con più server
Il canale condiviso è la prima voce. Il resto dell’elenco arriva con il load balancer:
- Un proxy configurato per l’upgrade. Un websocket nasce come una richiesta HTTP che chiede un upgrade. La documentazione di nginx spiega che un proxy non inoltra da solo gli header
UpgradeeConnection, quindi vanno impostati entrambi a mano, e che una connessione che passa dal proxy e resta senza dati per 60 secondi viene chiusa di default. - Un heartbeat. Per questo il server invia un ping a ogni connessione a intervalli regolari. Così i proxy non chiudono quelle silenziose, e si scoprono le connessioni morte senza avvisare. Il README di ws ha lo schema: contrassegnare ogni socket, inviargli un ping e terminare quelli che non hanno risposto entro il giro successivo.
- Sapere chi si sta collegando. Il
WebSocketdel browser accetta un indirizzo e dei sottoprotocolli, senza alcun modo di impostare un header. Quindi il server legge il cookie di sessione, o un token di breve durata nell’indirizzo, nell’eventoupgradedel server HTTP, prima che la connessione esista. Lì controlla anche l’headerOrigin, perché una pagina di qualsiasi altro sito può aprire un websocket verso il tuo server, e lo standard lascia a te il compito di rifiutarlo. - Sticky session, a volte. Un websocket puro è una sola connessione, e resta sul server che ha raggiunto. Una libreria che può ripiegare sul long polling HTTP fa più richieste per una stessa sessione, e tutte devono arrivare allo stesso processo, quindi il load balancer deve legare ogni browser a un solo processo.
- Deploy. Un riavvio fa cadere ogni connessione di quel processo. Il
WebSocketdel browser non si riconnette da solo, quindi lo fa il codice della tua pagina, dopo un ritardo che cresce ed è diverso per ogni browser, altrimenti tornano tutti nello stesso secondo. Ciò che è stato inviato mentre una pagina era scollegata è perso, a meno che tu non conservi gli eventi recenti e li reinvii a partire dall’ultimo che ha visto. - Lettori lenti.
send()ritorna subito, e ciò che una connessione lenta non ha ancora preso aspetta nella memoria del tuo processo.bufferedAmountdice quanto, così il server può saltare o chiudere una connessione rimasta troppo indietro.
Niente di tutto questo è insolito, e molti team lo fanno bene. Resta comunque un secondo sistema accanto alla tua app, con un suo Redis, le sue regole nel proxy e le sue giornate storte.
Oppure non tenere nessun server websocket
Un servizio in tempo reale gestito toglie le connessioni ai tuoi server. I browser si collegano al servizio. Il tuo codice Node.js invia ogni evento con una breve richiesta HTTPS, da qualunque processo o server abbia gestito la modifica, e il servizio lo consegna a ogni pagina che deve riceverlo. Nessuna connessione vive nei tuoi processi, quindi quanti ne fai girare non conta più.
| Configurazione | Dove vivono le connessioni | Cosa aggiungi |
|---|---|---|
| Un processo | Nella sua memoria | Niente |
| Più processi o server | In ognuno di essi | Un canale condiviso, regole nel proxy, heartbeat, reinvio |
| Un servizio gestito | Sui suoi server | Una richiesta per ogni evento |
Node.js su WordPlus Cloud
Con WordPlus Cloud, un unico pacchetto contiene entrambe le metà, il server e la pagina:
npm install @wordplus/realtimeIl tuo server dichiara le sue stanze una volta sola, ciascuna con una regola su chi può entrare, e monta un unico router. Questo è Express, con l’utente preso dalla sessione:
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 pagina entra nella stanza tramite il tuo bundler, con la chiave della tua app al posto di questa:
import { connect } from '@wordplus/realtime';
const rt = await connect( { app: 's1500000007' } );
const order = rt.join( 'order:1042' );
order.on( 'updated', ( data ) => showStatus( data.status ) );Quella chiamata a emit è una sola richiesta HTTPS, quindi funziona allo stesso modo in un processo, in otto worker del cluster e in una funzione serverless. In più:
- Nulla da condividere tra i tuoi server. Non conservano nulla che riguardi il tempo reale, quindi ognuno di loro risponde a qualsiasi richiesta e invia a qualsiasi stanza.
- Nulla si perde alla riconnessione. Una stanza conserva i suoi ultimi eventi, così una pagina che torna riceve ciò che si è persa, in ordine.
- Ogni pagina di un utente.
realtime.toUser( 42 ).emit( 'notice', { text: 'Your order shipped' } )raggiunge ogni scheda e ogni dispositivo che ha aperti. Un utente che non ha nulla aperto non riceve nulla, quindi invia un’email per ciò che deve raggiungerlo. - Una sola connessione per tutte le schede. Le schede di un browser condividono un’unica connessione, così una persona con tre schede aperte conta una volta sola.
- Sigillato lungo il tragitto. Ciò che il tuo server invia a una stanza con una regola viaggia cifrato con chiavi che hanno solo il tuo server e i tuoi utenti.
- Non solo eventi. Chi è online, chiamate che squillano in ogni scheda, chiamate di gruppo e live streaming arrivano sulla stessa connessione, con la schermata di chiamata, la chat e il player pronti all’uso di Better Messages, oppure con la tua interfaccia sulla stessa API.
Lo stesso pacchetto funziona anche senza Express, in un semplice server Node.js, in Fastify o in Hono. Per Next.js, i websocket su hosting serverless hanno un articolo a parte.
Quando è meglio un server tutto tuo
Un servizio gestito non va bene per ogni lavoro. Il tuo codice Node.js riceve ciò che inviano le pagine tramite un webhook, una richiesta HTTP che può arrivare più di una volta, e non tramite un loop attivo su ogni connessione. Un gioco o un sistema di controllo in cui il tuo processo deve rispondere a ogni messaggio entro pochi millisecondi va su un proprio server. Lo stesso vale per un protocollo tutto tuo che altri programmi parlano su un websocket puro. E a un piccolo strumento con un solo processo e qualche centinaio di persone potrebbero non servire mai più delle quindici righe all’inizio di questo articolo.
Parti dalla guida
La guida per Express contiene tutta la configurazione, e la demo per Express è un piccolo negozio costruito su di essa, dove un ordine passa a spedito in un’altra finestra mentre fai clic. Lo stesso elenco ha un aspetto un po’ diverso in Python, dove FastAPI se lo ritrova oltre un solo worker.
WordPlus Cloud for Apps ha un prezzo in base alle connessioni simultanee, a partire da 1.000, con fatturazione mensile o annuale, e il nostro articolo sui prezzi dei servizi in tempo reale spiega come funziona il conteggio a connessione. La nostra pagina sull’API WebSocket mostra stanze, presenza ed eventi in ogni stack, e i prezzi per le app riportano le cifre. Domande sulla tua integrazione? Scrivici.