WebRTC ב-Node.js: איתות, צדדים בשיחה וחבילות ה-npm

ל-Node.js אין WebRTC משלו: יש בו לקוח WebSocket מובנה, אבל אין RTCPeerConnection. לכן Node.js משתתף בשיחה באחת משתי דרכים. או כשרת האיתות שמעביר הצעות וכתובות בין שני דפדפנים, ולזה מספיקה ספריית websocket, או כצד בשיחה בעצמו, דרך חבילת npm שמביאה איתה את כל ה-WebRTC.
הפוסט הזה מראה איפה כל אחת מתאימה, שלוש חבילות שהופכות את Node.js לצד בשיחה ומה כל אחת נותנת לקוד שלכם, שתי תוכניות קצרות שנבדקו מול Chromium, ואז איך אפליקציית Express מוסיפה שיחות בין המשתמשים שלה בלי אף אחת מהן.
שני תפקידים ש-Node.js יכול למלא בשיחה
| תפקיד | מי מעביר את המדיה | מה Node.js צריך |
|---|---|---|
| שרת איתות | שני הדפדפנים | ספריית websocket, כמו ws |
| צד בשיחה | Node.js עצמו | חבילת WebRTC מ-npm |
הריצו node -e "console.log(typeof RTCPeerConnection, typeof WebSocket)" ב-Node.js 22 והוא מדפיס undefined function. ה-API של הדפדפן שמעביר שיחות לא נמצא שם, כך שקוד שנכתב לדפדפן לא יכול פשוט לרוץ על השרת.
לצ׳אט וידאו בין משתמשים של אפליקציית ווב, השרת לא צריך שום דבר מזה. השיחה עוברת מדפדפן לדפדפן, ו-Node.js רק עוזר להם למצוא זה את זה: איך WebRTC מחבר שני דפדפנים מראה את כל הממסר הזה ב-Node.js עם החבילה ws, ואת הדף שמשתמש בו. הממסר הוא החלק הקל. הצלצול לאדם בכל לשונית שפתוחה אצלו הוא לא, כי הוא דורש חיבור פתוח לכל משתמש, וברגע שמריצים יותר מתהליך אחד החיבורים האלה מתחלקים ביניהם (חיבורי websocket ב-Node.js מעבר לשרת אחד עובר על מה שזה דורש).
צד בשיחה מיועד לתוכניות שצריכות את המדיה או את הערוץ בעצמן: מקליט, בוט שמצטרף לשיחה, בדיקה שמתקשרת מסקריפט, שרת משחק שמדבר עם כל שחקן בערוץ נתונים.
חבילות ה-npm שהופכות את Node.js לצד בשיחה
כל אחת מהן היא קוד פתוח ונותנת ל-Node.js את ה-RTCPeerConnection של הדפדפן, עם ההצעה, התשובה והמועמדים שמוחלפים כמו בדפדפן. הן שונות במה שהן בנויות עליו, ולכן במה שהקוד שלכם מקבל:
| חבילה | מה הקוד מקבל |
|---|---|
| werift 0.28 | מדיה כמנות RTP, ערוצי נתונים |
| node-datachannel 0.33 | ערוצי נתונים, ו-WebSocket משלה |
| @roamhq/wrtc 0.10 | תמונה וקול מפוענחים, ערוצי נתונים |
מה כל אחת אומרת על עצמה, ומה ראינו כשהרצנו אותן:
- werift כתובה ב-TypeScript, דורשת Node.js 22 ומעלה ולא מתקינה שום דבר נייטיב. היא מוסרת לכם כל מנה של הווידאו כשהיא מגיעה, עדיין מקודדת, ושולחת מנות שאתם נותנים לה. זה מה שהעברה הלאה צריכה, וכך עובד שרת מדיה לשיחות קבוצתיות: הוא מעביר את הווידאו הלאה בלי לפענח אותו אף פעם (איך שיחות וידאו קבוצתיות עובדות).
- node-datachannel עוטפת את libdatachannel, ספריית C++ קטנה, עם קבצים בינאריים מוכנים ל-Linux, macOS ו-Windows על Node.js 18.20 ומעלה. ה-export שלה
node-datachannel/polyfillנותן את ה-API של הדפדפן, וה-README שלה מונה לקוח ושרת WebSocket משלה, לאיתות. - @roamhq/wrtc היא fork של הפרויקט הוותיק node-webrtc, עם חיבור לגרסה 106 של ספריית ה-WebRTC של Google, מ-2022, וקבצים בינאריים מוכנים ל-Linux ול-macOS על x64 ועל arm64, ול-Windows על x64. לצד ה-API הסטנדרטי יש בה sinks ו-sources לא סטנדרטיים: נתנו לה לקבל את המצלמה של דפדפן והיא מסרה לנו כל תמונה מפוענחת, 640 על 480, כבתים גולמיים.
הבחירה נובעת מהתפקיד. כדי להעביר מדיה הלאה, או להקליט אותה כפי שהגיעה, מנות מספיקות. כדי לקרוא מה יש בתמונה, או לצייר עליה, צריך אותה מפוענחת, במחיר עבודת ה-CPU על כל פריים. לנתונים בלבד, ספרייה קטנה עושה את העבודה.
Node.js כצד בשיחה: וידאו שחוזר
התוכנית שלמטה עונה לדפדפן עם werift ושולחת לו את הווידאו שלו ישר בחזרה, וכל מנה עוברת דרך Node.js בלי להיות מפוענחת (npm install werift). היא משתמשת במודול http של Node.js לבקשה האחת שההחלפה צריכה:
import http from 'node:http';
import { readFile } from 'node:fs/promises';
import { RTCPeerConnection } from 'werift';
async function answer(offer) {
const pc = new RTCPeerConnection();
pc.ontrack = ({ track, transceiver }) => {
// כל מנה של הווידאו של הדפדפן חוזרת ישר, בלי פענוח אף פעם.
track.onReceiveRtp.subscribe((rtp) => transceiver.sender.sendRtp(rtp));
// מבקשים מהדפדפן תמונה מלאה מדי פעם, כדי שהצד השני יוכל להתחיל לצייר.
const timer = setInterval(() => transceiver.receiver.sendRtcpPLI(track.ssrc), 3000);
pc.onconnectionstatechange = () => {
if (['failed', 'closed'].includes(pc.connectionState)) clearInterval(timer);
};
};
await pc.setRemoteDescription(offer);
// שולחים וגם מקבלים בקו הווידאו שהדפדפן הציע.
for (const transceiver of pc.getTransceivers()) transceiver.direction = 'sendrecv';
await pc.setLocalDescription(await pc.createAnswer());
// מחכים לכל המועמדים, כדי שכולם ייכנסו לתשובה האחת.
await new Promise((resolve) => {
if (pc.iceGatheringState === 'complete') return resolve();
pc.onicegatheringstatechange = () => pc.iceGatheringState === 'complete' && resolve();
});
return pc.localDescription;
}
http.createServer(async (req, res) => {
if (req.method === 'POST' && req.url === '/offer') {
let body = '';
for await (const chunk of req) body += chunk;
res.setHeader('Content-Type', 'application/json');
return res.end(JSON.stringify(await answer(JSON.parse(body))));
}
// הדף והסקריפט שלו, מהתיקייה static.
const file = req.url === '/' ? 'index.html' : req.url.slice(1);
try {
const body = await readFile(new URL(`./static/${file}`, import.meta.url));
res.setHeader('Content-Type', file.endsWith('.js') ? 'text/javascript' : 'text/html');
res.end(body);
} catch {
res.statusCode = 404;
res.end();
}
}).listen(8081);הדף נמצא ב-static/index.html, עם שני רכיבי וידאו והסקריפט:
<video id="me" autoplay playsinline muted></video>
<video id="back" autoplay playsinline></video>
<script type="module" src="/mirror.js"></script>const local = await navigator.mediaDevices.getUserMedia({ video: true });
document.getElementById('me').srcObject = local;
const pc = new RTCPeerConnection();
pc.addTrack(local.getVideoTracks()[0], local);
pc.ontrack = ({ track }) => {
document.getElementById('back').srcObject = new MediaStream([track]);
};
// צד ה-Node.js מקבל הצעה אחת עם כל המועמדים בתוכה, ולכן מחכים לכולם.
await pc.setLocalDescription(await pc.createOffer());
await new Promise((resolve) => {
if (pc.iceGatheringState === 'complete') return resolve();
pc.addEventListener('icegatheringstatechange', () => {
if (pc.iceGatheringState === 'complete') resolve();
});
});
const response = await fetch('/offer', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(pc.localDescription),
});
await pc.setRemoteDescription(await response.json());הריצו node echo.mjs ופתחו את http://localhost:8081/. הדפדפן מבקש גישה למצלמה, ורגע אחר כך הווידאו השני מציג את הראשון, חוזר מ-Node.js. הרצנו אותו ב-Chromium עם מצלמה מדומה: התמונה חזרה ברוחב 640 פיקסלים, ומספר התמונות שצוירו המשיך לעלות, כ-20 בשנייה.
שלוש שורות בו נמצאות שם מסיבה:
- הכיוון. תשובה שנוצרת בלי ערוץ משלה רק מקבלת, ולכן התוכנית מעבירה את קו הווידאו ל-
sendrecvלפני שהיא עונה. בלי השורה הזו הדפדפן לא קיבל שום דבר בחזרה. - הבקשה לתמונה מלאה. וידאו נשלח בעיקר כשינויים מהתמונה הקודמת. תוכנית שלא מפענחת כלום לא יכולה ליצור תמונה מלאה בעצמה, ולכן היא מבקשת אחת מהשולח מדי פעם, וזה מאפשר לצד השני להתחיל, או להתאושש אחרי מנה שאבדה. שרתי מדיה עושים אותו דבר.
- בקשה אחת היא כל ההחלפה. הדפדפן שולח את כל המועמדים בהצעה שלו ו-Node.js את כל המועמדים בתשובה שלו, כך ש-POST רגיל מספיק, ולתוכנית הזו לא צריך websocket.
Node.js כצד בשיחה: ערוץ נתונים
ערוץ נתונים לא צריך מדיה בכלל. עם node-datachannel (npm install node-datachannel), השרת שלמטה עונה לדפדפן בערוץ ללא סדר וללא שליחה חוזרת, מהסוג שמשחק משתמש בו למיקומים, שבו הודעה מאוחרת שווה פחות מהבאה אחריה:
// channel.mjs: אותו שרת כמו echo.mjs, עם זה במקום ה-import וה-answer() שלו
import { RTCPeerConnection } from 'node-datachannel/polyfill';
async function answer(offer) {
const pc = new RTCPeerConnection();
pc.ondatachannel = ({ channel }) => {
channel.onmessage = ({ data }) => {
// עונים לכל הודעה מיד, עם השעון של השרת.
const { sent } = JSON.parse(data);
channel.send(JSON.stringify({ sent, server: Date.now() }));
};
};
pc.onconnectionstatechange = () => {
if (['failed', 'closed'].includes(pc.connectionState)) pc.close();
};
await pc.setRemoteDescription(offer);
await pc.setLocalDescription(await pc.createAnswer());
// מחכים לכל המועמדים, כדי שכולם ייכנסו לתשובה האחת.
await new Promise((resolve) => {
if (pc.iceGatheringState === 'complete') return resolve();
pc.onicegatheringstatechange = () => pc.iceGatheringState === 'complete' && resolve();
});
return pc.localDescription;
}הדף פותח את הערוץ ומודד כל הלוך ושוב:
const pc = new RTCPeerConnection();
// ללא סדר, ללא שליחה חוזרת: הודעה מאוחרת שווה פחות מהבאה אחריה.
const channel = pc.createDataChannel('state', { ordered: false, maxRetransmits: 0 });
channel.onopen = () => {
setInterval(() => channel.send(JSON.stringify({ sent: performance.now() })), 1000);
};
channel.onmessage = ({ data }) => {
const { sent } = JSON.parse(data);
document.getElementById('log').textContent += `round trip ${Math.round(performance.now() - sent)} ms\n`;
};
// שולחים הצעה אחת עם כל המועמדים בתוכה, כי השרת עונה פעם אחת.
await pc.setLocalDescription(await pc.createOffer());
await new Promise((resolve) => {
if (pc.iceGatheringState === 'complete') return resolve();
pc.addEventListener('icegatheringstatechange', () => {
if (pc.iceGatheringState === 'complete') resolve();
});
});
const response = await fetch('/offer', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify(pc.localDescription),
});
await pc.setRemoteDescription(await response.json());ה-static/index.html שלו הוא <pre id="log"></pre> ותגית script ל-/channel.js. על מחשב אחד ב-Chromium, כל הלוך ושוב לקח 1 עד 4 מילישניות. ברשת אמיתית זה הזמן של הנתיב עצמו, בלי שום הודעה שמחכה מאחורי הודעה שאבדה, ו-websocket מעל TCP לא יכול להבטיח את זה.
בשרת שלכם, שתי התוכניות צריכות מה שכל צד בשיחה צריך: שרת STUN כדי ללמוד את הכתובת הציבורית שלהן, ושרת TURN לאנשים מאחורי רשתות מחמירות, שמוגדרים ב-new RTCPeerConnection({ iceServers: [...] }) (שרתי STUN ו-TURN, בהסבר). הדף חייב להיות ב-localhost או ב-HTTPS כדי שהמצלמה תיפתח. אם שיחה לא מתחברת, למה חיבור WebRTC נכשל עובר על מה לבדוק.
באיזו מהן אתם צריכים
- המשתמשים שלכם מתקשרים זה לזה. Node.js הוא שרת האיתות, או משאיר את זה לשירות. הדפדפנים מעבירים את השיחה, והשרת שלכם מחליט מי רשאי להתקשר למי.
- תוכנית מצטרפת לשיחה. מקליט, בוט, בדיקה, מצלמה במכשיר קטן: Node.js הוא צד בשיחה, דרך החבילה שמוסרת לכם את המדיה בצורה שאתם צריכים, ואתם מריצים אותו על שרתים משלכם.
- השרת שלכם מדבר עם כל דפדפן בהשהיה הנמוכה ביותר. ערוץ נתונים אל Node.js כצד בשיחה, למשחקים ולפקדים חיים, לצד websocket או במקומו.
אותה חלוקה תקפה גם בשפות אחרות: WebRTC ב-Python הוא הפוסט הזה ל-Python, עם aiortc כצד בשיחה. רוב אפליקציות הווב צריכות את הראשונה, והעבודה היא פחות בממסר ויותר במה שמסביבו: הצלצול בכל לשונית, הממסרים, התחברות מחדש כשטלפון מחליף רשת, ושיחות קבוצתיות של יותר מארבעה אנשים.
שיחות ב-Express וב-Node.js עם WordPlus Cloud
עם החבילה @wordplus/realtime, אפליקציית Node.js מקיימת שיחות בין המשתמשים שלה בלי שרת איתות, ממסר או מסך שיחה לכתוב, ובלי צד משלה בשיחה להריץ. האפליקציה שלכם מחליטה מי רשאי להתקשר ב-route משלה, שמחזיר token לשיחה. ב-Express:
// server.mjs: GET /call-token?to=34&type=video, שהכפתור שואל ברגע שלוחצים עליו.
app.get('/call-token', async (req, res) => {
// כאן הבדיקה שלכם: מי רשאי להתקשר למי.
const me = req.session.userId;
if (!me) return res.sendStatus(401);
res.json({ token: await realtime.callToken(me, req.query.to, { type: req.query.type }) });
});הדף מפעיל את מסך השיחה ומציב כפתור במקום שממנו אנשים מתקשרים, והכפתור שואל את ה-route שלכם:
await rt.callScreen(); // הצלצול וחלון השיחה, בכל דף ששיחה עשויה לצלצל בו<call-button to="34" token-url="/call-token" type="video" name="Ann">Call Ann</call-button>השיחה מצלצלת בכל לשונית ובכל מכשיר שפתוחים אצל Ann. היא עוברת ישירות בין שני הדפדפנים כשהרשתות שלהם מאפשרות זאת, דרך הממסרים שלנו בפורטים 443 ו-80 כשלא, ודרך שרתי המדיה שלנו כשאפילו הממסרים לא מצליחים להגיע, ועוברת מנתיב לנתיב בלי לנתק. שיחות בין שני אנשים מוצפנות מקצה לקצה בכל נתיב, ושיחות קבוצתיות רצות על אותם שרתים. בלי token מה-route שלכם שום דבר לא מתחיל, כך שאף אחד לא יכול לעקוף אותו.
דף השיחות במדריך של Express מראה את השאר: מי רשאי להתקשר, שיחות קבוצתיות עם מארח, וממשק שיחה משלכם. אותה חבילה רצה גם בשרת Node.js רגיל, ב-Fastify או ב-Hono.
שיחות וידאו לאפליקציית ה-Node.js שלכם
WordPlus Cloud for Apps מתומחר לפי חיבורים בו-זמניים, החל מ-1,000, בחיוב חודשי או שנתי, ושיחות בין שני אנשים לא לוקחות קרדיטים באף נתיב. ראו שיחות וידאו ושיחות קבוצתיות לאפליקציות, או את המחירים לאפליקציות. שאלות על האינטגרציה שלכם? כתבו לנו.