WebRTC en Node.js : signalisation, pairs et paquets npm

Node.js n’a pas de WebRTC à lui : il a un client WebSocket intégré, mais pas de RTCPeerConnection. Node.js prend donc part à un appel de l’une de deux façons. Soit il est le serveur de signalisation qui fait passer les offres et les adresses entre deux navigateurs, ce qui ne demande qu’une bibliothèque websocket. Soit il est un pair à part entière, grâce à un paquet npm qui apporte la pile WebRTC avec lui.
Cet article montre où chacun a sa place, trois paquets qui font de Node.js un pair et ce que chacun donne à votre code, deux courts programmes testés avec Chromium, puis comment une application Express ajoute des appels entre ses utilisateurs sans aucun des deux.
Les deux rôles de Node.js dans un appel
| Rôle | Qui porte les médias | Ce qu’il faut |
|---|---|---|
| Serveur de signalisation | Les deux navigateurs | Une bibliothèque websocket, comme ws |
| Pair de l’appel | Node.js lui-même | Un paquet WebRTC de npm |
Lancez node -e "console.log(typeof RTCPeerConnection, typeof WebSocket)" avec Node.js 22 et il affiche undefined function. L’API du navigateur qui porte les appels n’y est pas, si bien que du code écrit pour le navigateur ne peut pas simplement tourner sur le serveur.
Pour un chat vidéo entre les utilisateurs d’une application web, le serveur n’en a aucun besoin. L’appel va d’un navigateur à l’autre, et Node.js les aide seulement à se trouver : comment WebRTC relie deux navigateurs contient tout ce relais en Node.js avec le paquet ws, et la page qui s’en sert. Le relais est la partie facile. Faire sonner la personne dans chaque onglet qu’elle a ouvert ne l’est pas, car il faut une connexion gardée ouverte pour chaque utilisateur, et dès que vous faites tourner plus d’un processus, ces connexions se répartissent entre eux (les websockets en Node.js au-delà d’un serveur passe en revue ce que cela demande).
Un pair sert aux programmes qui ont besoin eux-mêmes des médias ou du canal : un enregistreur, un bot qui rejoint un appel, un test qui en passe un depuis un script, un serveur de jeu qui parle à chaque joueur par un canal de données.
Les paquets npm qui font de Node.js un pair
Chacun d’eux est open source et donne à Node.js le RTCPeerConnection du navigateur, l’offre, la réponse et les candidates s’échangeant comme dans un navigateur. Ils diffèrent par ce sur quoi ils reposent, et donc par ce que reçoit votre code :
| Paquet | Ce que reçoit votre code |
|---|---|
| werift 0.28 | Les médias en paquets RTP, canaux de données |
| node-datachannel 0.33 | Canaux de données, et son propre WebSocket |
| @roamhq/wrtc 0.10 | Images et son décodés, canaux de données |
Ce que chacun dit de lui-même, et ce que nous avons vu en les faisant tourner :
- werift est écrit en TypeScript, demande Node.js 22 ou plus récent et n’installe rien de natif. Il vous remet chaque paquet de la vidéo à son arrivée, encore encodé, et envoie les paquets que vous lui donnez. C’est ce dont a besoin la transmission, et c’est ainsi que fonctionne un serveur multimédia pour les appels de groupe : il fait suivre la vidéo sans jamais la décoder (comment fonctionnent les appels vidéo de groupe).
- node-datachannel relie libdatachannel, une petite bibliothèque C++, avec des binaires précompilés pour Linux, macOS et Windows sur Node.js 18.20 ou plus récent. Son export
node-datachannel/polyfilldonne l’API du navigateur, et son README liste un client et un serveur WebSocket à lui, pour la signalisation. - @roamhq/wrtc est un fork de l’ancien projet node-webrtc, relié à la version 106 de la bibliothèque WebRTC de Google, de 2022, avec des binaires précompilés pour Linux et macOS en x64 et arm64, et pour Windows en x64. À côté de l’API standard, il a des sources et des puits non standard : nous lui avons fait recevoir la caméra d’un navigateur et il nous a donné chaque image décodée, en 640 sur 480, sous forme d’octets bruts.
Le choix découle du rôle. Pour faire suivre les médias, ou les enregistrer tels qu’ils arrivent, les paquets suffisent. Pour lire ce qu’il y a dans l’image, ou dessiner dessus, il vous la faut décodée, au prix du travail du processeur pour chaque image. Pour les données seules, une petite bibliothèque fait l’affaire.
Node.js comme pair : une vidéo qui revient
Le programme ci-dessous répond à un navigateur avec werift et lui renvoie sa vidéo directement, chaque paquet passant par Node.js sans être décodé (npm install werift). Il utilise le module http de Node.js pour la seule requête dont l’échange a besoin :
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 }) => {
// Chaque paquet de la vidéo du navigateur repart tout de suite, jamais décodé.
track.onReceiveRtp.subscribe((rtp) => transceiver.sender.sendRtp(rtp));
// Demander de temps en temps une image complète au navigateur, pour que l’autre côté puisse commencer à afficher.
const timer = setInterval(() => transceiver.receiver.sendRtcpPLI(track.ssrc), 3000);
pc.onconnectionstatechange = () => {
if (['failed', 'closed'].includes(pc.connectionState)) clearInterval(timer);
};
};
await pc.setRemoteDescription(offer);
// Envoyer autant que recevoir sur la ligne vidéo que le navigateur a proposée.
for (const transceiver of pc.getTransceivers()) transceiver.direction = 'sendrecv';
await pc.setLocalDescription(await pc.createAnswer());
// Attendre toutes les candidates, pour qu’elles partent toutes dans la seule réponse.
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))));
}
// La page et son script, depuis le dossier 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);La page va dans static/index.html, avec deux éléments vidéo et le 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]);
};
// Le côté Node.js prend une seule offre contenant toutes les candidates, donc on les attend toutes.
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());Lancez node echo.mjs et ouvrez http://localhost:8081/. Le navigateur demande la caméra, et un instant plus tard la seconde vidéo montre la première, revenue de Node.js. Nous l’avons fait tourner dans Chromium avec une fausse caméra : l’image est revenue en 640 pixels de large, et le nombre d’images affichées n’a pas cessé de monter, environ 20 par seconde.
Trois lignes y sont pour une raison précise :
- Le sens. Une réponse faite sans piste à elle ne fait que recevoir, alors le programme passe la ligne vidéo en
sendrecvavant de répondre. Sans cette ligne, le navigateur ne recevait rien en retour. - La demande d’une image complète. La vidéo est envoyée surtout sous forme de changements par rapport à l’image précédente. Un programme qui ne décode rien ne peut pas fabriquer lui-même une image complète, alors il en demande une à l’émetteur de temps en temps, ce qui permet à l’autre côté de commencer, ou de se rétablir après un paquet perdu. Les serveurs multimédias font de même.
- Une seule requête fait tout l’échange. Le navigateur envoie toutes ses candidates dans son offre et Node.js toutes les siennes dans sa réponse, si bien qu’un simple POST suffit et qu’aucun websocket n’est nécessaire pour ce programme.
Node.js comme pair : un canal de données
Un canal de données ne demande aucun média. Avec node-datachannel (npm install node-datachannel), le serveur ci-dessous répond à un navigateur sur un canal sans ordre et sans renvoi, celui qu’un jeu utilise pour les positions, où un message en retard vaut moins que le suivant :
// channel.mjs : le même serveur que echo.mjs, avec ceci à la place de son import et de answer()
import { RTCPeerConnection } from 'node-datachannel/polyfill';
async function answer(offer) {
const pc = new RTCPeerConnection();
pc.ondatachannel = ({ channel }) => {
channel.onmessage = ({ data }) => {
// Répondre à chaque message aussitôt, avec l’horloge du serveur.
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());
// Attendre toutes les candidates, pour qu’elles partent toutes dans la seule réponse.
await new Promise((resolve) => {
if (pc.iceGatheringState === 'complete') return resolve();
pc.onicegatheringstatechange = () => pc.iceGatheringState === 'complete' && resolve();
});
return pc.localDescription;
}La page ouvre le canal et mesure chaque aller-retour :
const pc = new RTCPeerConnection();
// Sans ordre, jamais renvoyé : un message en retard vaut moins que le suivant.
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 += `aller-retour ${Math.round(performance.now() - sent)} ms\n`;
};
// Envoyer une seule offre contenant toutes les candidates, car le serveur ne répond qu’une fois.
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());Son static/index.html est un <pre id="log"></pre> et une balise script pour /channel.js. Sur une seule machine, dans Chromium, chaque aller-retour a pris de 1 à 4 millisecondes. Sur un vrai réseau, c’est le temps du chemin lui-même, sans message retenu derrière un autre qui s’est perdu, ce qu’un websocket sur TCP ne peut pas promettre.
Sur un serveur à vous, les deux programmes ont besoin de ce dont a besoin tout pair : un serveur STUN pour connaître leur adresse publique, et un serveur TURN pour les personnes derrière des réseaux stricts, donnés dans new RTCPeerConnection({ iceServers: [...] }) (les serveurs STUN et TURN, expliqués). La page doit être sur localhost ou en HTTPS pour que la caméra s’ouvre. Si un appel ne se connecte pas, pourquoi une connexion WebRTC échoue passe en revue ce qu’il faut vérifier.
Celui qu’il vous faut
- Vos utilisateurs s’appellent entre eux. Node.js est le serveur de signalisation, ou le confie à un service. Les navigateurs transportent l’appel, et votre serveur décide qui peut appeler qui.
- Un programme rejoint l’appel. Un enregistreur, un bot, un test, une caméra sur un petit appareil : Node.js est un pair, grâce au paquet qui vous remet les médias sous la forme dont vous avez besoin, et vous le faites tourner sur vos propres serveurs.
- Votre serveur parle à chaque navigateur avec le moins de délai possible. Un canal de données vers un pair Node.js, pour les jeux et les commandes en direct, à côté d’un websocket ou à sa place.
Le même partage vaut dans d’autres langages : WebRTC en Python est cet article pour Python, avec aiortc comme pair. La plupart des applications web ont besoin du premier, et le travail tient moins au relais qu’à tout ce qui l’entoure : la sonnerie dans chaque onglet, les relais, la reconnexion quand un téléphone change de réseau, et les appels de groupe au-delà de quatre personnes.
Des appels dans Express et Node.js avec WordPlus Cloud
Avec le paquet @wordplus/realtime, une application Node.js passe des appels entre ses utilisateurs sans serveur de signalisation, sans relais ni écran d’appel à écrire, et sans pair à elle à faire tourner. Votre application décide qui peut appeler dans une route à elle, qui renvoie un jeton pour l’appel. Dans Express :
// server.mjs : GET /call-token?to=34&type=video, que le bouton interroge quand on appuie dessus.
app.get('/call-token', async (req, res) => {
// Votre propre vérification va ici : qui peut appeler qui.
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 }) });
});La page démarre l’écran d’appel et pose un bouton là d’où les gens appellent, qui interroge votre route :
await rt.callScreen(); // la sonnerie et la fenêtre d’appel, sur chaque page où un appel peut sonner<call-button to="34" token-url="/call-token" type="video" name="Ann">Call Ann</call-button>L’appel sonne dans chaque onglet et sur chaque appareil qu’Ann a ouverts. Il passe directement entre les deux navigateurs quand leurs réseaux le permettent, par nos relais sur les ports 443 et 80 quand ils ne le permettent pas, et par nos serveurs multimédias quand même les relais ne passent pas, en basculant de l’un à l’autre sans raccrocher. Les appels entre deux personnes sont chiffrés de bout en bout sur chaque chemin, et les appels de groupe passent par les mêmes serveurs. Sans jeton de votre route, rien ne démarre, si bien que personne ne peut la contourner.
La page sur les appels du guide Express montre le reste : qui peut appeler, les appels de groupe avec un hôte, et une interface d’appel à vous. Le même paquet tourne dans un serveur Node.js pur, dans Fastify ou dans Hono.
Des appels vidéo pour votre application Node.js
WordPlus Cloud for Apps a un prix selon les connexions simultanées, à partir de 1 000, facturé au mois ou à l’année, et les appels entre deux personnes ne prennent aucun crédit, quel que soit le chemin. Découvrez les appels vidéo et les appels de groupe pour les applications, ou les tarifs pour les applications. Des questions sur votre intégration ? Écrivez-nous.