WebSockets in Node.js: was sich ab dem zweiten Server ändert

Node.js kommt mit WebSockets gut zurecht: Ein Prozess hält jede Verbindung in einem einzigen Event Loop offen, und ein Server, der jede Nachricht an alle weitergibt, die verbunden sind, ist mit der Bibliothek ws etwa fünfzehn Zeilen lang. Ab dem zweiten Prozess oder Server kennt jeder nur seine eigenen Verbindungen, also muss jedes Event durch einen Kanal laufen, den sich alle teilen, und Anmeldung, Neustarts und Proxys brauchen jeweils eine eigene Antwort.
Dieser Beitrag zeigt diesen kleinen Server, was der zweite Prozess ändert, was der Betrieb mehrerer Server verlangt und wie Sie aus Node.js Events senden, ganz ohne WebSocket-Server.
Ein WebSocket-Server in Node.js
Ein WebSocket ist eine Verbindung in beide Richtungen zwischen einem Browser und einem Server, die offen bleibt, sodass jede Seite jederzeit senden kann. Node.js hat seit Version 22 einen WebSocket-Client eingebaut, denselben WebSocket, den ein Browser hat. Ein Server ist eine andere Sache: Die Node.js-Anleitung zu WebSockets sagt, dass es für das Annehmen von Verbindungen weiterhin eine Bibliothek braucht. Die übliche ist 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 } );
}
}
} );
} );Eine Seite verbindet sich über die WebSocket-API, die jeder Browser hat:
const socket = new WebSocket( 'ws://localhost:8080' );
socket.onopen = () => socket.send( 'hello' );
socket.onmessage = ( event ) => console.log( event.data );Starten Sie den Server mit node server.mjs, öffnen Sie diese Seite in zwei Tabs, und jeder gibt aus, was der andere sendet. Läuft er auf einer öffentlichen Adresse, verbindet sich unser WebSocket-Test aus einem Browser damit und erklärt jeden Close-Code. Meldet der Browser nur, dass die Verbindung fehlgeschlagen ist, zeigt unser Beitrag zum WebSocket-Fehler 1006, wie Sie die Ursache finden.
Zwei Dinge in diesem Server bestimmen alles, was folgt. Jede Verbindung bleibt so lange offen wie ihre Seite, oft stundenlang. Und wss.clients lebt im Speicher dieses einen Prozesses.
Warum ein Prozess weit reicht
Node.js wurde für Verbindungen gebaut, die warten. Sein Event Loop bedient viele davon gleichzeitig, und eine Verbindung, die nichts zu sagen hat, kostet ihn weder einen Thread noch einen Worker. Das ist das Gegenteil von PHP und von Python auf WSGI, wo eine offene Verbindung einen ganzen Worker beschäftigt hält.
Die Grenzen liegen woanders. Ihr JavaScript läuft in einem einzigen Thread, also nutzt ein Prozess einen Kern der CPU, und ein Prozess auf einer Maschine ist eine einzige Stelle, die ausfallen kann. Für mehr Kerne starten Sie mehr Prozesse, mit dem Cluster-Modul oder einem Prozessmanager. Für eine Maschine, die ausfallen kann, starten Sie einen zweiten Server. Beides bringt dieselbe Änderung mit sich.
Was der zweite Prozess ändert
Mit dem Cluster-Modul nimmt der primäre Prozess jede neue Verbindung an und gibt sie reihum an einen der Worker weiter. Jeder Worker führt den Server von oben aus, jeder mit einem eigenen wss.clients. Eine Nachricht, die in Worker 1 ankommt, geht an die Browser von Worker 1, und die Browser von Worker 2 erfahren nie davon.
Auf Ihrem Laptop zeigt sich das an zwei Tabs, die einander nur manchmal sehen, je nachdem, wo jeder gelandet ist. Die Node.js-Dokumentation sagt es in einer Zeile: Node.js bringt keine Routing-Logik mit. Sie rät außerdem davon ab, sich auf Objekte im Speicher zu verlassen, und ein Set offener Verbindungen ist genau das.
Die Lösung ist ein Kanal, den sich alle Prozesse teilen, meist Redis. Jeder Prozess veröffentlicht, was er bekommt, und stellt seinen eigenen Browsern zu, was irgendein Prozess veröffentlicht hat:
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() ) );
} );Das ist die ganze Idee, und sie gilt für zwei Prozesse auf einer Maschine genauso wie für zwanzig Server. Beachten Sie, was sie offen lässt. Redis Pub/Sub stellt höchstens einmal zu, sodass ein Prozess, der sich in diesem Moment gerade neu mit Redis verbindet, das Event nie bekommt, und ein Browser, der sich gerade neu mit Ihnen verbindet, ebenso wenig.
Was mehrere Server verlangen
Der gemeinsame Kanal ist der erste Punkt. Der Rest der Liste kommt mit dem Load Balancer:
- Ein Proxy, der für das Upgrade eingerichtet ist. Ein WebSocket beginnt als HTTP-Anfrage, die um ein Upgrade bittet. Die nginx-Dokumentation erklärt, dass ein Proxy die Header
UpgradeundConnectionnicht von selbst weiterreicht, sodass beide von Hand gesetzt werden, und dass eine Verbindung über den Proxy, auf der 60 Sekunden lang keine Daten fließen, standardmäßig geschlossen wird. - Ein Heartbeat. Deshalb sendet der Server in festen Abständen einen Ping an jede Verbindung. Das hält Proxys davon ab, eine stille Verbindung zu schließen, und es findet die Verbindungen, die abgebrochen sind, ohne sich abzumelden. Die README von ws zeigt das Muster: jeden Socket markieren, ihm einen Ping senden und die beenden, die bis zur nächsten Runde nicht geantwortet haben.
- Wissen, wer sich verbindet. Der
WebSocketeines Browsers nimmt eine Adresse und Subprotokolle an, und ein Header lässt sich nicht setzen. Also liest der Server imupgrade-Event des HTTP-Servers das Session-Cookie oder ein kurzlebiges Token in der Adresse, bevor die Verbindung besteht. Dort prüft er auch denOrigin-Header, denn eine Seite auf jeder anderen Website kann einen WebSocket zu Ihrem Server öffnen, und der Standard überlässt es Ihnen, sie abzulehnen. - Sticky Sessions, manchmal. Ein einfacher WebSocket ist eine einzige Verbindung, und sie bleibt bei dem Server, den sie erreicht hat. Eine Bibliothek, die auf HTTP Long Polling zurückfallen kann, stellt für eine Session mehrere Anfragen, und alle müssen denselben Prozess erreichen, also muss der Load Balancer jeden Browser an einen Prozess binden.
- Deploys. Ein Neustart trennt jede Verbindung dieses Prozesses. Der
WebSocketeines Browsers verbindet sich nicht von selbst neu, also tut es der Code Ihrer Seite, nach einer Wartezeit, die wächst und für jeden Browser anders ist, sonst kommen alle in derselben Sekunde zurück. Was gesendet wurde, während eine Seite weg war, ist verloren, es sei denn, Sie heben die letzten Events auf und spielen sie ab dem letzten, das die Seite gesehen hat, erneut ab. - Langsame Empfänger.
send()kehrt sofort zurück, und was eine langsame Verbindung noch nicht abgenommen hat, wartet im Speicher Ihres Prozesses.bufferedAmountsagt, wie viel das ist, sodass der Server eine Verbindung, die zu weit zurückliegt, überspringen oder schließen kann.
Nichts davon ist ungewöhnlich, und viele Teams machen das gut. Trotzdem ist es ein zweites System neben Ihrer App, mit eigenem Redis, eigenen Proxy-Regeln und eigenen schlechten Tagen.
Oder Sie betreiben gar keinen WebSocket-Server
Ein gehosteter Echtzeit-Dienst nimmt Ihren Servern die Verbindungen ab. Die Browser verbinden sich mit dem Dienst. Ihr Node.js-Code sendet jedes Event in einer kurzen HTTPS-Anfrage, ganz gleich, welcher Prozess oder Server die Änderung bearbeitet hat, und der Dienst stellt es jeder Seite zu, die es bekommen soll. In Ihren Prozessen lebt keine Verbindung mehr, also spielt es keine Rolle mehr, wie viele davon Sie betreiben.
| Aufbau | Wo jede Verbindung lebt | Was Sie hinzufügen |
|---|---|---|
| Ein Prozess | In seinem Speicher | Nichts |
| Mehrere Prozesse oder Server | In einem von ihnen | Einen gemeinsamen Kanal, Proxy-Regeln, Heartbeats, Replay |
| Ein gehosteter Dienst | Auf seinen Servern | Eine Anfrage für jedes Event |
Node.js auf WordPlus Cloud
Mit WordPlus Cloud liefert ein einziges Paket beide Hälften, den Server und die Seite:
npm install @wordplus/realtimeIhr Server legt seine Räume einmal fest, jeweils mit einer Regel dafür, wer beitreten darf, und bindet einen einzigen Router ein. Hier ist es Express, mit dem Nutzer aus der 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 } );
} );Die Seite tritt dem Raum über Ihren Bundler bei, mit dem Schlüssel Ihrer App anstelle von diesem:
import { connect } from '@wordplus/realtime';
const rt = await connect( { app: 's1500000007' } );
const order = rt.join( 'order:1042' );
order.on( 'updated', ( data ) => showStatus( data.status ) );Dieses emit ist eine HTTPS-Anfrage, also läuft es in einem Prozess genauso wie in acht Cluster-Workern und in einer Serverless-Funktion. Darüber hinaus:
- Zwischen Ihren Servern ist nichts zu teilen. Auf ihnen liegt kein Echtzeit-Zustand, sodass jeder von ihnen jede Anfrage beantwortet und an jeden Raum sendet.
- Nichts geht bei einer Neuverbindung verloren. Ein Raum bewahrt seine letzten Events auf, sodass eine Seite, die zurückkommt, bekommt, was sie verpasst hat, in der richtigen Reihenfolge.
- Jede Seite eines Nutzers.
realtime.toUser( 42 ).emit( 'notice', { text: 'Your order shipped' } )erreicht alle Tabs und Geräte, die dieser Nutzer offen hat. Ein Nutzer, der nichts offen hat, bekommt nichts, also senden Sie für das, was ihn unbedingt erreichen muss, eine E-Mail. - Eine Verbindung für alle Tabs. Die Tabs eines Browsers teilen sich eine Verbindung, sodass eine Person mit drei offenen Tabs einmal zählt.
- Unterwegs versiegelt. Was Ihr Server an einen Raum mit einer Regel sendet, wird verschlüsselt übertragen, mit Schlüsseln, die nur Ihr Server und Ihre Nutzer haben.
- Mehr als Events. Online-Status, Anrufe, die in jedem Tab klingeln, Gruppenanrufe und Livestreams laufen über dieselbe Verbindung, mit fertigem Anrufbildschirm, Chat und Player aus Better Messages oder mit Ihrer eigenen Oberfläche auf derselben API.
Dasselbe Paket läuft auch ohne Express, in einem einfachen Node.js-Server, in Fastify oder Hono. Für Next.js ist WebSockets auf Serverless-Hosting ein eigener Beitrag.
Wann ein eigener Server besser passt
Ein gehosteter Dienst passt nicht für jede Aufgabe. Ihr Node.js-Code erfährt über einen Webhook, was Seiten senden, also über eine HTTP-Anfrage, die mehr als einmal ankommen kann, und nicht über eine Live-Schleife mit jeder Verbindung. Ein Spiel oder ein Steuerungssystem, bei dem Ihr Prozess jede Nachricht innerhalb von Millisekunden beantworten muss, gehört auf einen eigenen Server. Dasselbe gilt für ein eigenes Protokoll, das andere Programme über einen einfachen WebSocket sprechen. Und ein kleines Tool mit einem Prozess und ein paar hundert Personen braucht vielleicht nie mehr als die fünfzehn Zeilen am Anfang dieses Beitrags.
Beginnen Sie mit der Anleitung
Die Express-Anleitung enthält die ganze Einrichtung, und die Express-Demo ist ein kleiner Shop, der darauf aufbaut und in dem eine Bestellung in einem anderen Fenster auf „versendet“ wechselt, während Sie klicken. In Python sieht dieselbe Liste etwas anders aus, dort begegnet FastAPI ihr mit mehr als einem Worker.
Für WordPlus Cloud for Apps gelten Preise nach gleichzeitigen Verbindungen, ab 1.000, monatlich oder jährlich abgerechnet, und unser Beitrag zu Echtzeit-Preisen erklärt, wie das Zählen nach Verbindungen funktioniert. Unsere Seite zur WebSocket-API zeigt Räume, Präsenz und Ereignisse in jedem Stack, und die Preise für Apps nennen die Beträge. Fragen zu Ihrer Integration? Schreiben Sie uns.