Socket.IO donne l'impression d'être "temps réel et ça marche tout seul" jusqu'au premier déploiement avec deux instances serveur derrière un load balancer, ou au premier utilisateur qui passe dans un tunnel avec une coupure réseau de trois secondes. Les événements se perdent silencieusement, les notifications arrivent en double, ou certains clients ne reçoivent plus rien du tout après une reconnexion. Aucun de ces symptômes n'est un bug de la librairie : c'est l'absence de design explicite autour de la reconnexion et de la distribution des événements entre instances.
Ce que "connecté" ne garantit pas
Un socket Socket.IO peut se déconnecter pour de nombreuses raisons : coupure réseau, mise en veille du téléphone, timeout de ping, ou le serveur qui le ferme volontairement (io server disconnect). Le client reconnecte automatiquement par défaut, mais chaque reconnexion crée une nouvelle session avec un nouvel identifiant de socket, sauf configuration explicite. Pendant la fenêtre de déconnexion, tout événement émis par le serveur vers ce socket est perdu, pas mis en file d'attente.
// client
import { io } from "socket.io-client";
const socket = io("https://realtime.example.com", {
reconnection: true,
reconnectionAttempts: Infinity,
reconnectionDelay: 1000,
reconnectionDelayMax: 10000,
randomizationFactor: 0.5,
timeout: 20000,
});
socket.on("disconnect", (reason) => {
console.log("disconnected:", reason);
// "io server disconnect" => le serveur a fermé explicitement,
// il faut reconnecter manuellement (reconnection auto désactivée dans ce cas précis)
if (reason === "io server disconnect") {
socket.connect();
}
});
socket.on("connect", () => {
console.log("connected, socket id:", socket.id);
});
Le backoff exponentiel avec randomizationFactor n'est pas cosmétique : sans lui, un redémarrage serveur provoque une vague synchronisée de milliers de reconnexions simultanées (thundering herd) qui peut re-faire tomber le serveur qu'on vient de relancer.
Récupérer les événements manqués
Depuis Socket.IO 4.6, la connection state recovery permet de restaurer l'état d'une session côté serveur pendant une courte fenêtre après déconnexion, et de rejouer les événements émis pendant la coupure, à condition que le serveur ait gardé ces événements en mémoire tampon.
// serveur
import { Server } from "socket.io";
const io = new Server(httpServer, {
connectionStateRecovery: {
maxDisconnectionDuration: 2 * 60 * 1000, // 2 minutes
skipMiddlewares: true,
},
});
io.on("connection", (socket) => {
if (socket.recovered) {
console.log("session restaurée, événements manqués rejoués automatiquement");
} else {
console.log("nouvelle session (ou fenêtre de récupération expirée)");
}
});
Cette mécanique couvre les coupures courtes (tunnel, changement de réseau wifi/4G). Pour des événements critiques métier (paiement validé, message envoyé), il ne faut pas s'appuyer uniquement dessus : la bonne pratique reste de persister l'événement en base avec un identifiant monotone côté client, et de faire un "catch-up" explicite à la reconnexion (GET /events?since=lastSeenId) plutôt que de faire confiance à un buffer en mémoire qui disparaît si le processus serveur redémarre.
Le problème caché de la scalabilité horizontale
Dès qu'il y a plus d'une instance serveur, deux clients connectés sur deux instances différentes ne partagent par défaut aucun état. Si l'instance A veut notifier un utilisateur connecté sur l'instance B, l'émission io.to(room).emit(...) lancée depuis A n'atteint jamais le socket de B, parce que chaque instance Node.js a sa propre table de rooms en mémoire.
// serveur, avec adapter Redis pour la distribution inter-instances
import { createAdapter } from "@socket.io/redis-adapter";
import { createClient } from "redis";
const pubClient = createClient({ url: process.env.REDIS_URL });
const subClient = pubClient.duplicate();
await Promise.all([pubClient.connect(), subClient.connect()]);
io.adapter(createAdapter(pubClient, subClient));
// maintenant io.to("room:42").emit(...) atteint les sockets
// connectés sur n'importe quelle instance du cluster
L'adapter Redis fait transiter les émissions broadcast et les événements de room via Redis pub/sub, donc chaque instance reçoit et relaie les messages destinés à ses propres sockets. C'est transparent côté code applicatif : on continue d'écrire io.to(room).emit(...) normalement.
Régler le heartbeat : détection de coupure vs faux positifs
Socket.IO détecte une déconnexion via un mécanisme de ping/pong : le serveur envoie un ping toutes les pingInterval millisecondes, et considère le client perdu s'il ne répond pas dans le délai pingTimeout. Ces deux valeurs par défaut (25s et 20s respectivement) sont un compromis, pas une vérité universelle.
// serveur
const io = new Server(httpServer, {
pingInterval: 10000, // ping toutes les 10s
pingTimeout: 5000, // déclare la déconnexion après 5s sans pong
});
Réduire ces valeurs accélère la détection d'un client réellement perdu (utile pour une app de présence en temps réel où "en ligne" doit refléter la réalité à quelques secondes près), mais augmente le risque de faux positifs sur un réseau mobile avec de la latence variable : un pic de latence de 6 secondes sur une 4G dégradée déclenche une déconnexion/reconnexion complète, alors que la connexion sous-jacente aurait fini par répondre. Augmenter les délais réduit les faux positifs mais retarde la détection d'un client mort, ce qui compte directement pour des fonctionnalités comme "liste des utilisateurs actuellement connectés". Le bon réglage se détermine en observant la distribution réelle de latence des clients en production, pas en copiant une valeur par défaut.
Autoriser l'accès aux rooms, pas seulement s'y connecter
Un piège de sécurité fréquent : laisser le client choisir librement la room à laquelle il rejoint via socket.join(roomName) envoyé depuis le client, sans vérification serveur. N'importe quel client connecté peut alors rejoindre la room d'un autre utilisateur et recevoir ses événements.
// incorrect : le serveur fait confiance à la room demandée par le client
socket.on("join", (roomName) => {
socket.join(roomName); // aucune vérification d'autorisation
});
// correct : le serveur résout la room à partir de l'identité authentifiée,
// jamais à partir d'une valeur arbitraire envoyée par le client
io.use(async (socket, next) => {
const token = socket.handshake.auth?.token;
try {
socket.data.user = await verifyToken(token);
next();
} catch {
next(new Error("unauthorized"));
}
});
socket.on("join-conversation", async (conversationId) => {
const allowed = await userCanAccessConversation(socket.data.user.id, conversationId);
if (!allowed) return socket.emit("error", "forbidden");
socket.join(`conversation:${conversationId}`);
});
Le middleware io.use() s'exécute à chaque connexion, avant tout handler d'événement, et c'est l'endroit correct pour authentifier le socket une fois pour toute la durée de la connexion, plutôt que de vérifier un token à chaque événement individuel.
Le détail qui casse tout : les sticky sessions
Socket.IO négocie d'abord en HTTP long-polling avant d'upgrader vers WebSocket (sauf si on force transports: ["websocket"]). Cette négociation en plusieurs requêtes HTTP successives doit systématiquement atteindre la même instance serveur, sinon le handshake échoue. Sans affinité de session au niveau du load balancer, on observe des connexions qui échouent de façon intermittente, en particulier derrière un reverse proxy round-robin.
upstream socketio_nodes {
ip_hash;
server app1:3000;
server app2:3000;
server app3:3000;
}
server {
location /socket.io/ {
proxy_pass http://socketio_nodes;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
proxy_set_header Host $host;
}
}
ip_hash fonctionne pour un déploiement simple, mais devient fragile avec des clients derrière un NAT partagé (tout un bureau se retrouve collé à la même instance) ou avec IPv6. En environnement Kubernetes, l'alternative la plus robuste est une affinité par cookie au niveau de l'ingress, ou forcer directement transports: ["websocket"] côté client pour éviter entièrement la phase de polling multi-requêtes (au prix de la compatibilité avec les réseaux qui bloquent les WebSockets).
Diagnostiquer en production
Les symptômes de scalabilité mal gérée sont reconnaissables : des notifications qui n'arrivent qu'à certains utilisateurs de façon apparemment aléatoire (dépend de l'instance sur laquelle ils sont tombés), des taux de reconnexion anormalement élevés dans les métriques du load balancer, ou des erreurs de handshake qui augmentent avec le nombre d'instances. Activer les logs du moteur Engine.IO côté serveur (DEBUG=socket.io:* node server.js) permet de voir précisément à quelle étape de la négociation une connexion échoue.
Quand la solution simple ne suffit pas
Redis pub/sub résout la distribution des événements mais ne résout pas la livraison garantie : si une instance tombe entre l'émission et la réception par Redis, l'événement est perdu, Redis pub/sub n'a pas de mémoire de ce qui n'a pas été consommé. Pour des cas où la perte d'un message n'est pas acceptable (facturation, synchronisation d'état critique), il faut sortir du modèle "broadcast éphémère" et passer par une file de messages persistante (Redis Streams, ou une queue dédiée) consommée de façon fiable, avec Socket.IO réduit à son vrai rôle : le dernier kilomètre vers le navigateur, pas le système de livraison garanti.
Socket.IO gère très bien le temps réel occasionnel et les mises à jour d'UI non critiques dès qu'on configure correctement la reconnexion, la récupération d'état et l'adapter Redis. Pour tout ce qui doit être livré de façon garantie, mieux vaut le traiter comme tel dès la conception plutôt que de découvrir la limite en production.
