WebRTC in Node.js: signaling, peers en de npm-pakketten

Node.js heeft geen eigen WebRTC: er zit een WebSocket-client in, maar geen RTCPeerConnection. Node.js doet dus op een van twee manieren mee aan een gesprek. Of als de signalingserver die aanbiedingen en adressen doorgeeft tussen twee browsers, waarvoor alleen een websocket-bibliotheek nodig is, of als een eigen peer via een npm-pakket dat de WebRTC-stack meebrengt.
Dit artikel laat zien waar elk past, drie pakketten die van Node.js een peer maken en wat elk aan je code geeft, twee korte programma’s die tegen Chromium zijn getest, en daarna hoe een Express-app gesprekken tussen zijn gebruikers toevoegt zonder een van de twee.
Twee rollen voor Node.js in een gesprek
| Rol | Media via | Node.js heeft nodig |
|---|---|---|
| Signalingserver | De twee browsers | Een websocket-bibliotheek, zoals ws |
| Peer in het gesprek | Node.js zelf | Een WebRTC-pakket van npm |
Draai node -e "console.log(typeof RTCPeerConnection, typeof WebSocket)" op Node.js 22 en het toont undefined function. De API van de browser die gesprekken vervoert is er niet, dus code die voor de browser is geschreven, draait niet zomaar op de server.
Voor een videochat tussen de gebruikers van een webapp heeft de server daar niets van nodig. Het gesprek gaat van browser naar browser, en Node.js helpt ze alleen elkaar te vinden: hoe WebRTC twee browsers verbindt bevat die hele relay in Node.js met het pakket ws, en de pagina die hem gebruikt. De relay is het makkelijke deel. Het overgaan in elk tabblad dat iemand open heeft is dat niet, want daarvoor is voor elke gebruiker een open verbinding nodig, en zodra je meer dan één proces draait, zijn die verbindingen over de processen verdeeld (websockets in Node.js met meer dan één server legt uit wat daarvoor nodig is).
Een peer is voor programma’s die de media of het kanaal zelf nodig hebben: een recorder, een bot die aan een gesprek meedoet, een test die vanuit een script belt, een gameserver die met elke speler praat over een datakanaal.
De npm-pakketten die van Node.js een peer maken
Elk van deze is open source en geeft Node.js de RTCPeerConnection van de browser, met de aanbieding, het antwoord en de kandidaten uitgewisseld zoals in een browser. Ze verschillen in waarop ze gebouwd zijn, en dus in wat je code krijgt:
| Pakket | Je code krijgt |
|---|---|
| werift 0.28 | Media als RTP-pakketten, datakanalen |
| node-datachannel 0.33 | Datakanalen, en een eigen WebSocket |
| @roamhq/wrtc 0.10 | Gedecodeerde beelden en geluid, datakanalen |
Wat elk over zichzelf zegt, en wat we zagen toen we ze draaiden:
- werift is geschreven in TypeScript, vraagt Node.js 22 of nieuwer en installeert niets native. Het geeft je elk pakketje van de video zodra het binnenkomt, nog gecodeerd, en verstuurt pakketjes die je het geeft. Dat is wat doorsturen nodig heeft, en zo werkt een mediaserver voor groepsgesprekken: die stuurt de video door zonder hem ooit te decoderen (hoe groepsvideogesprekken werken).
- node-datachannel koppelt libdatachannel, een kleine C++-bibliotheek, met kant-en-klare binaries voor Linux, macOS en Windows op Node.js 18.20 of nieuwer. De export
node-datachannel/polyfillgeeft de API van de browser, en de README noemt een eigen WebSocket-client en -server, voor signaling. - @roamhq/wrtc is een fork van het oudere project node-webrtc, met bindings naar release 106 van de WebRTC-bibliotheek van Google, uit 2022, en kant-en-klare binaries voor Linux en macOS op x64 en arm64, en voor Windows op x64. Naast de standaard-API heeft het niet-standaard sinks en sources: we lieten het de camera van een browser ontvangen en het gaf ons elk beeld gedecodeerd, 640 bij 480, als ruwe bytes.
De keuze volgt uit de klus. Om media door te sturen, of op te nemen zoals ze binnenkwamen, zijn pakketjes genoeg. Om te lezen wat er in het beeld staat, of erop te tekenen, heb je het gedecodeerd nodig, ten koste van het CPU-werk voor elk beeld. Voor alleen data volstaat een kleine bibliotheek.
Node.js als peer: een video die terugkomt
Het programma hieronder beantwoordt een browser met werift en stuurt zijn video meteen terug, waarbij elk pakketje door Node.js gaat zonder gedecodeerd te worden (npm install werift). Het gebruikt de module http van Node.js voor het ene verzoek dat de uitwisseling nodig heeft:
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 }) => {
// Elk pakketje van de video van de browser gaat meteen terug, nooit gedecodeerd.
track.onReceiveRtp.subscribe((rtp) => transceiver.sender.sendRtp(rtp));
// Vraag de browser af en toe om een volledig beeld, zodat de andere kant kan beginnen met tekenen.
const timer = setInterval(() => transceiver.receiver.sendRtcpPLI(track.ssrc), 3000);
pc.onconnectionstatechange = () => {
if (['failed', 'closed'].includes(pc.connectionState)) clearInterval(timer);
};
};
await pc.setRemoteDescription(offer);
// Verstuur en ontvang op de videolijn die de browser aanbood.
for (const transceiver of pc.getTransceivers()) transceiver.direction = 'sendrecv';
await pc.setLocalDescription(await pc.createAnswer());
// Wacht op alle kandidaten, zodat ze allemaal in het ene antwoord staan.
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))));
}
// De pagina en haar script, uit de map 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);De pagina komt in static/index.html, met twee video-elementen en het script:
<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]);
};
// De Node.js-kant neemt één aanbieding met alle kandidaten erin, dus wacht op ze allemaal.
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());Draai node echo.mjs en open http://localhost:8081/. De browser vraagt om de camera, en even later toont de tweede video de eerste, terug van Node.js. We draaiden het in Chromium met een nepcamera: het beeld kwam terug met een breedte van 640 pixels, en het aantal getekende beelden bleef stijgen, ongeveer 20 per seconde.
Drie regels erin staan er met een reden:
- De richting. Een antwoord zonder eigen track ontvangt alleen, dus het programma zet de videolijn op
sendrecvvoordat het antwoordt. Zonder die regel kreeg de browser niets terug. - Het verzoek om een volledig beeld. Video wordt grotendeels verstuurd als veranderingen ten opzichte van het vorige beeld. Een programma dat niets decodeert, kan zelf geen volledig beeld maken, dus het vraagt de afzender er af en toe om. Zo kan de andere kant beginnen, of herstellen na een verloren pakketje. Mediaservers doen hetzelfde.
- Eén verzoek is de hele uitwisseling. De browser stuurt alle kandidaten mee in zijn aanbieding en Node.js alle kandidaten in zijn antwoord, dus een gewone POST volstaat, en voor dit programma is geen websocket nodig.
Node.js als peer: een datakanaal
Een datakanaal heeft helemaal geen media nodig. Met node-datachannel (npm install node-datachannel) beantwoordt de server hieronder een browser over een kanaal dat ongeordend is en nooit opnieuw verstuurt, het soort dat een game gebruikt voor posities, waar een laat bericht minder waard is dan het volgende:
// channel.mjs: dezelfde server als echo.mjs, met dit in plaats van zijn import en answer()
import { RTCPeerConnection } from 'node-datachannel/polyfill';
async function answer(offer) {
const pc = new RTCPeerConnection();
pc.ondatachannel = ({ channel }) => {
channel.onmessage = ({ data }) => {
// Beantwoord elk bericht meteen, met de klok van de server.
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());
// Wacht op alle kandidaten, zodat ze allemaal in het ene antwoord staan.
await new Promise((resolve) => {
if (pc.iceGatheringState === 'complete') return resolve();
pc.onicegatheringstatechange = () => pc.iceGatheringState === 'complete' && resolve();
});
return pc.localDescription;
}De pagina opent het kanaal en meet elke rondgang:
const pc = new RTCPeerConnection();
// Ongeordend, nooit opnieuw verstuurd: een laat bericht is minder waard dan het volgende.
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 += `rondgang ${Math.round(performance.now() - sent)} ms\n`;
};
// Stuur één aanbieding met alle kandidaten erin, want de server antwoordt één keer.
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());De bijbehorende static/index.html is een <pre id="log"></pre> en een scripttag voor /channel.js. Op één machine in Chromium duurde elke rondgang 1 tot 4 milliseconden. Over een echt netwerk is dat de tijd van het pad zelf, zonder dat een bericht wordt tegengehouden achter een dat verloren ging, wat een websocket over TCP niet kan beloven.
Op een eigen server hebben beide programma’s nodig wat elke peer nodig heeft: een STUN-server om hun publieke adres te leren, en een TURN-server voor mensen achter strenge netwerken, opgegeven in new RTCPeerConnection({ iceServers: [...] }) (STUN- en TURN-servers uitgelegd). De pagina moet op localhost of HTTPS staan om de camera te openen. Komt een gesprek niet tot stand, dan loopt waarom een WebRTC-verbinding mislukt na wat je controleert.
Welke je nodig hebt
- Je gebruikers bellen elkaar. Node.js is de signalingserver, of laat dat aan een dienst over. De browsers vervoeren het gesprek, en je server beslist wie wie mag bellen.
- Een programma doet mee aan het gesprek. Een recorder, een bot, een test, een camera op een klein apparaat: Node.js is een peer, via het pakket dat je de media geeft in de vorm die je nodig hebt, en je draait het op je eigen servers.
- Je server praat met elke browser met zo min mogelijk vertraging. Een datakanaal naar een Node.js-peer, voor games en live bediening, naast of in plaats van een websocket.
Dezelfde verdeling geldt in andere talen: WebRTC in Python is dit artikel voor Python, met aiortc als peer. De meeste webapps hebben het eerste nodig, en het werk zit minder in de relay dan eromheen: het overgaan in elk tabblad, de relays, opnieuw verbinden als een telefoon van netwerk wisselt, en groepsgesprekken met meer dan vier mensen.
Gesprekken in Express en Node.js met WordPlus Cloud
Met het pakket @wordplus/realtime plaatst een Node.js-app gesprekken tussen zijn gebruikers zonder dat je een signalingserver, relay of belscherm hoeft te schrijven, en zonder een eigen peer te draaien. Je app beslist wie mag bellen in een eigen route, die een token voor het gesprek teruggeeft. In Express:
// server.mjs: GET /call-token?to=34&type=video, die de knop opvraagt als erop wordt gedrukt.
app.get('/call-token', async (req, res) => {
// Hier komt je eigen controle: wie wie mag bellen.
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 }) });
});De pagina start het belscherm en zet een knop waar mensen vandaan bellen, die je route om een token vraagt:
await rt.callScreen(); // het overgaan en het gespreksvenster, op elke pagina waar een gesprek kan binnenkomen<call-button to="34" token-url="/call-token" type="video" name="Ann">Call Ann</call-button>Het gesprek gaat over in elk tabblad en op elk apparaat dat Ann open heeft. Het gaat rechtstreeks tussen de twee browsers als hun netwerken dat toelaten, via onze relays op de poorten 443 en 80 als dat niet zo is, en via onze mediaservers als zelfs de relays er niet doorkomen, en het wisselt van de ene weg naar de andere zonder op te hangen. Gesprekken tussen twee mensen zijn op elke weg end-to-end versleuteld, en groepsgesprekken lopen over dezelfde servers. Zonder token van je route begint er niets, dus niemand kan eromheen.
De gesprekspagina van de Express-handleiding laat de rest zien: wie mag bellen, groepsgesprekken met een host, en een eigen gespreksinterface. Hetzelfde pakket draait in een kale Node.js-server, Fastify of Hono.
Videogesprekken voor je Node.js-app
WordPlus Cloud for Apps is geprijsd op gelijktijdige verbindingen, vanaf 1.000, maandelijks of jaarlijks gefactureerd, en gesprekken tussen twee mensen kosten op geen enkele weg credits. Bekijk videogesprekken en groepsgesprekken voor apps, of de prijzen voor apps. Vragen over je integratie? Schrijf ons.