{"canonical_url":"https://engineer.company/fr/glossary/websocket/","content_markdown":"# WebSocket\n\n## Ce que c'est\n\nWebSocket est un protocole de connexion sur laquelle les deux parties peuvent\nécrire à tout moment. Une négociation HTTP l'établit, et elle reste ouverte\njusqu'à ce qu'un participant la ferme ou qu'elle tombe en panne. L'IETF l'a\npublié dans la RFC 6455 en décembre 2011 ; la partie qu'un navigateur expose\naux scripts, l'objet `WebSocket`, est définie par le WebSockets Standard du\nWHATWG. Dans le code et la documentation, le nom s'écrit aussi souvent\n« websocket » ou « web socket », et le pluriel WebSockets désigne généralement\nla technologie dans son ensemble.\n\nDans la négociation classique en HTTP/1.1, la connexion commence par un simple\n`GET`. Le client ajoute `Upgrade:\nwebsocket` et `Connection: Upgrade`, un `Sec-WebSocket-Version` de 13 et un\n`Sec-WebSocket-Key`, valeur aléatoire de 16 octets encodée en base64. Un serveur\nqui accepte répond par le statut 101 Switching Protocols et un en-tête\n`Sec-WebSocket-Accept`. Cette valeur prouve qu'il a lu cette négociation précise\nplutôt que de rejouer une ancienne réponse : c'est la clé du client à laquelle\nun GUID fixe a été ajouté, le tout haché avec SHA-1 puis encodé en base64.\nÀ partir de là, HTTP n'intervient plus sur cette connexion et les deux parties\néchangent des trames. HTTP/2 et HTTP/3 transportent plutôt WebSocket sur un\nseul flux au moyen de CONNECT étendu, comme le précisent les RFC 8441 et 9220.\n\nUne trame est petite. Son en-tête occupe d'abord deux octets, auxquels\ns'ajoutent deux ou huit octets lorsque la charge utile dépasse 125 octets,\npuis quatre autres dans les trames du client, qui portent une clé de masquage.\nChaque trame porte un code d'opération : texte, données binaires ou\ncontinuation pour un message réparti sur plusieurs trames ; trois autres\ncodes désignent les trames de contrôle de fermeture, ping et pong. Un message texte complet\ndoit être du UTF-8 valide ; un fragment isolé peut couper une séquence UTF-8.\nChaque trame envoyée par un client est masquée avec une nouvelle clé aléatoire\nde 32 bits, tandis qu'un serveur ne masque jamais. Le masquage n'est pas du\nchiffrement. Il sert à empêcher un script hostile de choisir les octets exacts qui\ntraversent le réseau pour empoisonner un proxy de mise en cache sur le trajet.\n\nLes adresses utilisent les schémas `ws://` et `wss://`, avec les ports 80 et\n443 par défaut, et `wss` fait passer tout l'échange dans TLS. Ce sont les ports\nqu'HTTP utilise déjà, délibérément : pour les pare-feu et les proxys traversés,\nla négociation ressemble à n'importe quelle autre requête web.\n\n## Pourquoi c'est important\n\nAvec des réponses HTTP courtes, le serveur ne parle que lorsqu'on l'interroge.\nBeaucoup de produits ont besoin de l'inverse : un message de chat, un prix qui\nvient de changer, un curseur dans un document partagé, une tâche de fond qui\ns'est terminée. Sans canal sur lequel le serveur peut écrire, le client doit\ninterroger périodiquement le serveur. Il le fait toutes les quelques secondes ;\nla plupart des réponses disent seulement que rien n'a changé, chacune porte\nun ensemble complet d'en-têtes, et une information nouvelle peut attendre tout un intervalle\navant d'être vue. Une connexion WebSocket ouverte supprime ces deux coûts.\nLe serveur peut envoyer dès qu'un événement survient, sans attendre la prochaine\ninterrogation. Chaque message ne demande que quelques octets d'encadrement au\nlieu d'un ensemble complet d'en-têtes HTTP.\n\nLe prix à payer est l'état à conserver. Une requête HTTP peut arriver sur\nn'importe quel serveur derrière un répartiteur de charge, tandis qu'une\nconnexion WebSocket appartient à un processus pendant toute sa durée de vie.\nCe processus réserve de la mémoire pour chaque connexion ouverte ; un\ndéploiement ou un redémarrage les coupe toutes à la fois, et chaque proxy et\nrépartiteur de charge du trajet doit prendre en charge la négociation et\nsupporter une connexion qui peut rester silencieuse plusieurs minutes.\nExploiter plusieurs serveurs soulève une question qu'HTTP ordinaire ne pose\njamais : lorsqu'un événement survient sur le serveur A, comment atteint-il un\nclient dont la connexion réside sur le serveur B ? La réponse habituelle est\nun canal partagé de publication et d'abonnement qu'écoute chaque serveur, soit\nun système de plus à exploiter.\n\nC'est donc un choix, pas une solution à adopter par défaut. Lorsque seul le\nserveur a des nouvelles à envoyer, les server-sent events, définis dans le\nstandard HTML, poussent des événements dans une réponse HTTP ordinaire de type\n`text/event-stream`, et le navigateur se reconnecte tout seul si la réponse\ns'interrompt. Les mécanismes supplémentaires de WebSocket se justifient quand\nle client a autant à dire que le serveur, comme dans le chat, les jeux et\nl'édition collaborative.\n\n## À quoi cela ressemble en pratique\n\nL'échange ci-dessous ouvre une connexion de chat. La clé est la valeur\nd'exemple de la RFC 6455 elle-même, et la valeur d'acceptation est celle que le\nstandard donne, que tout serveur correct doit renvoyer pour cette clé.\n\n```http\nGET /chat HTTP/1.1\nHost: example.com\nUpgrade: websocket\nConnection: Upgrade\nSec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\nSec-WebSocket-Version: 13\nOrigin: https://example.com\n\nHTTP/1.1 101 Switching Protocols\nUpgrade: websocket\nConnection: Upgrade\nSec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=\n```\n\nAprès la ligne vide qui termine la réponse du serveur, plus rien sur la\nconnexion n'est du HTTP. Un navigateur effectue toute la négociation dans un\nseul appel au constructeur et confie la suite à des écouteurs d'événements :\n\n```js\nconst socket = new WebSocket(\"wss://example.com/chat\");\nsocket.addEventListener(\"open\", () =\u003e socket.send(\"hello\"));\nsocket.addEventListener(\"message\", (event) =\u003e console.log(event.data));\nsocket.addEventListener(\"close\", (event) =\u003e {\n  console.log(event.code, event.reason, event.wasClean);\n});\n```\n\nL'événement de fermeture indique comment la connexion s'est terminée. Le code\n1000 signale une fermeture normale, et 1001 indique qu'un participant s'en va,\npar exemple un serveur qui s'arrête ou un navigateur qui quitte la page.\nLe code 1006 signifie que la connexion s'est interrompue sans aucune trame de\nfermeture. Aucun point de connexion n'est autorisé à l'envoyer ; il existe\nuniquement pour que le programme qui utilise la connexion puisse distinguer une fin anormale\nd'une fermeture propre.\n\nLa distinction entre requête-réponse et socket apparaît clairement dans un\nprojet du portfolio de ce site. Lors du passage d'une API à Huma v2,\n[toutes les routes ont adopté le modèle requête-réponse de Huma, sauf exactement deux](/fr/portfolio/migrated-the-api-to-huma-v2-at-100-parity/) :\nles points d'accès WebSocket sont restés sur Fiber directement, car le code y\na réellement besoin du socket lui-même et le modèle de Huma ne convient pas.\nUn framework conçu autour de la forme d'HTTP décrit et valide bien les\nrequêtes et les réponses, tandis qu'une connexion bidirectionnelle durable\nrelève simplement d'un autre fonctionnement.\n\n## Où les problèmes surviennent\n\n**Une page d'un autre site ouvre une connexion avec les cookies de vos\nvisiteurs.** Le navigateur envoie la requête de négociation à l'hôte du serveur\net peut y joindre ses cookies, sous réserve de sa politique relative aux\ncookies. Si cette politique autorise des requêtes authentifiées entre sites,\nun serveur qui authentifie par cookie et ignore l'en-tête `Origin` peut\naccepter une connexion ouverte par une page d'un autre site sous l'identité\ndu visiteur. La RFC 6455 indique qu'un serveur destiné uniquement à certains\nsites devrait comparer `Origin` aux origines attendues et refuser les autres\navec 403 Forbidden. Faites-le pendant la négociation, avant d'accepter la\nconnexion.\n\n**Le jeton d'accès se retrouve dans les journaux.** Le constructeur\n`WebSocket` du navigateur accepte une URL et une liste facultative de\nsous-protocoles, rien d'autre : un script ne peut donc pas ajouter d'en-tête\n`Authorization`. Le raccourci consiste à mettre un jeton dans l'URL, où les\nproxys inverses et les journaux d'accès le consignent. La RFC laisse le choix\nde l'authentification ouvert et cite les cookies, l'authentification HTTP et\nl'authentification TLS parmi les possibilités. Un cookie accompagné du contrôle\n`Origin` ci-dessus fonctionne, tout comme un ticket à usage unique et à courte\ndurée de vie que la page obtient par un appel HTTP authentifié puis utilise\npour la négociation.\n\n**Un redémarrage transforme tous les clients en déferlante.** Un déploiement\nbrutal ou un redémarrage peut fermer toutes les connexions à la fois. Les\nclients qui ne reçoivent aucune trame de fermeture signalent le code 1006 ;\ns'ils se reconnectent tous immédiatement et persistent, le serveur revient\nface à ce que la RFC compare à une attaque par déni de service. La RFC 6455\ndemande aux clients d'attendre un délai aléatoire avant le premier essai,\nsuggère une durée comprise entre 0 et 5 secondes, puis d'attendre davantage\naprès chaque échec, par exemple avec un délai exponentiel binaire tronqué.\nUn serveur qui ferme ses connexions avec 1001 avant de s'arrêter indique au\nmoins aux clients que l'interruption était prévue.\n\n```js\nfunction reconnectDelay(attempt) {\n  if (attempt === 0) return Math.random() * 5000;\n  const ceiling = Math.min(60_000, 1000 * 2 ** attempt);\n  return Math.random() * ceiling;\n}\n```\n\n**Les connexions meurent sans que personne le remarque.** Une connexion sans\ntrafic ne donne à aucune partie le signe que le trajet existe encore, et un\ncorrespondant qui disparaît sans trame de fermeture ressemble exactement à un\ncorrespondant silencieux jusqu'à l'échec de la prochaine écriture. Ping et pong\nservent à cela : une extrémité doit répondre à un ping par un pong, sauf si\nelle a déjà reçu une trame de fermeture. Si plusieurs pings restent sans\nréponse, elle peut ne répondre qu'au dernier. La RFC précise qu'un ping peut\nservir à maintenir la connexion ou à vérifier que l'autre partie répond\nencore. L'API du navigateur ne permet pas d'envoyer de ping : le minuteur\ndoit donc être géré côté serveur. Envoyez un ping à chaque connexion à intervalle\nfixe et fermez celles qui ne répondent pas par un pong.\n\n**Un seul message dévore la mémoire du serveur.** Le champ de longueur de\nl'en-tête d'une trame permet des charges utiles bien supérieures à la mémoire\nd'un serveur, et la RFC avertit qu'un correspondant hostile peut envoyer une\ntrame énorme ou une suite infinie de petits fragments. Les implémentations\ndoivent se protéger : fixez une taille maximale de message dans la bibliothèque\nserveur et fermez avec le code 1009, message too big, lorsqu'un correspondant\nla dépasse. Une accumulation similaire se produit dans l'autre sens. Dans le navigateur,\n`bufferedAmount` indique combien d'octets mis en attente par `send()` attendent\nencore de partir sur le réseau, et l'exemple du WHATWG n'envoie la mise à jour\nsuivante que lorsque ce nombre est nul. Sur le serveur, un client qui lit\nlentement remplit de la même manière le tampon de sortie. Chaque connexion a\ndonc besoin d'une limite pour ce tampon et d'une règle indiquant ce qui se\npasse lorsqu'elle est atteinte.\n\n## Pour aller plus loin\n\n- [RFC 6455: The WebSocket Protocol](https://www.rfc-editor.org/rfc/rfc6455) —\n  la négociation, le découpage en trames, le masquage et les codes de fermeture,\n  avec les raisons de sécurité de chacun.\n- [WebSockets Standard](https://websockets.spec.whatwg.org/) — l'API du navigateur :\n  le constructeur, `send()`, `close()`, `bufferedAmount` et l'événement de fermeture.\n- [RFC 9110: HTTP Semantics](https://www.rfc-editor.org/rfc/rfc9110) — le champ\n  d'en-tête `Upgrade` et le statut 101 Switching Protocols sur lesquels repose\n  la négociation.\n- [Server-sent events](https://html.spec.whatwg.org/multipage/server-sent-events.html)\n  — l'alternative unidirectionnelle du standard HTML, avec reconnexion intégrée.\n- [RFC 8441: Bootstrapping WebSockets with HTTP/2](https://www.rfc-editor.org/rfc/rfc8441)\n  — CONNECT étendu transporte WebSocket sur un flux HTTP/2 multiplexé.\n- [RFC 9220: Bootstrapping WebSockets with HTTP/3](https://www.rfc-editor.org/rfc/rfc9220)\n  — le mécanisme correspondant de CONNECT étendu pour HTTP/3.\n\n\u003chttps://engineer.company/fr/glossary/websocket/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Comment une requête HTTP ouvre une connexion bidirectionnelle qui reste ouverte, quand elle surpasse le polling et cinq façons dont elle peut défaillir.","formats":{"gemtext":"https://engineer.company/fr/glossary/websocket/index.gmi","gopher":"https://engineer.company/fr/glossary/websocket/gophermap","html":"https://engineer.company/fr/glossary/websocket/","json":"https://engineer.company/fr/glossary/websocket/index.json","markdown":"https://engineer.company/fr/glossary/websocket/index.md","pdf":"https://engineer.company/fr/glossary/websocket/index.pdf"},"kind":"page","language":"fr","title":"Qu'est-ce que WebSocket ?","url":"https://engineer.company/fr/glossary/websocket/","version":1}