WebRTC in Node.js: Signalisierung, Peers und die npm-Pakete

Node.js hat kein eigenes WebRTC: Ein WebSocket-Client ist eingebaut, aber kein RTCPeerConnection. Also nimmt Node.js auf eine von zwei Arten an einem Anruf teil, entweder als Signalisierungsserver, der Angebote und Adressen zwischen zwei Browsern weiterreicht, wofür eine WebSocket-Bibliothek genügt, oder als eigener Peer über ein npm-Paket, das den WebRTC-Stack mitbringt.
Dieser Beitrag zeigt, wofür sich was eignet, drei Pakete, die Node.js zum Peer machen, und was jedes Ihrem Code übergibt, zwei kurze Programme, getestet mit Chromium, und dann, wie eine Express-App Anrufe zwischen ihren Nutzern ohne beides ergänzt.
Zwei Aufgaben, die Node.js in einem Anruf haben kann
| Aufgabe | Wer die Medien trägt | Was Node.js braucht |
|---|---|---|
| Signalisierung | Die beiden Browser | Eine WebSocket-Bibliothek wie ws |
| Peer im Anruf | Node.js selbst | Ein WebRTC-Paket von npm |
Führen Sie node -e "console.log(typeof RTCPeerConnection, typeof WebSocket)" unter Node.js 22 aus, gibt es undefined function aus. Die Browser-API, die Anrufe trägt, fehlt, also kann Code, der für den Browser geschrieben ist, nicht einfach auf dem Server laufen.
Für einen Video-Chat zwischen den Nutzern einer Web-App braucht der Server nichts davon. Der Anruf läuft von Browser zu Browser, und Node.js hilft ihnen nur, einander zu finden: Wie WebRTC zwei Browser verbindet enthält dieses ganze Relay in Node.js mit dem Paket ws und die Seite, die es nutzt. Das Relay ist der leichte Teil. Die angerufene Person in jedem Tab klingeln zu lassen, den sie offen hat, ist es nicht, denn das braucht für jeden Nutzer eine offene Verbindung, und sobald mehr als ein Prozess läuft, verteilen sich diese Verbindungen auf sie (WebSockets in Node.js über einen Server hinaus zeigt, was das verlangt).
Ein Peer ist etwas für Programme, die die Medien oder den Kanal selbst brauchen: ein Aufzeichner, ein Bot, der an einem Anruf teilnimmt, ein Test, der aus einem Skript anruft, ein Spielserver, der mit jedem Spieler über einen Datenkanal spricht.
Die npm-Pakete, die Node.js zum Peer machen
Jedes davon ist Open Source und gibt Node.js das RTCPeerConnection des Browsers, mit Angebot, Antwort und Kandidaten, die wie im Browser ausgetauscht werden. Sie unterscheiden sich darin, worauf sie aufbauen, und damit darin, was Ihr Code bekommt:
| Paket | Was Ihr Code bekommt |
|---|---|
| werift 0.28 | Medien als RTP-Pakete, Datenkanäle |
| node-datachannel 0.33 | Datenkanäle und einen eigenen WebSocket |
| @roamhq/wrtc 0.10 | Dekodierte Bilder und Töne, Datenkanäle |
Was jedes über sich selbst sagt und was wir beim Ausprobieren gesehen haben:
- werift ist in TypeScript geschrieben, braucht Node.js 22 oder neuer und installiert nichts Natives. Es übergibt Ihnen jedes Paket des Videos, sobald es ankommt, noch kodiert, und sendet Pakete, die Sie ihm geben. Genau das braucht das Weiterleiten, und so arbeitet ein Medienserver für Gruppenanrufe: Er reicht das Video weiter, ohne es je zu dekodieren (wie Gruppen-Videoanrufe funktionieren).
- node-datachannel bindet libdatachannel an, eine kleine C++-Bibliothek, mit vorgefertigten Binärdateien für Linux, macOS und Windows ab Node.js 18.20. Sein Export
node-datachannel/polyfillliefert die Browser-API, und seine README nennt einen eigenen WebSocket-Client und -Server für die Signalisierung. - @roamhq/wrtc ist ein Fork des älteren Projekts node-webrtc, mit Bindungen an Release 106 von Googles WebRTC-Bibliothek aus dem Jahr 2022 und vorgefertigten Binärdateien für Linux und macOS auf x64 und arm64 sowie für Windows auf x64. Neben der Standard-API hat es nicht standardisierte Senken und Quellen: Wir ließen es die Kamera eines Browsers empfangen, und es gab uns jedes Bild dekodiert, 640 mal 480, als rohe Bytes.
Die Wahl folgt aus der Aufgabe. Um Medien weiterzureichen oder so aufzuzeichnen, wie sie ankamen, genügen Pakete. Um zu lesen, was im Bild ist, oder darauf zu zeichnen, brauchen Sie es dekodiert, um den Preis der CPU-Arbeit für jedes Bild. Für Daten allein genügt eine kleine Bibliothek.
Node.js als Peer: ein Video, das zurückkommt
Das Programm unten beantwortet einen Browser mit werift und schickt sein Video direkt zurück, wobei jedes Paket durch Node.js läuft, ohne dekodiert zu werden (npm install werift). Für die eine Anfrage, die der Austausch braucht, nutzt es das Modul http von 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 }) => {
// Jedes Paket des Browser-Videos geht direkt zurück, nie dekodiert.
track.onReceiveRtp.subscribe((rtp) => transceiver.sender.sendRtp(rtp));
// Den Browser ab und zu um ein volles Bild bitten, damit die Gegenseite zu zeichnen beginnen kann.
const timer = setInterval(() => transceiver.receiver.sendRtcpPLI(track.ssrc), 3000);
pc.onconnectionstatechange = () => {
if (['failed', 'closed'].includes(pc.connectionState)) clearInterval(timer);
};
};
await pc.setRemoteDescription(offer);
// Auf der Videozeile, die der Browser angeboten hat, senden und empfangen.
for (const transceiver of pc.getTransceivers()) transceiver.direction = 'sendrecv';
await pc.setLocalDescription(await pc.createAnswer());
// Auf alle Kandidaten warten, damit sie alle in die eine Antwort kommen.
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))));
}
// Die Seite und ihr Skript, aus dem Ordner 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);Die Seite kommt nach static/index.html, mit zwei Video-Elementen und dem Skript:
<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]);
};
// Die Node.js-Seite nimmt ein Angebot mit allen Kandidaten darin, also auf alle warten.
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());Starten Sie node echo.mjs und öffnen Sie http://localhost:8081/. Der Browser fragt nach der Kamera, und einen Moment später zeigt das zweite Video das erste, zurück von Node.js. Wir haben es in Chromium mit einer simulierten Kamera laufen lassen: Das Bild kam mit 640 Pixeln Breite zurück, und die Zahl der gezeichneten Bilder stieg weiter, etwa 20 pro Sekunde.
Drei Zeilen darin stehen aus gutem Grund dort:
- Die Richtung. Eine Antwort ohne eigenen Track empfängt nur, also stellt das Programm die Videozeile vor dem Antworten auf
sendrecv. Ohne diese Zeile bekam der Browser nichts zurück. - Die Bitte um ein volles Bild. Video wird meist als Änderungen gegenüber dem vorigen Bild gesendet. Ein Programm, das nichts dekodiert, kann selbst kein volles Bild erzeugen, also bittet es den Sender ab und zu um eines, damit die Gegenseite beginnen oder sich nach einem verlorenen Paket erholen kann. Medienserver tun dasselbe.
- Eine Anfrage ist der ganze Austausch. Der Browser schickt alle Kandidaten in seinem Angebot und Node.js alle Kandidaten in seiner Antwort, also genügt ein einfacher POST, und dieses Programm braucht keinen WebSocket.
Node.js als Peer: ein Datenkanal
Ein Datenkanal braucht gar keine Medien. Mit node-datachannel (npm install node-datachannel) beantwortet der Server unten einen Browser über einen Kanal, der ungeordnet ist und nie erneut sendet, die Art, die ein Spiel für Positionen nutzt, wo eine verspätete Nachricht weniger wert ist als die nächste:
// channel.mjs: derselbe Server wie echo.mjs, mit diesem Teil statt seines Imports und answer()
import { RTCPeerConnection } from 'node-datachannel/polyfill';
async function answer(offer) {
const pc = new RTCPeerConnection();
pc.ondatachannel = ({ channel }) => {
channel.onmessage = ({ data }) => {
// Jede Nachricht sofort beantworten, mit der Uhr des Servers.
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());
// Auf alle Kandidaten warten, damit sie alle in die eine Antwort kommen.
await new Promise((resolve) => {
if (pc.iceGatheringState === 'complete') return resolve();
pc.onicegatheringstatechange = () => pc.iceGatheringState === 'complete' && resolve();
});
return pc.localDescription;
}Die Seite öffnet den Kanal und misst jeden Umlauf:
const pc = new RTCPeerConnection();
// Ungeordnet, nie erneut gesendet: Eine verspätete Nachricht ist weniger wert als die nächste.
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 += `Umlauf ${Math.round(performance.now() - sent)} ms\n`;
};
// Ein Angebot mit allen Kandidaten darin senden, da der Server einmal antwortet.
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());Ihre static/index.html besteht aus einem <pre id="log"></pre> und einem Script-Tag für /channel.js. Auf einem Rechner in Chromium dauerte jeder Umlauf 1 bis 4 Millisekunden. Über ein echtes Netzwerk ist das die Zeit des Weges selbst, ohne dass eine Nachricht hinter einer verlorenen zurückgehalten wird, was ein WebSocket über TCP nicht versprechen kann.
Auf einem Ihrer Server brauchen beide Programme, was jeder Peer braucht: einen STUN-Server, um die eigene öffentliche Adresse zu erfahren, und einen TURN-Server für Menschen hinter strengen Netzwerken, angegeben in new RTCPeerConnection({ iceServers: [...] }) (STUN- und TURN-Server erklärt). Die Seite muss auf localhost oder HTTPS liegen, damit sich die Kamera öffnet. Kommt ein Anruf nicht zustande, geht warum eine WebRTC-Verbindung scheitert durch, was Sie prüfen sollten.
Was Sie brauchen
- Ihre Nutzer rufen einander an. Node.js ist der Signalisierungsserver oder überlässt das einem Dienst. Die Browser tragen den Anruf, und Ihr Server entscheidet, wer wen anrufen darf.
- Ein Programm nimmt am Anruf teil. Ein Aufzeichner, ein Bot, ein Test, eine Kamera an einem kleinen Gerät: Node.js ist ein Peer, über das Paket, das Ihnen die Medien in der Form übergibt, die Sie brauchen, und Sie betreiben es auf eigenen Servern.
- Ihr Server spricht mit jedem Browser mit der geringsten Verzögerung. Ein Datenkanal zu einem Node.js-Peer, für Spiele und Live-Steuerungen, neben oder statt eines WebSockets.
Dieselbe Aufteilung gilt in anderen Sprachen: WebRTC in Python ist dieser Beitrag für Python, mit aiortc als Peer. Die meisten Web-Apps brauchen das Erste, und die Arbeit steckt weniger im Relay als darum herum: das Klingeln in jedem Tab, die Relays, das neue Verbinden, wenn ein Smartphone das Netzwerk wechselt, und Gruppenanrufe mit mehr als vier Personen.
Anrufe in Express und Node.js mit WordPlus Cloud
Mit dem Paket @wordplus/realtime führt eine Node.js-App Anrufe zwischen ihren Nutzern, ohne dass Sie einen Signalisierungsserver, ein Relay oder einen Anrufbildschirm schreiben, und ohne einen eigenen Peer zu betreiben. Ihre App entscheidet in einer eigenen Route, wer anrufen darf, und diese antwortet mit einem Token für den Anruf. In Express:
// server.mjs: GET /call-token?to=34&type=video, das der Button beim Drücken fragt.
app.get('/call-token', async (req, res) => {
// Hier kommt Ihre eigene Prüfung hin: wer wen anrufen darf.
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 }) });
});Die Seite startet den Anrufbildschirm und setzt einen Button dorthin, von wo aus Menschen anrufen, der Ihre Route fragt:
await rt.callScreen(); // das Klingeln und das Anruffenster, auf jeder Seite, auf der ein Anruf klingeln kann<call-button to="34" token-url="/call-token" type="video" name="Ann">Call Ann</call-button>Der Anruf klingelt in jedem Tab und auf jedem Gerät, das Ann offen hat. Er läuft direkt zwischen den beiden Browsern, wenn ihre Netzwerke es erlauben, über unsere Relays auf den Ports 443 und 80, wenn nicht, und über unsere Medienserver, wenn selbst die Relays nicht durchkommen, und wechselt von einem zum nächsten, ohne aufzulegen. Anrufe zwischen zwei Personen sind auf jedem Weg Ende-zu-Ende-verschlüsselt, und Gruppenanrufe laufen auf denselben Servern. Ohne Token von Ihrer Route startet nichts, also kommt niemand daran vorbei.
Die Seite zu Anrufen im Express-Leitfaden zeigt den Rest: wer anrufen darf, Gruppenanrufe mit einem Host und eine eigene Anrufoberfläche. Dasselbe Paket läuft in einem einfachen Node.js-Server, in Fastify oder Hono.
Videoanrufe für Ihre Node.js-App
Für WordPlus Cloud for Apps gelten Preise nach gleichzeitigen Verbindungen, ab 1.000, monatlich oder jährlich abgerechnet, und Anrufe zwischen zwei Personen verbrauchen auf keinem Weg Credits. Sehen Sie sich Videoanrufe und Gruppenanrufe für Apps an oder die Preise für Apps. Fragen zu Ihrer Integration? Schreiben Sie uns.