Websockets in Node.js: wat er verandert met meer dan één server

Node.js kan websockets goed vasthouden: één proces houdt elke verbinding open op één event loop, en een server die elk bericht doorgeeft aan iedereen die verbonden is, telt met de bibliotheek ws ongeveer vijftien regels. Met meer dan één proces of server kent elk alleen zijn eigen verbindingen, dus moet elk event door een kanaal dat ze delen, en inloggen, herstarts en proxy’s vragen elk om een eigen antwoord.
In dit artikel lees je hoe die kleine server eruitziet, wat het tweede proces verandert, wat het vraagt om meerdere servers te draaien, en hoe je vanuit Node.js events verstuurt zonder überhaupt een websocketserver te draaien.
Een websocketserver in Node.js
Een websocket is een verbinding in twee richtingen tussen een browser en een server die open blijft, zodat beide kanten op elk moment kunnen versturen. Node.js heeft sinds versie 22 een websocketclient ingebouwd, dezelfde WebSocket die een browser heeft. Een server is een ander verhaal: de Node.js-handleiding over websockets zegt dat je voor het aannemen van verbindingen nog altijd een bibliotheek nodig hebt. De gebruikelijke is 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 } );
}
}
} );
} );Een pagina maakt verbinding met de WebSocket API die elke browser heeft:
const socket = new WebSocket( 'ws://localhost:8080' );
socket.onopen = () => socket.send( 'hello' );
socket.onmessage = ( event ) => console.log( event.data );Start hem met node server.mjs, open die pagina in twee tabbladen, en elk tabblad print wat het andere verstuurt. Draait de server op een openbaar adres, dan maakt onze WebSocket-test er vanuit een browser verbinding mee en legt elke sluitcode uit. Meldt de browser alleen dat de verbinding mislukt is, dan laat ons artikel over WebSocket-fout 1006 zien hoe je de oorzaak vindt.
Twee dingen in die server bepalen alles wat volgt. Elke verbinding blijft open zolang de pagina openstaat, vaak urenlang. En wss.clients leeft in het geheugen van dit ene proces.
Waarom je met één proces ver komt
Node.js is gebouwd voor verbindingen die wachten. De event loop handelt er veel tegelijk af, en een verbinding die niets te zeggen heeft, kost geen thread en geen worker. Dat is het omgekeerde van PHP en van Python op WSGI, waar een open verbinding een hele worker bezighoudt.
De grenzen liggen ergens anders. Je JavaScript draait op één thread, dus een proces gebruikt één core van de CPU, en één proces op één machine is één ding dat kan uitvallen. Voor meer cores start je meer processen, met de cluster-module of een procesmanager. Voor een machine die kan uitvallen, start je een tweede server. Beide brengen dezelfde verandering mee.
Wat het tweede proces verandert
Met de cluster-module neemt het primaire proces elke nieuwe verbinding aan en geeft die om de beurt aan een van de workers. Elke worker draait de server hierboven, elk met een eigen wss.clients. Een bericht dat bij worker 1 binnenkomt, gaat naar de browsers van worker 1, en de browsers van worker 2 horen er nooit van.
Op je laptop zie je dat als twee tabbladen die elkaar soms wel en soms niet zien, afhankelijk van waar elk is terechtgekomen. De Node.js-documentatie zegt het in één zin: Node.js levert geen routeringslogica. Daarna raadt ze af om te leunen op objecten in het geheugen, en een verzameling open verbindingen is precies dat.
De oplossing is een kanaal dat alle processen delen, meestal Redis. Elk proces publiceert wat het binnenkrijgt, en bezorgt aan zijn eigen browsers wat welk proces dan ook heeft gepubliceerd:
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() ) );
} );Dat is het hele idee, en het geldt net zo goed voor twee processen op één machine als voor twintig servers. Let wel op wat het openlaat. Redis pub/sub bezorgt hooguit één keer, dus een proces dat op dat moment opnieuw verbinding maakte met Redis, krijgt het event nooit, en een browser die op dat moment opnieuw verbinding maakte met jou ook niet.
Wat meerdere servers vragen
Het gedeelde kanaal is het eerste punt. De rest van de lijst komt mee met de load balancer:
- Een proxy die is ingesteld op de upgrade. Een websocket begint als een HTTP-verzoek dat om een upgrade vraagt. De nginx-documentatie legt uit dat een proxy de headers
UpgradeenConnectionniet uit zichzelf doorgeeft, dus je stelt ze allebei met de hand in, en dat een verbinding via de proxy waar 60 seconden geen data over gaat, standaard wordt gesloten. - Een heartbeat. Daarom pingt de server elke verbinding op een timer. Zo sluiten proxy’s een stille verbinding niet, en zo vind je de verbindingen die zijn weggevallen zonder het te melden. De README van ws heeft het patroon: markeer elke socket, ping hem, en beëindig de sockets die bij de volgende ronde niet hebben geantwoord.
- Weten wie er verbinding maakt. De
WebSocketvan een browser neemt een adres en subprotocollen aan, zonder manier om een header mee te geven. Dus leest de server de sessiecookie, of een kortlevend token in het adres, uit in hetupgrade-event van de HTTP-server, voordat de verbinding bestaat. Daar controleert hij ook de headerOrigin, want een pagina op elke andere site kan een websocket naar je server openen, en de standaard laat het weigeren aan jou over. - Sticky sessions, soms. Een gewone websocket is één verbinding, en die blijft op de server waar hij terechtkwam. Een bibliotheek die kan terugvallen op HTTP long polling, doet meerdere verzoeken voor één sessie, en die moeten allemaal hetzelfde proces bereiken, dus de load balancer moet elke browser aan één proces vastzetten.
- Deploys. Een herstart verbreekt elke verbinding van dat proces. De
WebSocketvan een browser maakt niet uit zichzelf opnieuw verbinding, dus doet de code van je pagina dat, na een wachttijd die oploopt en per browser verschilt, want anders komen ze allemaal in dezelfde seconde terug. Wat er is verstuurd terwijl een pagina weg was, is verdwenen, tenzij je recente events bewaart en ze opnieuw afspeelt vanaf het laatste dat de pagina zag. - Trage lezers.
send()keert meteen terug, en wat een trage verbinding nog niet heeft afgenomen, wacht in het geheugen van je proces.bufferedAmountzegt hoeveel dat is, zodat de server een verbinding die te ver achterloopt kan overslaan of sluiten.
Niets hiervan is ongewoon, en genoeg teams doen het goed. Toch is het een tweede systeem naast je app, met een eigen Redis, eigen proxyregels en eigen slechte dagen.
Of draai helemaal geen websocketserver
Een gehoste realtime dienst haalt de verbindingen weg van je servers. De browsers maken verbinding met de dienst. Je Node.js-code verstuurt elk event in één kort HTTPS-verzoek, vanuit het proces of de server die de wijziging afhandelde, welke dat ook is, en de dienst bezorgt het aan elke pagina die het moet krijgen. In je processen leeft geen enkele verbinding, dus hoeveel je er draait, doet er niet meer toe.
| Opzet | Waar elke verbinding leeft | Wat je toevoegt |
|---|---|---|
| Eén proces | In zijn geheugen | Niets |
| Meerdere processen of servers | In elk ervan | Een gedeeld kanaal, regels voor de proxy, heartbeats, opnieuw afspelen |
| Een gehoste dienst | Op zijn servers | Eén verzoek per event |
Node.js op WordPlus Cloud
Met WordPlus Cloud is één package beide helften, de server en de pagina:
npm install @wordplus/realtimeJe server legt zijn ruimtes één keer vast, elk met een regel voor wie erin mag, en voegt één router toe. Dit is Express, met de gebruiker uit de sessie:
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 } );
} );De pagina neemt via je bundler deel aan de ruimte, met de sleutel van je eigen app in plaats van deze:
import { connect } from '@wordplus/realtime';
const rt = await connect( { app: 's1500000007' } );
const order = rt.join( 'order:1042' );
order.on( 'updated', ( data ) => showStatus( data.status ) );Die emit is één HTTPS-verzoek, dus hij werkt hetzelfde in één proces, in acht cluster-workers en in een serverless functie. En daarnaast:
- Niets te delen tussen je servers. Je servers bewaren niets van realtime, dus elke server beantwoordt elk verzoek en verstuurt naar elke ruimte.
- Niets kwijt bij opnieuw verbinden. Een ruimte bewaart de laatste events, dus een pagina die terugkomt, krijgt wat ze gemist heeft, in de juiste volgorde.
- Elke pagina van één gebruiker.
realtime.toUser( 42 ).emit( 'notice', { text: 'Your order shipped' } )bereikt elk tabblad en apparaat dat hij open heeft. Een gebruiker met niets open krijgt niets, dus stuur een e-mail voor wat hem moet bereiken. - Eén verbinding voor alle tabbladen. De tabbladen van een browser delen één verbinding, zodat iemand met drie tabbladen open maar één keer telt.
- Verzegeld onderweg. Wat je server verstuurt naar een ruimte met een regel, reist versleuteld met sleutels die alleen je server en je gebruikers hebben.
- Meer dan events. Wie er online is, gesprekken die in elk tabblad overgaan, groepsgesprekken en livestreams lopen over dezelfde verbinding, met een kant-en-klaar belscherm, chat en speler van Better Messages, of je eigen interface op dezelfde API.
Hetzelfde package werkt ook zonder Express, in een kale Node.js-server, Fastify of Hono. Voor Next.js is websockets op serverless hosting een artikel apart.
Wanneer je eigen server beter past
Een gehoste dienst past niet bij elke klus. Je Node.js-code hoort wat pagina’s versturen via een webhook, een HTTP-verzoek dat meer dan eens kan aankomen, en niet via een live loop met elke verbinding. Een game of een regelsysteem waarin je proces elk bericht binnen milliseconden moet beantwoorden, hoort op een eigen server. Dat geldt ook voor een eigen protocol dat andere programma’s over een gewone websocket spreken. En een kleine tool met één proces en een paar honderd mensen heeft misschien nooit meer nodig dan de vijftien regels bovenaan dit artikel.
Begin met de handleiding
De Express-handleiding beschrijft de hele installatie, en de Express-demo is een kleine webwinkel die erop is gebouwd, waar een bestelling in een ander venster de status verzonden krijgt terwijl je klikt. Dezelfde lijst ziet er in Python iets anders uit, waar FastAPI hem tegenkomt met meer dan één worker.
WordPlus Cloud for Apps is geprijsd op gelijktijdige verbindingen, vanaf 1.000, maandelijks of jaarlijks gefactureerd, en ons artikel over prijzen voor realtime legt uit hoe tellen per verbinding werkt. Onze pagina over de WebSocket-API toont ruimtes, aanwezigheid en events in elke stack, en bij de prijzen voor apps vind je de cijfers. Vragen over je integratie? Schrijf ons.