{"canonical_url":"https://engineer.company/da/glossary/websocket/","content_markdown":"# WebSocket\n\n## Hvad det er\n\nWebSocket er en protokol til en forbindelse, som begge parter kan skrive på\nnår som helst. Et HTTP-håndtryk opretter den, og den forbliver åben, indtil\nen part lukker den, eller forbindelsen svigter. IETF udgav den som RFC 6455 i december 2011,\nog den del, en browser stiller til rådighed for scripts, objektet `WebSocket`,\ner defineret i WHATWG's WebSockets Standard. I kode og dokumentation ser man\nogså navnet stavet »websocket« eller »web socket«, og flertalsformen WebSockets\nbruges som regel om teknologien som helhed.\n\nI det klassiske HTTP/1.1-håndtryk begynder forbindelsen med en almindelig\n`GET`. Klienten\ntilføjer `Upgrade: websocket` og `Connection: Upgrade`, en\n`Sec-WebSocket-Version` på 13 og en `Sec-WebSocket-Key`, som er en tilfældig\nværdi på 16 byte kodet i base64. En server, der siger ja, svarer med statuskoden\n101 Switching Protocols og headerfeltet `Sec-WebSocket-Accept`. Værdien beviser,\nat serveren har læst netop dette håndtryk og ikke genbruger et gammelt svar: den\ner klientens nøgle med et fast GUID hængt på, hashet med SHA-1 og kodet i\nbase64. Fra det øjeblik er HTTP færdig på forbindelsen, og parterne udveksler\nrammer i stedet. HTTP/2 og HTTP/3 bærer i stedet WebSocket over én strøm\nmed extended CONNECT, som RFC 8441 og RFC 9220 beskriver.\n\nEn ramme er lille. Headeren fylder mindst to byte, vokser med to eller otte, når\nindholdet er længere end 125 byte, og med yderligere fire på rammer fra\nklienten, som bærer en maskeringsnøgle. Hver ramme har en opcode: tekst, binær eller fortsættelse, når en besked er\ndelt over flere rammer, og dertil tre kontrolrammer til lukning, ping og pong.\nEn komplet tekstbesked skal være gyldig UTF-8; et enkelt fragment kan dele\nen UTF-8-sekvens. Hver ramme,\nen klient sender, er maskeret med en ny tilfældig 32-bit-nøgle, og en server\nmaskerer aldrig. Maskering er ikke kryptering. Den findes, så et fjendtligt\nscript ikke kan vælge præcis de byte, der krydser netværket, og bruge dem til at\nforgifte en cachende proxy et sted på vejen.\n\nAdresser begynder med `ws://` eller `wss://`, med port 80 og port 443 som\nstandard, og `wss` kører hele udvekslingen inde i TLS. Det er de porte, HTTP\nallerede bruger, og det er med vilje: håndtrykket ligner enhver anden\nwebforespørgsel for de firewalls og proxyer, det kommer igennem.\n\n## Hvorfor det betyder noget\n\nMed korte HTTP-svar taler serveren kun, når den bliver spurgt.\nMange produkter har brug for det modsatte: en chatbesked, en pris, der lige har\nændret sig, en markør i et delt dokument, et baggrundsjob, der er blevet\nfærdigt. Uden en kanal, serveren kan skrive på, må klienten polle. Den spørger\nmed få sekunders mellemrum, de fleste svar siger blot, at intet er ændret, hvert\nsvar bærer et helt sæt headerfelter, og en nyhed venter op til et helt interval,\nfør nogen ser den. En åben WebSocket-forbindelse fjerner begge omkostninger.\nServeren kan sende, når noget sker, uden at vente på næste polling. Hver\nbesked behøver kun nogle få byte til rammen i stedet for et helt sæt\nHTTP-headerfelter.\n\nPrisen er, at forbindelsen bærer tilstand. En HTTP-forespørgsel kan lande på en\nhvilken som helst server bag en load balancer, mens en WebSocket-forbindelse\nhører til én proces, så længe den lever. Den proces holder hukommelse for hver\nåben forbindelse, en udrulning eller genstart kapper dem alle på én gang, og\nhver proxy og load balancer på vejen skal understøtte håndtrykket og finde\nsig i en forbindelse, der måske er stille i flere minutter. Kører man mere end\nén server, opstår et spørgsmål, almindelig HTTP aldrig stiller: når noget sker\npå server A, hvordan når det så frem til en klient, hvis forbindelse lever på\nserver B? Det sædvanlige svar er en fælles publish/subscribe-kanal, som alle\nserverne lytter på, og det er endnu et system at drive.\n\nWebSocket er altså noget, man vælger til, ikke noget, man starter med. Når kun\nserveren har noget at fortælle, kan server-sent events, som er defineret i\nHTML-standarden, skubbe hændelser over et almindeligt HTTP-svar af typen\n`text/event-stream`, og browseren forbinder selv igen, når svaret bliver\nafbrudt. WebSocket gør sig fortjent til sine ekstra bevægelige dele, når\nklienten har lige så meget at sige som serveren, som i chat, spil og samtidig\nredigering af det samme dokument.\n\n## Sådan ser det ud i praksis\n\nUdvekslingen nedenfor åbner en chatforbindelse. Nøglen er eksempelværdien fra\nselve RFC 6455, og accept-værdien er den, standarden selv viser, og som enhver\nkorrekt server skal sende tilbage for netop den nøgle.\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\nEfter den tomme linje, der afslutter serverens svar, er intet på forbindelsen\nHTTP længere. En browser klarer hele håndtrykket bag ét kald til konstruktøren\nog overlader resten til hændelseslyttere:\n\n```js\nconst socket = new WebSocket(\"wss://example.com/chat\");\nsocket.addEventListener(\"open\", () =\u003e socket.send(\"hej\"));\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\nLukkehændelsen fortæller, hvordan forbindelsen sluttede. Kode 1000 er en normal\nlukning, og 1001 betyder, at den ene part går sin vej, for eksempel en server,\nder lukker ned, eller en browser, der forlader siden. Kode 1006 betyder, at\nforbindelsen forsvandt helt uden en lukkeramme. Intet endpoint må sende den; den\nfindes kun, så programmet ovenpå kan skelne en unormal afslutning fra en ren.\n\nGrænsen mellem forespørgsel og svar på den ene side og en åben socket på den\nanden ses tydeligt i et projekt i sitets portefølje. Da et API flyttede over på\nHuma v2,\n[kom alle ruter over på Humas model med forespørgsel og svar, undtagen præcis to](/da/portfolio/migrated-the-api-to-huma-v2-at-100-parity/):\nWebSocket-endpointene blev på rå Fiber, fordi koden dér reelt har brug for selve\nsocketten, og fordi Humas model ikke passer. Et framework, der er bygget op om\nHTTP's egen form, beskriver og validerer forespørgsler og svar godt, og en\nlanglivet tovejsforbindelse er simpelthen noget andet.\n\n## Hvor det går galt\n\n**En side på et andet site åbner en forbindelse med dine besøgendes cookies.**\nBrowseren sender håndtryksforespørgslen til serverens vært og kan medtage\nværtens cookies, afhængigt af browserens cookiepolitik. Hvor den politik\ntillader autentificerede forespørgsler på tværs af sites, kan en server, der\nautentificerer med cookies og ignorerer `Origin`, acceptere en forbindelse\nåbnet af en anden sides script i den besøgendes navn. RFC 6455 siger, at en server, der kun\ner beregnet til bestemte sites, bør tjekke `Origin` mod dem, den forventer, og\nafvise resten med 403 Forbidden. Gør det i håndtrykket, før forbindelsen accepteres.\n\n**Adgangstokenet ender i loggene.** Browserens `WebSocket`-konstruktør tager en\nURL og en valgfri liste af subprotokoller og intet andet, så et script kan ikke\ntilføje et `Authorization`-felt. Den hurtige omvej er et token i URL'en, hvor\nreverse proxyer og adgangslogge skriver det ned. RFC'en lader autentificering\nstå åben og nævner cookies, HTTP-autentificering og TLS-autentificering som\nmuligheder. En cookie kombineret med `Origin`-tjekket ovenfor virker, og det gør\nen kortlivet engangsbillet også, som siden henter over et autentificeret\nHTTP-kald og bruger på håndtrykket.\n\n**En genstart gør alle klienter til en stormflod.** En brat udrulning eller genstart kan lukke alle forbindelser på én gang.\nKlienter, der ikke modtager nogen lukkeramme, melder kode 1006; hvis de alle\nforbinder igen med det samme og bliver ved, kommer serveren op til noget,\nsom RFC'en sammenligner med et denial-of-service-angreb. RFC 6455 beder klienter\nvente et tilfældigt stykke tid før første forsøg, foreslår noget mellem 0 og 5\nsekunder og beder dem derefter vente længere efter hver fejl, for eksempel med\nafkortet binær eksponentiel backoff. En server, der lukker sine forbindelser med\n1001, før den stopper, fortæller i det mindste klienterne, at afbrydelsen var\nplanlagt.\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**Forbindelser dør, uden at nogen opdager det.** En forbindelse uden trafik\ngiver ingen af parterne tegn på, at vejen stadig findes, og en modpart, der\nforsvandt uden en lukkeramme, ligner præcis en stille forbindelse, indtil næste\nskrivning fejler. Det er det, ping og pong er til: et endpoint skal besvare et ping med et pong, medmindre det allerede har\nmodtaget en lukkeramme. Er flere pings ubesvarede, må det nøjes med at\nbesvare det seneste. RFC'en nævner, at et ping kan tjene som keepalive eller\nsom et tjek af, at den anden side stadig svarer. Browserens API har ingen\nmåde at sende et ping på, så timeren hører hjemme på serveren: ping hver\nforbindelse med et fast interval, og luk dem, der ikke svarer med pong.\n\n**Én besked æder serverens hukommelse.** Længdefeltet i en rammes header giver\nplads til langt større indhold, end nogen server har hukommelse til, og RFC'en\nadvarer om, at en fjendtlig modpart kan sende én enorm ramme eller en endeløs\nstrøm af små fragmenter. Implementeringer skal beskytte sig selv, så sæt en\nmaksimal beskedstørrelse i serverbiblioteket, og luk med kode 1009, message too\nbig, når en modpart går over den. Det samme efterslæb kan hobe sig op den anden\nvej. I browseren fortæller `bufferedAmount`, hvor mange byte fra `send()` der\nstadig venter på at komme ud på netværket, og WHATWG's eksempel sender først den\nnæste opdatering, når tallet er nul. På serveren fylder en klient, der læser\nlangsomt, den udgående buffer på samme måde, så hver forbindelse har brug for et\nloft over den og en regel for, hvad der sker, når loftet er nået.\n\n## Læs mere\n\n- [RFC 6455: The WebSocket Protocol](https://www.rfc-editor.org/rfc/rfc6455) —\n  håndtrykket, rammerne, maskeringen og lukkekoderne, og sikkerhedsbegrundelsen\n  bag hver af dem.\n- [WebSockets Standard](https://websockets.spec.whatwg.org/) — browserens API:\n  konstruktøren, `send()`, `close()`, `bufferedAmount` og lukkehændelsen.\n- [RFC 9110: HTTP Semantics](https://www.rfc-editor.org/rfc/rfc9110) —\n  headerfeltet `Upgrade` og statuskoden 101 Switching Protocols, som håndtrykket\n  bygger på.\n- [Server-sent events](https://html.spec.whatwg.org/multipage/server-sent-events.html)\n  — HTML-standardens envejsalternativ med indbygget genforbindelse.\n- [RFC 8441: Bootstrapping WebSockets with HTTP/2](https://www.rfc-editor.org/rfc/rfc8441)\n  — extended CONNECT bærer WebSocket over én multiplekset HTTP/2-strøm.\n- [RFC 9220: Bootstrapping WebSockets with HTTP/3](https://www.rfc-editor.org/rfc/rfc9220)\n  — den tilsvarende extended-CONNECT-mekanisme til HTTP/3.\n\n\u003chttps://engineer.company/da/glossary/websocket/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Sådan bliver én HTTP-forespørgsel til en åben tovejsforbindelse, hvornår det slår polling, og fem måder, en langlivet forbindelse går galt på.","formats":{"gemtext":"https://engineer.company/da/glossary/websocket/index.gmi","gopher":"https://engineer.company/da/glossary/websocket/gophermap","html":"https://engineer.company/da/glossary/websocket/","json":"https://engineer.company/da/glossary/websocket/index.json","markdown":"https://engineer.company/da/glossary/websocket/index.md","pdf":"https://engineer.company/da/glossary/websocket/index.pdf"},"kind":"page","language":"da","title":"Hvad er WebSocket?","url":"https://engineer.company/da/glossary/websocket/","version":1}