WebRTC w Node.js: sygnalizacja, uczestnicy i pakiety npm

Node.js nie ma własnego WebRTC: ma wbudowanego klienta WebSocket, ale nie ma RTCPeerConnection. Dlatego Node.js bierze udział w rozmowie na jeden z dwóch sposobów. Albo jest serwerem sygnalizacji, który przekazuje oferty i adresy między dwiema przeglądarkami, i wtedy potrzebuje tylko biblioteki websocket, albo jest osobnym uczestnikiem rozmowy, dzięki pakietowi npm, który przynosi ze sobą cały stos WebRTC.
Ten wpis pokazuje, gdzie pasuje każdy z nich, trzy pakiety, które robią z Node.js uczestnika rozmowy, i co każdy z nich daje Twojemu kodowi, dwa krótkie programy przetestowane z Chromium, a potem to, jak aplikacja w Expressie dodaje rozmowy między swoimi użytkownikami bez żadnego z nich.
Dwie role Node.js w rozmowie
| Rola | Kto przenosi media | Czego trzeba |
|---|---|---|
| Serwer sygnalizacji | Dwie przeglądarki | Biblioteki websocket, np. ws |
| Uczestnik rozmowy | Sam Node.js | Pakietu WebRTC z npm |
Uruchom node -e "console.log(typeof RTCPeerConnection, typeof WebSocket)" w Node.js 22, a wypisze undefined function. API przeglądarki, które przenosi rozmowy, nie istnieje tu, więc kod napisany dla przeglądarki nie zadziała po prostu na serwerze.
Czat wideo między użytkownikami aplikacji internetowej nie potrzebuje na serwerze niczego z tego. Rozmowa idzie od przeglądarki do przeglądarki, a Node.js tylko pomaga im się odnaleźć: jak WebRTC łączy dwie przeglądarki pokazuje cały ten przekaźnik w Node.js z pakietem ws oraz stronę, która go używa. Przekaźnik to łatwa część. Trudniejszy jest dzwonek w każdej karcie, którą dana osoba ma otwartą, bo wymaga połączenia utrzymywanego dla każdego użytkownika, a gdy uruchamiasz więcej niż jeden proces, te połączenia są między nimi podzielone (websockety w Node.js na więcej niż jednym serwerze omawiają, czego to wymaga).
Uczestnik rozmowy jest potrzebny programom, które same potrzebują mediów albo kanału: rejestratorowi, botowi, który dołącza do rozmowy, testowi, który wykonuje rozmowę ze skryptu, serwerowi gry, który rozmawia z każdym graczem przez kanał danych.
Pakiety npm, które robią z Node.js uczestnika rozmowy
Każdy z nich jest open source i daje Node.js przeglądarkowe RTCPeerConnection, z ofertą, odpowiedzią i kandydatami wymienianymi tak jak w przeglądarce. Różnią się tym, na czym są zbudowane, a więc tym, co dostaje Twój kod:
| Pakiet | Co dostaje kod |
|---|---|
| werift 0.28 | Media jako pakiety RTP, kanały danych |
| node-datachannel 0.33 | Kanały danych i własny WebSocket |
| @roamhq/wrtc 0.10 | Zdekodowany obraz i dźwięk, kanały danych |
Co każdy mówi o sobie i co zobaczyliśmy, uruchamiając je:
- werift jest napisany w TypeScript, wymaga Node.js 22 lub nowszego i nie instaluje niczego natywnego. Daje Ci każdy pakiet wideo, gdy tylko przyjdzie, wciąż zakodowany, i wysyła pakiety, które mu przekażesz. Tego wymaga przekazywanie dalej i tak działa serwer mediów dla rozmów grupowych: przekazuje wideo, w ogóle go nie dekodując (jak działają grupowe rozmowy wideo).
- node-datachannel udostępnia libdatachannel, małą bibliotekę w C++, z gotowymi plikami binarnymi dla Linuksa, macOS i Windows w Node.js 18.20 lub nowszym. Jego eksport
node-datachannel/polyfilldaje API przeglądarki, a jego README wymienia własnego klienta i serwer WebSocket do sygnalizacji. - @roamhq/wrtc to fork starszego projektu node-webrtc, z powiązaniami do wydania 106 biblioteki WebRTC Google z 2022 roku oraz gotowymi plikami binarnymi dla Linuksa i macOS na x64 i arm64, a dla Windows na x64. Obok standardowego API ma niestandardowe ujścia i źródła: kazaliśmy mu odebrać kamerę przeglądarki i dał nam każdy obraz zdekodowany, 640 na 480, jako surowe bajty.
Wybór wynika z zadania. Żeby przekazać media dalej albo nagrać je tak, jak przyszły, pakiety wystarczą. Żeby odczytać, co jest na obrazie, albo na nim rysować, potrzebujesz go zdekodowanego, kosztem pracy procesora przy każdej klatce. Do samych danych wystarczy mała biblioteka.
Node.js jako uczestnik: wideo, które wraca
Poniższy program odpowiada przeglądarce przez werift i odsyła jej wideo prosto z powrotem, a każdy pakiet przechodzi przez Node.js bez dekodowania (npm install werift). Do jedynego żądania, którego potrzebuje wymiana, używa modułu http z 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 }) => {
// Każdy pakiet wideo z przeglądarki wraca od razu, nigdy niezdekodowany.
track.onReceiveRtp.subscribe((rtp) => transceiver.sender.sendRtp(rtp));
// Co jakiś czas poproś przeglądarkę o pełny obraz, żeby druga strona mogła zacząć rysować.
const timer = setInterval(() => transceiver.receiver.sendRtcpPLI(track.ssrc), 3000);
pc.onconnectionstatechange = () => {
if (['failed', 'closed'].includes(pc.connectionState)) clearInterval(timer);
};
};
await pc.setRemoteDescription(offer);
// Wysyłaj i odbieraj na linii wideo, którą zaoferowała przeglądarka.
for (const transceiver of pc.getTransceivers()) transceiver.direction = 'sendrecv';
await pc.setLocalDescription(await pc.createAnswer());
// Poczekaj na wszystkich kandydatów, żeby trafili do jednej odpowiedzi.
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))));
}
// Strona i jej skrypt, z folderu 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);Strona trafia do static/index.html, z dwoma elementami wideo i skryptem:
<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]);
};
// Strona Node.js przyjmuje jedną ofertę ze wszystkimi kandydatami, więc poczekaj na nich wszystkich.
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());Uruchom node echo.mjs i otwórz http://localhost:8081/. Przeglądarka poprosi o kamerę, a chwilę później drugie wideo pokaże pierwsze, odesłane przez Node.js. Uruchomiliśmy to w Chromium z wirtualną kamerą: obraz wrócił o szerokości 640 pikseli, a liczba narysowanych klatek rosła dalej, około 20 na sekundę.
Trzy linijki są w nim nie bez powodu:
- Kierunek. Odpowiedź utworzona bez własnej ścieżki tylko odbiera, więc program ustawia linię wideo na
sendrecvprzed odpowiedzią. Bez tej linijki przeglądarka nie dostała niczego z powrotem. - Prośba o pełny obraz. Wideo jest wysyłane głównie jako zmiany względem poprzedniego obrazu. Program, który niczego nie dekoduje, nie może sam zrobić pełnego obrazu, więc co jakiś czas prosi o niego nadawcę, co pozwala drugiej stronie zacząć albo dojść do siebie po utraconym pakiecie. Serwery mediów robią to samo.
- Jedno żądanie to cała wymiana. Przeglądarka wysyła wszystkich kandydatów w swojej ofercie, a Node.js wszystkich w swojej odpowiedzi, więc wystarcza zwykły POST i ten program nie potrzebuje websocketu.
Node.js jako uczestnik: kanał danych
Kanał danych w ogóle nie potrzebuje mediów. Z node-datachannel (npm install node-datachannel) poniższy serwer odpowiada przeglądarce przez kanał bez kolejności i bez ponownego wysyłania, taki, jakiego gra używa do pozycji, gdzie spóźniona wiadomość jest warta mniej niż następna:
// channel.mjs: ten sam serwer co echo.mjs, z tym w miejscu jego importu i answer()
import { RTCPeerConnection } from 'node-datachannel/polyfill';
async function answer(offer) {
const pc = new RTCPeerConnection();
pc.ondatachannel = ({ channel }) => {
channel.onmessage = ({ data }) => {
// Odpowiedz na każdą wiadomość od razu, z zegarem serwera.
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());
// Poczekaj na wszystkich kandydatów, żeby trafili do jednej odpowiedzi.
await new Promise((resolve) => {
if (pc.iceGatheringState === 'complete') return resolve();
pc.onicegatheringstatechange = () => pc.iceGatheringState === 'complete' && resolve();
});
return pc.localDescription;
}Strona otwiera kanał i mierzy czas każdej wiadomości w obie strony:
const pc = new RTCPeerConnection();
// Bez kolejności, bez ponownego wysyłania: spóźniona wiadomość jest warta mniej niż następna.
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 += `w obie strony ${Math.round(performance.now() - sent)} ms\n`;
};
// Wyślij jedną ofertę ze wszystkimi kandydatami, bo serwer odpowiada raz.
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());Jej static/index.html to <pre id="log"></pre> i znacznik skryptu dla /channel.js. Na jednym komputerze w Chromium każda wiadomość wracała po 1 do 4 milisekund. W prawdziwej sieci to czas samej drogi, bez wiadomości wstrzymanej za tą, która zginęła, czego websocket przez TCP nie może obiecać.
Na Twoim serwerze oba programy potrzebują tego, czego potrzebuje każdy uczestnik rozmowy: serwera STUN, żeby poznać swój publiczny adres, i serwera TURN dla osób w restrykcyjnych sieciach, podanych w new RTCPeerConnection({ iceServers: [...] }) (Serwery STUN i TURN). Strona musi działać na localhost albo przez HTTPS, żeby kamera się otworzyła. Jeśli rozmowa się nie łączy, dlaczego połączenie WebRTC się nie udaje omawia, co sprawdzić.
Której roli potrzebujesz
- Twoi użytkownicy dzwonią do siebie nawzajem. Node.js jest serwerem sygnalizacji albo zostawia to usłudze. Rozmowę przenoszą przeglądarki, a Twój serwer decyduje, kto może dzwonić do kogo.
- Program dołącza do rozmowy. Rejestrator, bot, test, kamera na małym urządzeniu: Node.js jest uczestnikiem rozmowy, przez pakiet, który daje Ci media w potrzebnej postaci, a uruchamiasz go na własnych serwerach.
- Twój serwer rozmawia z każdą przeglądarką z jak najmniejszym opóźnieniem. Kanał danych do uczestnika w Node.js, dla gier i sterowania na żywo, obok websocketu albo zamiast niego.
Ten sam podział obowiązuje w innych językach: WebRTC w Pythonie to ten wpis dla Pythona, z aiortc jako uczestnikiem. Większość aplikacji internetowych potrzebuje pierwszej roli, a pracy jest mniej w samym przekaźniku niż wokół niego: dzwonek w każdej karcie, przekaźniki, ponowne łączenie, gdy telefon zmienia sieć, i rozmowy grupowe powyżej czterech osób.
Rozmowy w Expressie i Node.js z WordPlus Cloud
Z pakietem @wordplus/realtime aplikacja w Node.js wykonuje rozmowy między swoimi użytkownikami bez serwera sygnalizacji, przekaźnika i ekranu rozmowy do napisania, i bez własnego uczestnika do uruchamiania. Twoja aplikacja decyduje, kto może dzwonić, we własnej trasie, która zwraca token rozmowy. W Expressie:
// server.mjs: GET /call-token?to=34&type=video, o który pyta przycisk w chwili naciśnięcia.
app.get('/call-token', async (req, res) => {
// Tutaj Twoje własne sprawdzenie: kto może dzwonić do kogo.
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 }) });
});Strona uruchamia ekran rozmowy i umieszcza przycisk tam, skąd ludzie dzwonią, a ten pyta Twoją trasę:
await rt.callScreen(); // dzwonek i okno rozmowy, na każdej stronie, na której może zadzwonić rozmowa<call-button to="34" token-url="/call-token" type="video" name="Ann">Call Ann</call-button>Rozmowa dzwoni w każdej karcie i na każdym urządzeniu, które Ann ma otwarte. Idzie bezpośrednio między dwiema przeglądarkami, gdy pozwalają na to ich sieci, przez nasze przekaźniki na portach 443 i 80, gdy nie pozwalają, i przez nasze serwery mediów, gdy nawet przekaźniki nie mogą dotrzeć, przechodząc z jednej drogi na drugą bez rozłączania. Rozmowy między dwiema osobami są szyfrowane end-to-end na każdej drodze, a rozmowy grupowe działają na tych samych serwerach. Bez tokenu z Twojej trasy nic się nie zaczyna, więc nikt tego nie obejdzie.
Strona o rozmowach w przewodniku dla Expressa pokazuje resztę: kto może dzwonić, rozmowy grupowe z prowadzącym i własny interfejs rozmowy. Ten sam pakiet działa w czystym serwerze Node.js, w Fastify albo w Hono.
Rozmowy wideo dla Twojej aplikacji w Node.js
WordPlus Cloud for Apps ma cenę według jednoczesnych połączeń, od 1000 wzwyż, rozliczaną miesięcznie lub rocznie, a rozmowy między dwiema osobami nie zużywają kredytów na żadnej drodze. Zobacz rozmowy wideo i rozmowy grupowe dla aplikacji albo cennik dla aplikacji. Masz pytania o swoją integrację? Napisz do nas.