חיבורי websocket ב-Node.js: מה משתנה מעבר לשרת אחד

Node.js מחזיק חיבורי websocket היטב: תהליך אחד שומר כל חיבור פתוח על event loop יחיד, ושרת שמעביר כל הודעה לכל מי שמחובר הוא כחמש עשרה שורות עם הספרייה ws. מעבר לתהליך אחד או לשרת אחד, כל אחד מהם מכיר רק את החיבורים שלו, ולכן כל event צריך לעבור בערוץ שכולם חולקים, וההתחברות של משתמשים, ההפעלות מחדש וה-proxies דורשים כל אחד תשובה משלו.
הפוסט הזה מציג את השרת הקטן הזה, מה משנה התהליך השני, מה נדרש כדי להריץ כמה שרתים, ואיך לשלוח events מ-Node.js בלי שרת websocket בכלל.
שרת websocket ב-Node.js
websocket הוא חיבור דו-כיווני בין דפדפן לשרת שנשאר פתוח, כך שכל צד יכול לשלוח בכל רגע. ב-Node.js יש לקוח websocket מובנה מאז גרסה 22, אותו WebSocket שיש בדפדפן. שרת הוא עניין אחר: המדריך של Node.js ל-websocket אומר שכדי לקבל חיבורים עדיין צריך ספרייה. המקובלת היא 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 } );
}
}
} );
} );דף מתחבר דרך ה-API של WebSocket שיש בכל דפדפן:
const socket = new WebSocket( 'ws://localhost:8080' );
socket.onopen = () => socket.send( 'hello' );
socket.onmessage = ( event ) => console.log( event.data );הפעילו אותו עם node server.mjs, פתחו את הדף הזה בשתי לשוניות, וכל אחת מדפיסה את מה שהשנייה שולחת. אחרי שהשרת רץ בכתובת ציבורית, בדיקת WebSocket שלנו מתחברת אליו מדפדפן ומסבירה כל קוד סגירה. אם הדפדפן מדווח רק שהחיבור נכשל, הפוסט שלנו על שגיאת WebSocket 1006 מראה איך למצוא את הסיבה.
שני דברים בשרת הזה קובעים את כל מה שבא אחר כך. כל חיבור נשאר פתוח כל עוד הדף שלו פתוח, ולעיתים קרובות מדובר בשעות. ו-wss.clients חי בזיכרון של התהליך הזה בלבד.
למה תהליך אחד מספיק להרבה
Node.js נבנה לחיבורים שמחכים. ה-event loop שלו מטפל בהרבה מהם בבת אחת, וחיבור שאין לו מה לומר לא תופס אצלו thread ולא worker. זה ההפך מ-PHP ומ-Python על WSGI, שם חיבור פתוח מעסיק worker שלם.
המגבלות נמצאות במקום אחר. ה-JavaScript שלכם רץ על thread אחד, ולכן תהליך משתמש בליבה אחת של ה-CPU, ותהליך אחד על מכונה אחת הוא נקודה אחת שיכולה ליפול. כדי לקבל יותר ליבות אתם מפעילים יותר תהליכים, עם המודול cluster או עם מנהל תהליכים. כדי לא להיות תלויים במכונה אחת שיכולה ליפול, אתם מפעילים שרת שני. שני הצעדים מביאים את אותו שינוי.
מה משנה התהליך השני
עם המודול cluster, התהליך הראשי מקבל כל חיבור חדש ומעביר אותו בכל פעם ל-worker הבא בתור. כל worker מריץ את השרת שלמעלה, כל אחד עם wss.clients משלו. הודעה שמגיעה ל-worker 1 עוברת לדפדפנים של worker 1, והדפדפנים של worker 2 אף פעם לא שומעים עליה.
על המחשב הנייד שלכם זה נראה כמו שתי לשוניות שרואות זו את זו רק חלק מהזמן, תלוי איפה כל אחת נחתה. התיעוד של Node.js אומר את זה בשורה אחת: Node.js לא מספק לוגיקת ניתוב. בהמשך הוא ממליץ לא להישען על אובייקטים שבזיכרון, ואוסף של חיבורים פתוחים הוא בדיוק דבר כזה.
הפתרון הוא ערוץ שכל התהליכים חולקים, בדרך כלל Redis. כל תהליך מפרסם את מה שהוא מקבל, ומוסר לדפדפנים שלו את מה שתהליך כלשהו פרסם:
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() ) );
} );זה כל הרעיון, והוא נכון לשני תהליכים על מכונה אחת בדיוק כמו לעשרים שרתים. שימו לב למה שהוא משאיר פתוח. ה-pub/sub של Redis מוסר לכל היותר פעם אחת, כך שתהליך שבאותו רגע התחבר מחדש ל-Redis אף פעם לא מקבל את ה-event, וכך גם דפדפן שבאותו רגע התחבר מחדש אליכם.
מה נדרש כשיש כמה שרתים
הערוץ המשותף הוא הסעיף הראשון. שאר הרשימה מגיע יחד עם ה-load balancer:
- proxy שמוגדר ל-upgrade. websocket מתחיל כבקשת HTTP שמבקשת לעבור upgrade. התיעוד של nginx מסביר ש-proxy לא מעביר הלאה את ה-headers
Upgradeו-Connectionמעצמו, ולכן מגדירים את שניהם ידנית, ושחיבור דרך proxy שלא עובר בו מידע במשך 60 שניות נסגר כברירת מחדל. - heartbeat. לכן השרת שולח ping לכל חיבור לפי טיימר. כך proxies לא סוגרים חיבור שקט, וכך גם מתגלים חיבורים שמתו בלי להודיע על כך. ב-README של ws יש את התבנית: מסמנים כל socket, שולחים לו ping, ומנתקים את אלה שלא ענו עד הסבב הבא.
- לדעת מי מתחבר. ה-
WebSocketשל הדפדפן מקבל כתובת ו-subprotocols, בלי דרך להגדיר header. לכן השרת קורא את ה-cookie של ה-session, או token קצר מועד שבכתובת, ב-eventupgradeשל שרת ה-HTTP, לפני שהחיבור קיים. שם הוא בודק גם את ה-headerOrigin, כי דף בכל אתר אחר יכול לפתוח websocket לשרת שלכם, ו-התקן משאיר לכם לסרב לו. - sticky sessions, לפעמים. websocket רגיל הוא חיבור אחד, והוא נשאר על השרת שאליו הגיע. ספרייה שיכולה לרדת ל-HTTP long polling שולחת כמה בקשות ל-session אחד, וכולן חייבות להגיע לאותו תהליך, ולכן ה-load balancer חייב להצמיד כל דפדפן לתהליך אחד.
- deploys. הפעלה מחדש מנתקת כל חיבור של אותו תהליך. ה-
WebSocketשל הדפדפן לא מתחבר מחדש מעצמו, ולכן הקוד של הדף שלכם עושה את זה, אחרי השהיה שגדלה ושונה בכל דפדפן, אחרת כולם חוזרים באותה שנייה. מה שנשלח בזמן שדף לא היה מחובר אבד, אלא אם אתם שומרים את ה-events האחרונים ושולחים אותם שוב, החל מהאחרון שהדף ראה. - קוראים איטיים.
send()חוזר מיד, ומה שחיבור איטי עוד לא לקח מחכה בזיכרון של התהליך שלכם.bufferedAmountאומר כמה, כך שהשרת יכול לדלג על חיבור שנשאר רחוק מדי מאחור, או לסגור אותו.
שום דבר מזה אינו יוצא דופן, והרבה צוותים עושים את זה היטב. ועדיין זו מערכת שנייה לצד האפליקציה שלכם, עם Redis, כללי proxy וימים רעים משלה.
או לא להחזיק שרת websocket בכלל
שירות מנוהל לזמן אמת מוציא את החיבורים מהשרתים שלכם. הדפדפנים מתחברים לשירות. קוד ה-Node.js שלכם שולח כל event בבקשת HTTPS קצרה אחת, לא משנה איזה תהליך או שרת טיפל בשינוי, והשירות מוסר אותו לכל דף שצריך לקבל אותו. אף חיבור לא חי בתהליכים שלכם, ולכן כבר לא משנה כמה מהם אתם מריצים.
| הגדרה | איפה החיבורים חיים | מה מוסיפים |
|---|---|---|
| תהליך אחד | בזיכרון שלו | שום דבר |
| כמה תהליכים או שרתים | בכל אחד מהם | ערוץ משותף, כללי proxy, heartbeat, שליחה חוזרת |
| שירות מנוהל | על השרתים שלו | בקשה אחת לכל event |
Node.js על WordPlus Cloud
עם WordPlus Cloud, חבילה אחת כוללת את שני החצאים, השרת והדף:
npm install @wordplus/realtimeהשרת שלכם מגדיר את החדרים שלו פעם אחת, כל אחד עם כלל שקובע מי רשאי להצטרף, ומוסיף router אחד. כאן זה Express, והמשתמש נלקח מה-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 } );
} );הדף מצטרף לחדר דרך ה-bundler שלכם, עם המפתח של האפליקציה שלכם במקום המפתח הזה:
import { connect } from '@wordplus/realtime';
const rt = await connect( { app: 's1500000007' } );
const order = rt.join( 'order:1042' );
order.on( 'updated', ( data ) => showStatus( data.status ) );ה-emit הזה הוא בקשת HTTPS אחת, ולכן הוא רץ אותו דבר בתהליך אחד, בשמונה workers של cluster ובפונקציית serverless. ומעבר לזה:
- אין מה לשתף בין השרתים שלכם. שום דבר של זמן אמת לא נשמר עליהם, כך שכל אחד מהם עונה לכל בקשה ושולח לכל חדר.
- שום דבר לא הולך לאיבוד בהתחברות מחדש. חדר שומר את ה-events האחרונים שלו, כך שדף שחוזר מקבל את מה שפספס, לפי הסדר.
- כל הדפים של משתמש אחד.
realtime.toUser( 42 ).emit( 'notice', { text: 'Your order shipped' } )מגיע לכל לשונית ולכל מכשיר שפתוחים אצלו. משתמש שאין אצלו שום דבר פתוח לא מקבל כלום, ולכן שלחו אימייל על מה שחייב להגיע אליו. - חיבור אחד לכל הלשוניות. הלשוניות של דפדפן חולקות חיבור אחד, כך שאדם עם שלוש לשוניות פתוחות נספר פעם אחת.
- סגור לאורך הדרך. מה שהשרת שלכם שולח לחדר עם כלל עובר מוצפן, במפתחות שרק השרת שלכם והמשתמשים שלכם מחזיקים.
- יותר מ-events. מי מחובר כרגע, שיחות שמצלצלות בכל לשונית, שיחות קבוצתיות ושידורים חיים מגיעים על אותו חיבור, עם מסך שיחה, צ׳אט ונגן מוכנים מ-Better Messages, או עם ממשק משלכם על אותו API.
אותה חבילה רצה גם בלי Express, בשרת Node.js רגיל, ב-Fastify או ב-Hono. ל-Next.js יש פוסט משלו, חיבורי websocket על אחסון serverless.
מתי שרת משלכם מתאים יותר
שירות מנוהל לא מתאים לכל משימה. הקוד שלכם ב-Node.js שומע את מה שדפים שולחים דרך webhook, בקשת HTTP שיכולה להגיע יותר מפעם אחת, ולא דרך לולאה חיה מול כל חיבור. משחק או מערכת בקרה, שבהם התהליך שלכם צריך לענות על כל הודעה תוך אלפיות שנייה, מקומם על שרת משלהם. כך גם פרוטוקול משלכם, שתוכנות אחרות מדברות בו על websocket רגיל. וכלי קטן עם תהליך אחד וכמה מאות אנשים אולי לעולם לא יצטרך יותר מחמש עשרה השורות שבתחילת הפוסט הזה.
התחילו מהמדריך
המדריך ל-Express כולל את כל ההגדרה, ו-ההדגמה של Express היא חנות קטנה שבנויה עליו, שבה הזמנה עוברת ל"נשלחה" בחלון אחר ברגע שאתם לוחצים. אותה רשימה נראית קצת אחרת ב-Python, שם FastAPI פוגש אותה מעבר ל-worker אחד.
WordPlus Cloud for Apps מתומחר לפי חיבורים בו-זמניים, החל מ-1,000, בחיוב חודשי או שנתי, ו-הפוסט שלנו על תמחור של זמן אמת מסביר איך עובדת ספירה לפי חיבור. העמוד שלנו על ה-API של WebSocket מציג חדרים, נוכחות ואירועים בכל סטאק, ו-המחירים לאפליקציות כוללים את המספרים. שאלות על האינטגרציה שלכם? כתבו לנו.