Websockety w Node.js: co zmienia więcej niż jeden serwer

Node.js dobrze radzi sobie z websocketami: jeden proces utrzymuje każde połączenie otwarte na jednym event loopie, a serwer, który przekazuje każdą wiadomość wszystkim połączonym, to mniej więcej piętnaście linijek z biblioteką ws. Przy więcej niż jednym procesie albo serwerze każdy z nich zna tylko własne połączenia, więc każde zdarzenie musi przejść przez wspólny dla nich kanał, a logowanie, restarty i proxy wymagają każde osobnego rozwiązania.
Ten wpis pokazuje ten mały serwer, wyjaśnia, co zmienia drugi proces i czego wymaga działanie na kilku serwerach, a na koniec pokazuje, jak wysyłać zdarzenia z Node.js w ogóle bez serwera websocket.
Serwer websocket w Node.js
Websocket to dwukierunkowe połączenie między przeglądarką a serwerem, które pozostaje otwarte, więc każda ze stron może wysyłać w dowolnej chwili. Node.js ma od wersji 22 wbudowanego klienta websocket, ten sam WebSocket, który ma przeglądarka. Serwer to inna sprawa: przewodnik Node.js o websocketach podaje, że do przyjmowania połączeń wciąż potrzebna jest biblioteka. Zwykle jest nią 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 } );
}
}
} );
} );Strona łączy się przez WebSocket API, które ma każda przeglądarka:
const socket = new WebSocket( 'ws://localhost:8080' );
socket.onopen = () => socket.send( 'hello' );
socket.onmessage = ( event ) => console.log( event.data );Uruchom go przez node server.mjs, otwórz tę stronę w dwóch kartach, a każda wypisze to, co wysyła druga. Gdy serwer działa już pod publicznym adresem, nasz Test WebSocket połączy się z nim z przeglądarki i wyjaśni każdy kod zamknięcia. Jeśli przeglądarka zgłasza tylko, że połączenie się nie powiodło, nasz artykuł o błędzie WebSocket 1006 pokazuje, jak znaleźć przyczynę.
Dwie rzeczy w tym serwerze przesądzają o wszystkim, co dalej. Każde połączenie pozostaje otwarte tak długo, jak jego strona, często godzinami. A wss.clients żyje w pamięci tego jednego procesu.
Dlaczego jeden proces wystarcza na długo
Node.js powstał z myślą o połączeniach, które czekają. Jego event loop obsługuje wiele z nich naraz, a połączenie, które nie ma nic do powiedzenia, nie kosztuje go ani wątku, ani workera. To odwrotność PHP i Pythona na WSGI, gdzie otwarte połączenie zajmuje całego workera.
Ograniczenia są gdzie indziej. Twój JavaScript działa w jednym wątku, więc proces korzysta z jednego rdzenia procesora, a jeden proces na jednej maszynie to jedna rzecz, która może zawieść. Żeby wykorzystać więcej rdzeni, uruchamiasz więcej procesów, przez moduł cluster albo menedżer procesów. Na wypadek awarii maszyny uruchamiasz drugi serwer. Jedno i drugie przynosi tę samą zmianę.
Co zmienia drugi proces
Z modułem cluster proces główny przyjmuje każde nowe połączenie i przekazuje je po kolei jednemu z workerów. Każdy worker uruchamia powyższy serwer, każdy z własnym wss.clients. Wiadomość, która trafia do workera 1, idzie do przeglądarek workera 1, a przeglądarki workera 2 nigdy się o niej nie dowiadują.
Na laptopie wygląda to tak, że dwie karty widzą się nawzajem tylko czasami, zależnie od tego, gdzie każda trafiła. Dokumentacja Node.js mówi w jednym zdaniu, że Node.js nie zapewnia logiki routingu. Dalej odradza opieranie się na obiektach w pamięci, a zbiór otwartych połączeń jest właśnie czymś takim.
Rozwiązaniem jest kanał wspólny dla wszystkich procesów, zwykle Redis. Każdy proces publikuje to, co dostaje, i dostarcza swoim przeglądarkom to, co opublikował dowolny proces:
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() ) );
} );To cały pomysł i działa on tak samo dla dwóch procesów na jednej maszynie, jak i dla dwudziestu serwerów. Zwróć uwagę na to, czego nie załatwia. Redis pub/sub dostarcza najwyżej raz, więc proces, który akurat w tej chwili łączył się ponownie z Redisem, nigdy nie dostanie zdarzenia, podobnie jak przeglądarka, która właśnie łączyła się ponownie z Tobą.
Czego wymaga kilka serwerów
Wspólny kanał to pierwsza pozycja. Reszta listy pojawia się razem z load balancerem:
- Proxy skonfigurowane pod upgrade. Websocket zaczyna się jako żądanie HTTP, które prosi o upgrade. Dokumentacja nginx wyjaśnia, że proxy samo nie przekazuje dalej nagłówków
UpgradeiConnection, więc oba ustawia się ręcznie, i że połączenie przez proxy, w którym przez 60 sekund nie ma danych, jest domyślnie zamykane. - Heartbeat. Serwer wysyła więc ping do każdego połączenia w stałych odstępach. Dzięki temu proxy nie zamykają cichych połączeń, a serwer znajduje te, które umarły bez słowa. README biblioteki ws pokazuje wzorzec: oznacz każdy socket, wyślij mu ping i zakończ te, które nie odpowiedziały do następnej rundy.
- Rozpoznanie, kto się łączy.
WebSocketw przeglądarce przyjmuje adres i podprotokoły, bez możliwości ustawienia nagłówka. Serwer odczytuje więc plik cookie sesji albo krótkotrwały token w adresie w zdarzeniuupgradeserwera HTTP, zanim połączenie w ogóle powstanie. Sprawdza tam też nagłówekOrigin, bo strona w dowolnej innej witrynie może otworzyć websocket do Twojego serwera, a standard zostawia odmowę Tobie. - Sticky sessions, czasami. Zwykły websocket to jedno połączenie i zostaje na serwerze, do którego trafił. Biblioteka, która potrafi przejść awaryjnie na HTTP long polling, wykonuje kilka żądań w ramach jednej sesji i wszystkie muszą trafić do tego samego procesu, więc load balancer musi przypiąć każdą przeglądarkę do jednego.
- Deploye. Restart zrywa każde połączenie tego procesu.
WebSocketw przeglądarce sam nie łączy się ponownie, więc robi to kod Twojej strony, po opóźnieniu, które rośnie i jest inne dla każdej przeglądarki, bo inaczej wszystkie wrócą w tej samej sekundzie. To, co wysłano, gdy strona była rozłączona, przepada, chyba że przechowujesz ostatnie zdarzenia i odtwarzasz je od ostatniego, które widziała. - Wolni odbiorcy.
send()wraca od razu, a to, czego wolne połączenie jeszcze nie odebrało, czeka w pamięci Twojego procesu.bufferedAmountmówi, ile tego jest, więc serwer może pominąć albo zamknąć połączenie, które zostało zbyt daleko w tyle.
Nic z tego nie jest niezwykłe i wiele zespołów robi to dobrze. Mimo to jest to drugi system obok Twojej aplikacji, z własnym Redisem, własnymi regułami proxy i własnymi złymi dniami.
Albo w ogóle nie utrzymuj serwera websocket
Hostowana usługa czasu rzeczywistego przejmuje połączenia od Twoich serwerów. Przeglądarki łączą się z usługą. Twój kod Node.js wysyła każde zdarzenie jednym krótkim żądaniem HTTPS, z tego procesu albo serwera, który obsłużył zmianę, a usługa dostarcza je każdej stronie, która powinna je dostać. W Twoich procesach nie żyje żadne połączenie, więc to, ile ich uruchamiasz, przestaje mieć znaczenie.
| Konfiguracja | Gdzie żyją połączenia | Co dodajesz |
|---|---|---|
| Jeden proces | W jego pamięci | Nic |
| Kilka procesów lub serwerów | W każdym z nich | Wspólny kanał, reguły proxy, heartbeat, odtwarzanie |
| Hostowana usługa | Na jej serwerach | Jedno żądanie na każde zdarzenie |
Node.js w WordPlus Cloud
Z WordPlus Cloud jeden pakiet obejmuje obie połowy, serwer i stronę:
npm install @wordplus/realtimeTwój serwer raz deklaruje swoje pokoje, każdy z regułą określającą, kto może do niego dołączyć, i montuje jeden router. To Express, z użytkownikiem branym z sesji:
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 } );
} );Strona dołącza do pokoju przez Twój bundler, z kluczem Twojej aplikacji w miejscu tego poniżej:
import { connect } from '@wordplus/realtime';
const rt = await connect( { app: 's1500000007' } );
const order = rt.join( 'order:1042' );
order.on( 'updated', ( data ) => showStatus( data.status ) );To emit to jedno żądanie HTTPS, więc działa tak samo w jednym procesie, w ośmiu workerach modułu cluster i w funkcji serverless. A do tego:
- Nic do dzielenia między Twoimi serwerami. Nie przechowują one niczego, co dotyczy czasu rzeczywistego, więc dowolny z nich odpowiada na dowolne żądanie i wysyła do dowolnego pokoju.
- Nic nie ginie przy ponownym połączeniu. Pokój przechowuje swoje ostatnie zdarzenia, więc strona, która wraca, dostaje to, co ją ominęło, w odpowiedniej kolejności.
- Każda strona jednego użytkownika.
realtime.toUser( 42 ).emit( 'notice', { text: 'Your order shipped' } )dociera do wszystkich kart i urządzeń, które ten użytkownik ma otwarte. Użytkownik, który nie ma nic otwartego, nie dostanie nic, więc to, co musi do niego dotrzeć, wyślij e-mailem. - Jedno połączenie dla wszystkich kart. Karty jednej przeglądarki dzielą jedno połączenie, więc osoba z trzema otwartymi kartami jest liczona tylko raz.
- Zapieczętowane w drodze. To, co Twój serwer wysyła do pokoju z regułą, podróżuje zaszyfrowane kluczami, które mają tylko Twój serwer i Twoi użytkownicy.
- Więcej niż zdarzenia. Informacja, kto jest online, rozmowy, które dzwonią w każdej karcie, rozmowy grupowe i transmisje na żywo działają przez to samo połączenie, z gotowym ekranem rozmowy, czatem i odtwarzaczem z Better Messages albo z Twoim własnym interfejsem na tym samym API.
Ten sam pakiet działa też bez Expressa, w czystym serwerze Node.js, w Fastify albo w Hono. Dla Next.js jest osobny wpis o websocketach na hostingu serverless.
Kiedy własny serwer sprawdzi się lepiej
Hostowana usługa nie nadaje się do każdego zadania. Twój kod Node.js dowiaduje się, co wysyłają strony, przez webhook, czyli żądanie HTTP, które może dotrzeć więcej niż raz, a nie przez pętlę na żywo z każdym połączeniem. Miejsce gry albo systemu sterowania, w którym Twój proces musi odpowiadać na każdą wiadomość w ciągu milisekund, jest na własnym serwerze. To samo dotyczy Twojego własnego protokołu, którym inne programy rozmawiają przez zwykły websocket. A małe narzędzie z jednym procesem i kilkuset osobami może nigdy nie potrzebować niczego więcej niż piętnaście linijek z początku tego wpisu.
Zacznij od przewodnika
Przewodnik dla Expressa zawiera całą konfigurację, a demo Expressa to mały sklep zbudowany na niej, w którym status zamówienia zmienia się na „wysłane” w drugim oknie w chwili, gdy klikasz. Ta sama lista wygląda trochę inaczej w Pythonie, gdzie FastAPI trafia na nią przy więcej niż jednym workerze.
WordPlus Cloud for Apps ma cenę według jednoczesnych połączeń, od 1000 wzwyż, rozliczaną miesięcznie lub rocznie, a nasz wpis o cenach usług czasu rzeczywistego wyjaśnia, jak działa liczenie według połączeń. Nasza strona o API WebSocket pokazuje pokoje, obecność i zdarzenia w każdym stacku, a cennik dla aplikacji podaje liczby. Chcesz zapytać o swoją integrację? Napisz do nas.