MODULE 59 / 72
🔔
Scénario : notification temps réel (chat, alertes)
Le problème : HTTP est request-response. Le client demande, le serveur répond. Mais pour un chat ou des notifications, c'est le SERVEUR qui doit pouvoir pousser une info au client — quand un autre utilisateur envoie un message. Trois solutions, par ordre de sophistication.
Solution 1 — Polling (le pragmatique) : le frontend fait `GET /notifications` toutes les 5-30 secondes. Simple, marche partout, pas d'infra spéciale. Inconvénients : latence (jusqu'à 30s avant de voir un nouveau message) et gaspillage (99% des requêtes retournent "rien de neuf"). Acceptable pour des notifications peu fréquentes (nouveaux emails).
Solution 2 — SSE (Server-Sent Events) : le frontend ouvre UNE connexion HTTP longue avec `EventSource('/stream')`. Le serveur garde cette connexion ouverte et peut y pousser des messages à volonté. Unidirectionnel (serveur → client uniquement). Parfait pour : notifications, flux d'activité, streaming de réponses IA. Simple, basé sur HTTP standard, passe les proxies d'entreprise.
Solution 3 — WebSocket : connexion TCP bidirectionnelle permanente. Le serveur ET le client peuvent envoyer des messages à tout moment. Protocole distinct (`ws://` ou `wss://`). Indispensable pour : chat, jeux multijoueur, édition collaborative (Google Docs), trading temps réel.
Le choix pragmatique : commencer par polling si la fréquence de mise à jour le permet. Passer en SSE si vous avez du server-push mais pas besoin de client-push. WebSocket uniquement pour du vrai bidirectionnel fréquent. Ne JAMAIS partir directement sur WebSocket parce que "c'est moderne" — la complexité est énorme (scaling, reconnexions, états de connexion, fallbacks).
Scaling WebSocket — le piège : si un user est connecté au serveur A et qu'un autre user sur le serveur B lui envoie un message, comment A sait-il que B a reçu un message ? Réponse : un pub/sub central (Redis Pub/Sub, NATS) où tous les serveurs publient et s'abonnent. Sans ça, vos serveurs sont des silos isolés.
Reconnexions : un WebSocket se coupe tout le temps (WiFi qui switch, écran verrouillé, etc). Le client doit gérer la reconnexion automatique avec backoff exponentiel (1s, 2s, 4s, 8s...). Et à la reconnexion : récupérer les messages manqués (via un `last_message_id` et un appel HTTP classique).
Exception no-code : avec Supabase Realtime, Firebase ou le Realtime Xano, le WebSocket est géré pour vous — souvent le choix le plus simple dès qu'il faut du live.
⚡ ANALOGIE — LE COURRIER VS LE TÉLÉPHONE
Polling = rappeler la réception toutes les 5 minutes pour demander "j'ai du courrier ?". Épuisant et gaspilleur. SSE = ligne ouverte où la réception vous annonce le courrier au fur et à mesure — mais vous ne pouvez pas parler en retour. WebSocket = conversation téléphonique bidirectionnelle : les deux parties parlent et écoutent en même temps. Pub/Sub = un standardiste central qui met en relation toutes les lignes, sinon chaque bureau serait isolé.
📐 SCHÉMA
Polling5-30scoût: Élevé (99% inutile)
Client demande périodiquement
→ Notifs peu fréquentes
Long polling< 1scoût: Moyen
Serveur retient la requête jusqu'à avoir une réponse
→ Compromis avant WebSocket
SSE< 100mscoût: Faible
Serveur pousse, client écoute
→ Notifs, streaming IA, flux live
WebSocket< 50mscoût: Faible mais infra complexe
Bidirectionnel permanent
→ Chat, jeux, édition collab
💬 QUESTION INTERACTIVE
1/5
"Vous construisez un chat entre 2 utilisateurs pour un SaaS interne (50 users simultanés max). WebSocket ou autre chose ?"
🎯 PIÈGE / QUESTION D'ENTRETIEN
Qu'est-ce que le 'sticky session' et pourquoi c'est critique pour le WebSocket derrière un load balancer ?