À propos de ce cours
Objectifs de la leçon
- Comprendre la différence entre HTTP et une connexion WebSocket.
- Échanger des événements avec Socket.IO :
emit,on, diffusion. - Brancher Socket.IO sur une application Express existante.
- Authentifier les connexions avec un jeton JWT et utiliser des salles.
- Tester et déployer une application temps réel.
Versions: Node.js 24 LTS, npm 11, Express 5, Mongoose 9, MongoDB 8.0, Supertest 7, Socket.IO 4.8, PM2 7, nginx 1.24 (Ubuntu 24.04). Le code de ce chapitre est celui de l'API de produits (TP 6, 8 et 9) : Express 5 en modules ES (import), Mongoose, authentification JWT avec les rôles admin et utilisateur, code réparti en routes, contrôleurs et services (séparation des couches). Toutes les commandes ont réellement été exécutées et leurs sorties sont reproduites telles quelles.
Pourquoi le temps réel ?
Avec HTTP, c'est toujours le client qui demande. Si un administrateur modifie un stock, les autres visiteurs ne voient rien tant qu'ils ne rechargent pas la page. On pourrait interroger l'API toutes les 5 secondes, mais la plupart de ces requêtes ne servent à rien et le changement arrive quand même en retard.
Le protocole WebSocket garde une connexion ouverte entre le navigateur et le serveur : chacun peut envoyer un message à tout moment. Socket.IO est la bibliothèque la plus utilisée pour cela en Node.js. Elle ajoute des événements nommés, la reconnexion automatique, des « salles » et un repli automatique sur des requêtes HTTP si le WebSocket est bloqué. Exemples d'usage : messagerie, notifications, tableau de bord, suivi de commande, jeu, édition à plusieurs.
HTTP contre WebSocket, et le parcours d'un événement dans l'API de produits.
Un premier échange
Dans un dossier à part (npm init -y, "type": "module"), installez le serveur et le client : npm install socket.io socket.io-client.
📄 serveur.js
import { createServer } from 'node:http';
import { Server } from 'socket.io';
const serveurHttp = createServer();
const io = new Server(serveurHttp);
io.on('connection', (socket) => {
console.log(`connexion de ${socket.id}`);
socket.emit('bienvenue', `Bonjour ${socket.id}`); // à ce client seulement
socket.on('message', (texte) => {
console.log(`message reçu de ${socket.id} : ${texte}`);
io.emit('message', { de: socket.id, texte }); // à TOUS les clients
});
socket.on('disconnect', (raison) => console.log(`déconnexion de ${socket.id} (${raison})`));
});
serveurHttp.listen(4000, () => console.log('Socket.IO écoute sur le port 4000'));
📄 client.js
import { io } from 'socket.io-client';
const nom = process.argv[2] ?? 'anonyme';
const socket = io('http://localhost:4000');
socket.on('connect', () => console.log(`[${nom}] connecté (${socket.id})`));
socket.on('bienvenue', (texte) => console.log(`[${nom}] ${texte}`));
socket.on('message', ({ de, texte }) => console.log(`[${nom}] ${de} dit : ${texte}`));
// le premier client envoie un message après une seconde
if (nom === 'Sami') setTimeout(() => socket.emit('message', 'Salut tout le monde !'), 1000);
setTimeout(() => socket.close(), 2000);
socket.emit(nom, données)envoie un événement ;socket.on(nom, fonction)le reçoit. Les données sont converties en JSON automatiquement.- Côté serveur,
socketreprésente un client ;ioreprésente tous les clients :socket.emitrépond à un seul,io.emitdiffuse à tout le monde. - Chaque connexion reçoit un identifiant unique,
socket.id.
Lancez node serveur.js, puis deux clients dans deux autres terminaux. Résultat réel :
$ node client.js Lina
[Lina] connecté (XDwizC06Z4d_rmKjAAAA)
[Lina] Bonjour XDwizC06Z4d_rmKjAAAA
[Lina] bWoRgMVEaQMp48ldAAAB dit : Salut tout le monde !
$ node client.js Sami
[Sami] connecté (bWoRgMVEaQMp48ldAAAB)
[Sami] Bonjour bWoRgMVEaQMp48ldAAAB
[Sami] bWoRgMVEaQMp48ldAAAB dit : Salut tout le monde !
$ node serveur.js
Socket.IO écoute sur le port 4000
connexion de XDwizC06Z4d_rmKjAAAA
connexion de bWoRgMVEaQMp48ldAAAB
message reçu de bWoRgMVEaQMp48ldAAAB : Salut tout le monde !
déconnexion de XDwizC06Z4d_rmKjAAAA (client namespace disconnect)
déconnexion de bWoRgMVEaQMp48ldAAAB (client namespace disconnect)
Le message de Sami est arrivé chez Lina sans qu'elle ait rien demandé : c'est le serveur qui l'a poussé.
Socket.IO dans l'API de produits
Socket.IO s'attache à un serveur HTTP. Au lieu de app.listen(), on crée ce serveur avec createServer(app) et on le partage entre Express et Socket.IO (voir server.js dans la leçon 16.2). Les deux utilisent le même port : les requêtes /api/… vont à Express, celles de /socket.io/… à Socket.IO.
Pour que les services n'aient pas à connaître Socket.IO, ils annoncent leurs changements sur un bus d'événements, un simple EventEmitter (la programmation événementielle avec EventEmitter) :
📄 src/evenements.js
import { EventEmitter } from 'node:events';
// Bus d'événements de l'application : les services annoncent, d'autres parties écoutent (ex. Socket.IO)
export const bus = new EventEmitter();
📄 src/services/produits.service.js (extrait)
export async function creer(donnees) {
const produit = (await Produit.create(donnees)).toObject();
bus.emit('produit:cree', produit);
return produit;
}
export async function modifier(id, donnees) {
verifierId(id);
const modifs = Object.fromEntries(Object.entries(donnees).filter(([cle]) => CHAMPS_MODIFIABLES.includes(cle)));
const produit = await Produit.findByIdAndUpdate(id, modifs, { returnDocument: 'after', runValidators: true }).lean();
if (!produit) throw new ErreurApi(404, 'Produit introuvable');
bus.emit('produit:modifie', produit);
return produit;
}
Le module temps réel écoute ce bus et transmet les événements aux clients connectés :
📄 src/temps-reel.js
import { Server } from 'socket.io';
import { bus } from './evenements.js';
import { verifierJeton } from './services/auth.service.js';
import { config } from './config/index.js';
const SEUIL_STOCK = 5;
export function brancherTempsReel(serveurHttp) {
const io = new Server(serveurHttp, { cors: { origin: config.corsOrigines } });
// Authentification facultative : un jeton valide fait entrer l'utilisateur dans la salle de son rôle
io.use((socket, next) => {
const jeton = socket.handshake.auth?.jeton;
if (!jeton) return next(); // visiteur anonyme : autorisé, sans salle
try {
const { sub, role, nom } = verifierJeton(jeton);
socket.data.utilisateur = { id: sub, role, nom };
next();
} catch {
next(new Error('Jeton invalide')); // la connexion est refusée
}
});
io.on('connection', (socket) => {
const u = socket.data.utilisateur;
if (u?.role === 'admin') socket.join('admins');
io.emit('visiteurs', io.engine.clientsCount);
socket.on('disconnect', () => io.emit('visiteurs', io.engine.clientsCount));
});
// Les services annoncent les changements ; on les diffuse à tous les clients connectés
bus.on('produit:cree', (p) => io.emit('produit:cree', p));
bus.on('produit:modifie', (p) => {
io.emit('produit:modifie', p);
if (p.stock < SEUIL_STOCK) io.to('admins').emit('stock:alerte', { _id: p._id, nom: p.nom, stock: p.stock });
});
bus.on('produit:supprime', (p) => io.emit('produit:supprime', p));
return io;
}
io.use()est un middleware de connexion, comme ceux d'Express. Il lit le jeton JWT envoyé par le client dansauthet le vérifie avec la même fonction que l'API. Sans jeton, la connexion est acceptée comme visiteur ; avec un jeton invalide, elle est refusée (next(new Error(…))).socket.dataconserve des informations sur le client pendant toute la connexion.- Les salles:
socket.join('admins')range le client dans un groupe ;io.to('admins').emit(...)n'envoie qu'à ce groupe. Ici, seuls les administrateurs reçoivent l'alerte de stock bas. io.engine.clientsCountdonne le nombre de connexions ouvertes, diffusé à chaque arrivée et départ.cors: comme pour l'API, une page servie par une autre origine doit être autorisée.
Le client dans le navigateur
Le serveur Socket.IO fournit automatiquement le client à l'adresse /socket.io/socket.io.js. La page est servie par express.static('public'). Le script est dans un fichier à part : la politique de sécurité (CSP) de helmet interdit les scripts écrits directement dans la page.
📄 public/temps-reel.html
<!doctype html>
<html lang="fr">
<head>
<meta charset="utf-8">
<title>Stock en temps réel</title>
<style>
body { font-family: system-ui, sans-serif; margin: 24px; color: #1e293b; }
header { display: flex; justify-content: space-between; align-items: center; }
#etat { padding: 4px 10px; border-radius: 999px; background: #fee2e2; color: #991b1b; font-size: 14px; }
#etat.connecte { background: #dcfce7; color: #166534; }
table { border-collapse: collapse; width: 100%; margin-top: 16px; }
th, td { border-bottom: 1px solid #e2e8f0; padding: 8px; text-align: left; }
td.stock { font-weight: 600; }
tr.flash { animation: flash 1.5s; }
@keyframes flash { from { background: #fef08a; } to { background: transparent; } }
.bas { color: #b91c1c; }
</style>
</head>
<body>
<header>
<h1>Stock en temps réel</h1>
<span id="etat">déconnecté</span>
</header>
<p><span id="visiteurs">0</span> visiteur(s) connecté(s)</p>
<table>
<thead><tr><th>Produit</th><th>Catégorie</th><th>Prix</th><th>Stock</th></tr></thead>
<tbody id="lignes"></tbody>
</table>
<!-- client Socket.IO servi automatiquement par le serveur ; pas de script dans la page (CSP de helmet) -->
<script src="/socket.io/socket.io.js"></script>
<script src="/temps-reel.js"></script>
</body>
</html>
📄 public/temps-reel.js
const lignes = document.getElementById('lignes');
// textContent (et non innerHTML) : un nom de produit ne peut pas injecter de HTML
const ligne = (p) => {
const tr = document.createElement('tr');
tr.id = 'p-' + p._id;
for (const texte of [p.nom, p.categorie, `${p.prix.toFixed(3)} DT`, p.stock]) {
const td = document.createElement('td');
td.textContent = texte;
tr.append(td);
}
tr.lastChild.className = 'stock' + (p.stock < 5 ? ' bas' : '');
return tr;
};
const flash = (tr) => { tr.classList.remove('flash'); void tr.offsetWidth; tr.classList.add('flash'); };
fetch('/api/produits?limite=50')
.then((r) => r.json())
.then(({ donnees }) => donnees.forEach((p) => lignes.append(ligne(p))));
const socket = io();
const etat = document.getElementById('etat');
socket.on('connect', () => { etat.textContent = 'connecté'; etat.className = 'connecte'; });
socket.on('disconnect', () => { etat.textContent = 'déconnecté'; etat.className = ''; });
socket.on('visiteurs', (n) => { document.getElementById('visiteurs').textContent = n; });
socket.on('produit:cree', (p) => { const tr = ligne(p); lignes.prepend(tr); flash(tr); });
socket.on('produit:modifie', (p) => {
const ancien = document.getElementById('p-' + p._id);
const tr = ligne(p);
ancien ? ancien.replaceWith(tr) : lignes.prepend(tr);
flash(tr);
});
socket.on('produit:supprime', ({ _id }) => document.getElementById('p-' + _id)?.remove());
Les noms de produits sont insérés avec textContent et non innerHTML: un administrateur malveillant ou un compte piraté ne peut pas injecter de HTML ou de JavaScript chez tous les visiteurs (faille XSS). Deux fenêtres sont ouvertes sur la page ; un administrateur passe le stock du smartphone à 3 et ajoute une tablette avec l'API :

Deux navigateurs mis à jour au même instant, sans rechargement : ligne modifiée et nouveau produit surlignés, stock bas en rouge (capture réelle).
Un client administrateur
Un client Socket.IO peut aussi être un programme Node.js : par exemple un outil interne qui affiche les alertes. Il envoie son jeton JWT au moment de la connexion :
📄 demo/admin-alertes.js
// Client Socket.IO d'un administrateur : node demo/admin-alertes.js <jeton>
import { io } from 'socket.io-client';
const socket = io('http://localhost:3000', { auth: { jeton: process.argv[2] } });
socket.on('connect', () => console.log('connecté en tant qu\'administrateur'));
socket.on('connect_error', (e) => console.log('connexion refusée :', e.message));
socket.on('stock:alerte', ({ nom, stock }) => console.log(`⚠ stock bas : ${nom} (${stock} restant(s))`));
socket.on('produit:modifie', (p) => console.log(`modifié : ${p.nom}, stock ${p.stock}`));
Résultat réellement obtenu :
$ node demo/admin-alertes.js $JETON_ADMIN
# (dans un autre terminal : stock du casque passé à 20, puis à 4)
connecté en tant qu'administrateur
modifié : Casque Bluetooth, stock 20
modifié : Casque Bluetooth, stock 4
⚠ stock bas : Casque Bluetooth (4 restant(s))
$ node demo/admin-alertes.js faux.jeton.jwt
connexion refusée : Jeton invalide
Le stock du casque passe à 20 (simple modification), puis à 4 : sous le seuil de 5, l'alerte est envoyée à la salle admins. Avec un faux jeton, la connexion est refusée par io.use().
Tester le temps réel
On teste les événements avec node:test, un vrai serveur sur un port libre (listen(0)) et socket.io-client. La fonction once() de node:events transforme « le prochain événement de ce nom » en promesse :
📄 test/temps-reel.test.js
import { describe, it, before, after } from 'node:test';
import assert from 'node:assert/strict';
import { createServer } from 'node:http';
import { once } from 'node:events';
import request from 'supertest';
import { io as clientIo } from 'socket.io-client';
import { app, ouvrirBase, fermerBase, jetonPour } from './aide.js';
import { brancherTempsReel } from '../src/temps-reel.js';
describe('temps réel (Socket.IO)', () => {
let serveur, io, url, admin;
const clients = [];
const connecter = (auth) => {
const c = clientIo(url, { auth, transports: ['websocket'], reconnection: false });
clients.push(c);
return c;
};
before(async () => {
await ouvrirBase('temps_reel');
admin = await jetonPour('admin');
serveur = createServer(app);
io = brancherTempsReel(serveur);
serveur.listen(0); // port libre choisi par le système
await once(serveur, 'listening');
url = `http://127.0.0.1:${serveur.address().port}`;
});
after(async () => {
clients.forEach((c) => c.close());
await io.close(); // ferme aussi le serveur HTTP
await fermerBase();
});
it('un visiteur anonyme reçoit les nouveaux produits', async () => {
const visiteur = connecter();
await once(visiteur, 'connect');
const recu = once(visiteur, 'produit:cree'); // on écoute AVANT de déclencher
await request(app).post('/api/produits').set('Authorization', `Bearer ${admin}`)
.send({ nom: 'Écran 27"', prix: 890, categorie: 'informatique', stock: 10 }).expect(201);
const [produit] = await recu;
assert.equal(produit.nom, 'Écran 27"');
});
it("seuls les administrateurs reçoivent l'alerte de stock bas", async () => {
const visiteur = connecter();
const gestionnaire = connecter({ jeton: admin });
await Promise.all([once(visiteur, 'connect'), once(gestionnaire, 'connect')]);
let alerteVisiteur = false;
visiteur.on('stock:alerte', () => { alerteVisiteur = true; });
const { body } = await request(app).get('/api/produits');
const alerte = once(gestionnaire, 'stock:alerte');
await request(app).patch(`/api/produits/${body.donnees[0]._id}`).set('Authorization', `Bearer ${admin}`).send({ stock: 2 });
const [donnees] = await alerte;
assert.equal(donnees.stock, 2);
await new Promise((r) => setTimeout(r, 100));
assert.equal(alerteVisiteur, false);
});
it('refuse un jeton invalide', async () => {
const pirate = connecter({ jeton: 'faux.jeton.jwt' });
const [erreur] = await once(pirate, 'connect_error');
assert.equal(erreur.message, 'Jeton invalide');
});
});
Résultat réellement obtenu :
$ node --env-file=.env.test --test test/temps-reel.test.js
▶ temps réel (Socket.IO)
✔ un visiteur anonyme reçoit les nouveaux produits (40.319909ms)
✔ seuls les administrateurs reçoivent l'alerte de stock bas (133.094679ms)
✔ refuse un jeton invalide (4.978649ms)
✔ temps réel (Socket.IO) (318.284817ms)
ℹ tests 3
ℹ pass 3
ℹ fail 0
ℹ duration_ms 913.766314
Et l'ensemble des tests du projet :
$ npm test
ℹ tests 25
ℹ pass 25
ℹ fail 0
Point délicat : on commence à écouter (once(...)) avant de déclencher l'action, sinon l'événement peut arriver avant que l'on écoute, et le test attend indéfiniment.
En production
- nginx doit transmettre les en-têtes
UpgradeetConnectionpour/socket.io/(leçon 16.2) ; sinon Socket.IO se rabat sur le long polling, plus coûteux. - Plusieurs instances (PM2 en mode cluster, plusieurs serveurs) : chaque processus ne connaît que ses propres clients. Il faut alors des sessions « collantes » (un client toujours envoyé au même processus) et l'adaptateur Redis (
@socket.io/redis-adapter) pour queio.emitatteigne les clients de tous les processus. Avec une seule instance, comme ici, rien de tout cela n'est nécessaire. - Plateformes cloud: les offres gratuites mettent en veille les services inactifs ; les connexions WebSocket sont alors coupées et les clients se reconnectent au réveil.
- Les connexions ouvertes consomment de la mémoire : limitez ce qui est envoyé (jamais d'objets complets inutiles) et vérifiez les droits dans
io.use()comme dans un middleware d'API.
Activités
Activité 1 emit, to ou broadcast ?
Côté serveur, dans io.on('connection', (socket) => { … }), quelle instruction utiliser pour envoyer un événement : (a) au client qui vient de se connecter ; (b) à tous les clients ; (c) à tous sauf celui qui vient d'envoyer un message ; (d) aux clients de la salle admins; (e) à un client précis dont on connaît l'identifiant ?
Voir le corrigé
(a) socket.emit('…', d); (b) io.emit('…', d); (c) socket.broadcast.emit('…', d); (d) io.to('admins').emit('…', d); (e) io.to(idDuSocket).emit('…', d): chaque client est automatiquement placé dans une salle qui porte son propre identifiant.
Activité 2 Notifier la suppression
Lorsqu'un produit est supprimé, l'administrateur qui l'a supprimé voit la ligne disparaître. Ajoutez un message « Produit supprimé » qui s'affiche quelques secondes dans la page de tous les visiteurs. Que faut-il modifier côté serveur ? Côté client ?
Voir le corrigé
Côté serveur : rien, l'événement produit:supprime est déjà diffusé. On peut l'enrichir avec le nom du produit dans le service : bus.emit('produit:supprime', { _id: produit._id, nom: produit.nom }). Côté client : un élément <p id="message"> dans la page, et dans temps-reel.js: socket.on('produit:supprime', ({ _id, nom }) => { document.getElementById('p-' + _id)?.remove(); const m = document.getElementById('message'); m.textContent = `${nom} a été supprimé`; setTimeout(() => { m.textContent = ''; }, 3000); });
Activité 3 Une alerte dans la page
Faites afficher l'alerte de stock bas dans la page temps réel, seulement pour un administrateur connecté. Le jeton est enregistré dans localStorage par le client SPA du TP 10 (clé jeton).
Voir le corrigé
Dans temps-reel.js, connectez-vous avec le jeton s'il existe : const socket = io({ auth: { jeton: localStorage.getItem('jeton') } }); (pour un visiteur, null: connexion anonyme). Puis socket.on('stock:alerte', ({ nom, stock }) => afficher(`Stock bas : ${nom} (${stock})`));. Un visiteur ne reçoit jamais cet événement : le tri est fait par le serveur (salle admins), pas par le client. Gérez aussi socket.on('connect_error', …): un jeton expiré fait refuser la connexion ; supprimez-le alors de localStorage et reconnectez-vous en visiteur.
Activité 4 Une mini-messagerie
Ajoutez à l'API une messagerie entre utilisateurs connectés : un client envoie message avec un texte ; le serveur le diffuse à tous avec le nom de l'auteur (lu dans le jeton) et l'heure. Les visiteurs anonymes peuvent lire mais pas écrire. Écrivez le code serveur et un test.
Voir le corrigé
// dans io.on('connection', (socket) => { … })
socket.on('message', (texte, accuse) => {
const u = socket.data.utilisateur;
if (!u) return accuse?.({ erreur: 'Connexion requise' });
const propre = String(texte).trim().slice(0, 500);
if (!propre) return accuse?.({ erreur: 'Message vide' });
io.emit('message', { auteur: u.nom, texte: propre, date: new Date().toISOString() });
accuse?.({ ok: true });
});
Le second paramètre accuse est un accusé de réception: le client l'obtient avec const r = await socket.emitWithAck('message', 'Bonjour');. Test : un client anonyme reçoit { erreur: 'Connexion requise' }; un client avec jeton reçoit { ok: true } et un autre client reçoit l'événement message avec le bon auteur. Ne faites jamais confiance au nom envoyé par le client : il vient du jeton.
À retenir
- WebSocket : une connexion ouverte dans les deux sens ; Socket.IO ajoute événements nommés, reconnexion, salles et repli HTTP.
socket.emit(un client),io.emit(tous),io.to(salle).emit(une salle),socket.onpour recevoir.- Un seul serveur HTTP partagé :
createServer(app)puisnew Server(serveur). - Les services annoncent les changements sur un
EventEmitter; le module temps réel les diffuse. io.use()pour authentifier avec JWT ;textContentcôté client contre le XSS.- Tests avec
socket.io-clientetonce(); en production, en-têtes WebSocket dans nginx et une seule instance (ou Redis).
Cet article vous a-t-il aidé ?
Merci pour votre avis sur cet article 🙏
Merci, votre message nous a bien été transmis 🙏
Cette leçon vous a été utile ? Partagez-la !