Aller au contenu
Blog

Engineering

Architecture temps réel : WebSockets, SSE et passage à l'échelle au-delà de la démo

Choisissez le bon transport pour le chat, les tableaux de bord et la présence. Des patterns d'architecture concrets pour des fonctionnalités temps réel qui tiennent sous une vraie charge.

Par Pykero Agency · Engineering team8 juil. 20265 min de lecture

TL;DR

SSE couvre la plupart des cas d'usage serveur vers client avec bien moins de complexité que WebSockets. Utilisez WebSockets quand les clients envoient aussi fréquemment des données, ajoutez un bus pub/sub dès que vous déployez plus d'un serveur, et concevez la reconnexion dès le premier jour.

Flux de données en direct circulant entre des clients connectés sur un fond bleu marine profond

Le bon transport pour une fonctionnalité temps réel dépend d'une seule question : les données circulent-elles dans un sens ou dans les deux ? Server-Sent Events gère la plupart des cas d'usage serveur vers client avec moins de complexité que les équipes ne l'anticipent. WebSockets est le bon choix quand les clients envoient aussi fréquemment des données, mais y recourir par défaut ajoute un poids opérationnel dont vous n'avez peut-être pas besoin.

Faites correspondre le transport au sens de circulation des données

SSE est un flux unidirectionnel du serveur vers le client via HTTP standard. Il se reconnecte automatiquement, fonctionne à travers la plupart des proxies et des load balancers sans configuration particulière, et ne nécessite aucune mise à niveau de protocole. Les notifications, les flux en direct, les flux d'activité et les tableaux de bord en lecture seule entrent tous dans cette catégorie. C'est la bonne réponse plus souvent que sa réputation ne le laisse entendre.

WebSockets ouvre une connexion persistante en duplex intégral. Utilisez-les pour le chat, le multijoueur, l'édition collaborative et les curseurs en direct : tout ce où le client envoie en permanence un flux d'événements vers le serveur. La bidirectionnalité est l'essentiel.

Le polling (et son cousin le long-polling) interroge le serveur à intervalles réguliers. C'est rudimentaire et consommateur de ressources, mais c'est parfois le choix pragmatique pour des mises à jour peu fréquentes ou dans des environnements où les connexions persistantes sont peu fiables. Ne l'utilisez pas par défaut.

La règle pratique : si les clients ne font que recevoir, SSE. Si les clients envoient aussi en permanence, WebSockets.

Les couches temps réel gérées existent pour une bonne raison

Les connexions persistantes sont faciles à prototyper et véritablement difficiles à opérer. Avant d'écrire votre propre serveur WebSocket, il vaut la peine de comprendre ce à quoi vous vous engagez : gestion du cycle de vie des connexions, heartbeats, arrêt gracieux, contre-pression et le problème de mise à l'échelle décrit ci-dessous.

Les couches gérées résolvent la majeure partie de tout cela :

  • Supabase Realtime diffuse les changements de lignes Postgres et l'état de présence via WebSockets avec presque aucun code serveur, une solution naturelle si vous utilisez déjà Supabase
  • Pusher, Ably et similaires gèrent pour vous la mise à l'échelle des connexions, les garanties de livraison et la distribution, à un tarif par message ou par connexion
  • Les options au niveau du framework (Action Cable, Laravel Echo, etc.) vous offrent une intégralité fonctionnelle temps réel intégrée à votre stack existante

Construire votre propre solution se justifie par des exigences spécifiques ou des raisons économiques d'échelle, pas par une préférence pour le contrôle.

Le pattern d'architecture qui passe à l'échelle

Un serveur gérant une poignée de connexions WebSocket, c'est simple. Dix serveurs gérant chacun dix mille connexions, c'est un problème différent. Un client connecté au serveur A doit recevoir les messages publiés sur le serveur B. Sans couche partagée, c'est impossible.

La solution standard est un bus pub/sub, généralement Redis, placé derrière vos serveurs de connexion :

  1. Chaque serveur de connexion gère ses propres connexions clientes ouvertes
  2. Quand un événement se produit, l'application le publie sur un canal Redis
  3. Chaque serveur de connexion s'abonne et pousse le message vers les clients qu'il héberge

Cela sépare "qui est connecté où" de "ce qui doit être livré", ce qui vous permet d'ajouter des serveurs de connexion horizontalement sans qu'aucun d'eux n'ait besoin de connaître les autres. Les services temps réel gérés implémentent ce pattern en interne, vous ne le voyez jamais, et c'est une grande partie de ce pour quoi vous payez.

Pour les équipes qui construisent sur Next.js et NestJS, ce pattern s'applique naturellement : NestJS gère la passerelle WebSocket et publie vers Redis ; chaque instance de la passerelle s'abonne et redistribue à ses propres clients. Le choix entre microservices et monolithe influe sur l'emplacement de cette passerelle, mais le pattern pub/sub lui-même reste identique dans les deux cas.

Les points de défaillance qui tuent les fonctionnalités temps réel en production

La plupart des problèmes liés à "le temps réel, c'est compliqué" viennent du fait que l'on a omis la couche de fiabilité, pas d'avoir choisi le mauvais transport.

La reconnexion. Les réseaux mobiles se coupent. Les ordinateurs portables se mettent en veille. Les proxies ferment les connexions inactives. Les clients doivent se reconnecter automatiquement avec un backoff exponentiel. Si votre bibliothèque cliente ne le fait pas, écrivez-le vous-même. Ce n'est pas optionnel.

Les messages manqués. Après une reconnexion, le client a un trou dans son historique. Deux façons de le combler : rejouer les événements depuis un curseur ou horodatage que le client envoie à la reconnexion, ou récupérer l'état complet à la reconnexion en repartant d'une base propre. Le bon choix dépend du coût d'une récupération complète. Pour la plupart des tableaux de bord, la récupération est plus simple. Pour le chat, le rejeu est attendu.

La présence. "Qui est en ligne" nécessite des heartbeats côté client et un timeout côté serveur pour détecter les déconnexions silencieuses. Un utilisateur dont la connexion se coupe sans fermeture propre apparaîtra sinon comme connecté indéfiniment. Supabase Realtime et Ably gèrent cela ; si vous le construisez vous-même, prenez-le en compte explicitement.

L'ordre et les conflits. Pour l'édition collaborative, vous avez besoin d'une stratégie pour les écritures simultanées. Le dernier écrit gagne est simple et souvent acceptable. Les CRDTs ou la transformation opérationnelle gèrent la véritable édition concurrente sans perte de données, mais ils ajoutent une complexité significative. La plupart des produits n'en ont pas besoin.

L'authentification. Authentifiez lors de la négociation initiale et autorisez chaque abonnement à un canal côté serveur. Ne faites pas confiance aux noms de canaux ou aux identifiants de salles envoyés par le client sans les valider par rapport aux permissions de l'utilisateur. C'est le même principe que la conception d'API sécurisée appliqué à l'état des connexions.

La voie pratique

Utilisez le transport le plus simple qui répond au besoin réel, SSE bien plus souvent que les équipes ne le font par défaut. Appuyez-vous sur une couche temps réel gérée, sauf si les contraintes économiques ou techniques vous en éloignent. Concevez la reconnexion et la gestion des trous de messages avant de mettre en production, pas après la première réclamation. Ces trois décisions résolvent la majeure partie de la complexité avant même que vous n'écriviez une ligne de code de gestion des connexions.

Si vous ajoutez des fonctionnalités temps réel et souhaitez une architecture qui tient au-delà de la démo, parlons-en.

real-time features architecturewebsockets vs ssepub/sub architectureserver-sent events nodejswebsocket scalingreal-time dashboard architecture

Questions fréquentes

Quand faut-il utiliser SSE plutôt que WebSockets ?

Dès que les données ne circulent que du serveur vers le client : notifications, flux en direct, flux d'activité, tableaux de bord. SSE se reconnecte automatiquement, fonctionne à travers la plupart des proxies et ne nécessite aucune mise à niveau de protocole particulière. Il est sous-utilisé parce que les développeurs choisissent WebSockets par réflexe, sans réfléchir au sens de circulation des données.

Comment mettre à l'échelle les connexions WebSocket sur plusieurs serveurs ?

Placez un bus pub/sub (Redis est le choix habituel) derrière vos serveurs de connexion. Chaque serveur gère ses propres connexions ouvertes, et lorsqu'un événement est publié, il est envoyé à Redis, qui le redistribue à tous les serveurs de connexion ayant un abonné. Cela découple l'état des connexions de l'acheminement des messages.

Comment gérer les messages manqués après une reconnexion WebSocket ?

Suivez un curseur ou un horodatage côté client. À la reconnexion, envoyez ce curseur au serveur et rejouez tous les événements depuis ce point. Pour les fonctionnalités à état complexe, il est parfois plus simple de récupérer l'intégralité de l'état courant à la reconnexion plutôt que de rejouer un journal d'événements potentiellement long.

Dois-je construire mon propre serveur WebSocket ou utiliser un service géré ?

Utilisez une couche gérée (Supabase Realtime, Pusher, Ably) sauf si vous avez des exigences spécifiques que ces services ne peuvent pas satisfaire, ou si le coût par connexion devient significatif à votre échelle. La complexité opérationnelle liée à la gestion d'une infrastructure de connexions persistantes à grande échelle est systématiquement sous-estimée.

Comment Pykero peut aider

Services liés à cet article.

Vous construisez quelque chose de similaire ?

Pykero Agency conçoit et livre des produits web, mobiles, SaaS et IA prêts pour la production.

Parlons-en

Discussion

Be the first to comment.

À lire aussi