Avez-vous une question? (216) 97 656 803 hajjriadh@gmail.com
Node.js

Pour aller plus loin : le temps réel avec Socket.IO

Cette leçon ajoute le temps réel à l'API de produits avec Socket.IO. Après la différence entre HTTP et WebSocket, un premier exemple en ligne de commande montre la connexion, l'envoi à un client et la...

0 chapitres 0 QCM Accès gratuit
Pour aller plus loin : le temps réel avec Socket.IO

À propos de ce cours

Cette leçon ajoute le temps réel à l'API de produits avec Socket.IO. Après la différence entre HTTP et WebSocket, un premier exemple en ligne de commande montre la connexion, l'envoi à un client et la diffusion à tous. Socket.IO est ensuite branché sur le serveur Express : les services annoncent leurs changements avec un EventEmitter, une page affiche le stock mis à jour sans rechargement (capture réelle de deux fenêtres), les administrateurs authentifiés par JWT rejoignent une salle qui reçoit les alertes de stock bas. La leçon teste ces échanges avec node:test et précise les contraintes de déploiement. Activités corrigées.

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.

Le temps réel avec Socket.IO

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, socket représente un client ; io représente tous les clients : socket.emit répond à un seul, io.emit diffuse à 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 dans auth et 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.data conserve 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.clientsCount donne 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 fenêtres mises à jour en même temps

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 Upgrade et Connection pour /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 que io.emit atteigne 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.on pour recevoir.
  • Un seul serveur HTTP partagé : createServer(app) puis new Server(serveur).
  • Les services annoncent les changements sur un EventEmitter; le module temps réel les diffuse.
  • io.use() pour authentifier avec JWT ; textContent côté client contre le XSS.
  • Tests avec socket.io-client et once(); en production, en-têtes WebSocket dans nginx et une seule instance (ou Redis).

Cet article vous a-t-il aidé ?