{"canonical_url":"https://engineer.company/nb/glossary/websocket/","content_markdown":"# WebSocket\n\n## Hva det er\n\nWebSocket er en protokoll for en forbindelse begge parter kan skrive til når\nsom helst. Et HTTP-håndtrykk oppretter den, og den holdes åpen til en part\nlukker den eller forbindelsen svikter. IETF publiserte den som RFC 6455 i desember 2011, og den\ndelen en nettleser gjør tilgjengelig for skript, objektet `WebSocket`, er\ndefinert i WHATWGs WebSockets Standard. I kode og dokumentasjon ser man også\nnavnet skrevet «websocket» eller «web socket», og flertallsformen WebSockets\nbrukes som regel om teknologien som helhet.\n\nI det klassiske HTTP/1.1-håndtrykket starter forbindelsen med en vanlig\n`GET`. Klienten legger til\n`Upgrade: websocket` og `Connection: Upgrade`, en `Sec-WebSocket-Version` på 13\nog en `Sec-WebSocket-Key`, som er en tilfeldig verdi på 16 byte kodet i base64.\nEn server som sier ja, svarer med statuskoden 101 Switching Protocols og\nheaderfeltet `Sec-WebSocket-Accept`. Verdien beviser at serveren har lest\nakkurat dette håndtrykket og ikke spiller av et gammelt svar: den er klientens\nnøkkel med en fast GUID hengt på, hashet med SHA-1 og kodet i base64. Fra det\nøyeblikket er HTTP ferdig på forbindelsen, og partene utveksler rammer i stedet.\nHTTP/2 og HTTP/3 fører i stedet WebSocket over én strøm ved hjelp av extended\nCONNECT, slik RFC 8441 og RFC 9220 beskriver.\n\nEn ramme er liten. Headeren er minst to byte, vokser med to eller åtte når\ninnholdet er lengre enn 125 byte, og med ytterligere fire på rammer fra\nklienten, som bærer en maskeringsnøkkel. Hver ramme har en opcode: tekst, binær eller fortsettelse når en melding er\ndelt over flere rammer, og i tillegg tre kontrollrammer for lukking, ping og\npong. En fullstendig tekstmelding må være gyldig UTF-8; ett enkelt fragment\nkan dele en UTF-8-sekvens. Hver ramme en\nklient sender, maskeres med en ny tilfeldig 32-bits nøkkel, og en server\nmaskerer aldri. Maskering er ikke kryptering. Den finnes for at et fiendtlig\nskript ikke skal kunne velge nøyaktig hvilke byte som krysser nettverket, og\nbruke dem til å forgifte en mellomlagrende proxy et sted på veien.\n\nAdresser begynner med `ws://` eller `wss://`, med port 80 og port 443 som\nstandard, og `wss` kjører hele utvekslingen inne i TLS. Det er de samme portene\nHTTP allerede bruker, og det er med vilje: for brannmurer og proxyer underveis\nser håndtrykket ut som en hvilken som helst annen nettforespørsel.\n\n## Hvorfor det er viktig\n\nMed korte HTTP-svar snakker serveren bare når den blir spurt. Mange\nprodukter trenger det motsatte: en chatmelding, en pris som nettopp har endret\nseg, en markør i et delt dokument, en bakgrunnsjobb som er ferdig. Uten en kanal\nserveren kan skrive til, må klienten polle. Den spør med noen sekunders\nmellomrom, de fleste svarene sier bare at ingenting har endret seg, hvert av dem\nbærer et fullt sett headerfelt, og en nyhet venter opptil et helt intervall før\nnoen ser den. En åpen WebSocket-forbindelse fjerner begge kostnadene. Serveren kan sende når noe skjer, uten å vente på neste polling. Hver melding\ntrenger bare noen få byte rammeinformasjon i stedet for et fullt sett\nHTTP-headere.\n\nPrisen er tilstand. En HTTP-forespørsel kan havne på hvilken som helst server\nbak en lastbalanserer, mens en WebSocket-forbindelse tilhører én prosess så\nlenge den lever. Den prosessen holder av minne til hver åpen forbindelse, en\nproduksjonssetting eller omstart kutter alle på én gang, og hver proxy og\nlastbalanserer på veien må støtte håndtrykket og tåle en forbindelse\nsom kanskje er stille i flere minutter. Kjører man mer enn én server, oppstår et\nspørsmål vanlig HTTP aldri stiller: når noe skjer på server A, hvordan kommer\ndet fram til en klient som har forbindelsen sin på server B? Det vanlige svaret\ner en felles publish/subscribe-kanal som alle serverne lytter på, og det er enda\net system å drifte.\n\nWebSocket er altså et bevisst valg, ikke et utgangspunkt. Når bare serveren har\nnoe å fortelle, kan server-sent events, som er definert i HTML-standarden, sende\nhendelser over et vanlig HTTP-svar av typen `text/event-stream`, og nettleseren\nkobler seg til igjen av seg selv når svaret brytes. WebSocket fortjener de\nekstra bevegelige delene sine når klienten har like mye å si som serveren, som i\nchat, spill og samtidig redigering av det samme dokumentet.\n\n## Slik ser det ut i praksis\n\nUtvekslingen nedenfor åpner en chatforbindelse. Nøkkelen er eksempelverdien fra\nselve RFC 6455, og `Sec-WebSocket-Accept`-verdien er den standarden selv viser,\nog som enhver korrekt server må sende tilbake for akkurat den nøkkelen.\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\nEtter den tomme linjen som avslutter serverens svar, er ingenting på\nforbindelsen HTTP lenger. En nettleser gjør hele håndtrykket bak ett kall til\nkonstruktøren og overlater resten til hendelseslyttere:\n\n```js\nconst socket = new WebSocket(\"wss://example.com/chat\");\nsocket.addEventListener(\"open\", () =\u003e socket.send(\"hei\"));\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\nLukkehendelsen forteller hvordan forbindelsen endte. Kode 1000 er en normal\nlukking, og 1001 betyr at den ene parten går sin vei, for eksempel en server som\nslås av, eller en nettleser som forlater siden. Kode 1006 betyr at forbindelsen\nforsvant helt uten noen lukkeramme. Ingen av partene har lov til å sende den;\nden finnes bare for at programmet over skal kunne skille en unormal slutt fra en\nren.\n\nGrensen mellom forespørsel og svar på den ene siden og en åpen socket på den\nandre vises tydelig i et prosjekt i nettstedets portefølje. Da et API ble\nflyttet over på Huma v2,\n[ble alle rutene migrert over på Humas modell for forespørsel og svar, med nøyaktig to unntak](/nb/portfolio/migrated-the-api-to-huma-v2-at-100-parity/):\nWebSocket-endepunktene ble igjen på ren Fiber, fordi koden der faktisk vil ha\nselve socketen, og Humas modell ikke passer. Et rammeverk bygd rundt formen til\nHTTP beskriver og validerer forespørsler og svar godt, og en langlivet\ntoveisforbindelse er rett og slett noe annet.\n\n## Hvor det går galt\n\n**En side på et annet nettsted åpner en forbindelse med cookiene til de\nbesøkende.** Nettleseren sender håndtrykksforespørselen til serverens vert og kan ta med\nvertens cookies, avhengig av nettleserens cookiepolicy. Der denne policyen\ntillater autentiserte forespørsler på tvers av nettsteder, kan en server som\nautentiserer med cookies og ignorerer `Origin`, godta en forbindelse åpnet av\nen annen nettside på vegne av den besøkende. RFC 6455 sier at en\nserver som bare er ment for bestemte nettsteder, bør sjekke `Origin` mot dem den\nventer, og avvise resten med 403 Forbidden. Gjør det i håndtrykket, før\nforbindelsen godtas.\n\n**Tilgangstokenet havner i loggene.** Nettleserens `WebSocket`-konstruktør tar\nen URL og en valgfri liste med subprotokoller og ingenting annet, så et skript\nkan ikke legge til et `Authorization`-felt. Den raske omveien er et token i\nURL-en, der omvendte proxyer og tilgangslogger skriver det ned. RFC-en lar\nautentisering stå åpen og nevner cookies, HTTP-autentisering og\nTLS-autentisering som muligheter. En cookie sammen med `Origin`-sjekken ovenfor\nfungerer, og det gjør også en kortlivet engangsbillett som siden henter over et\nautentisert HTTP-kall og bruker på håndtrykket.\n\n**En omstart gjør alle klientene til en flodbølge.** En brå produksjonssetting eller omstart kan lukke alle forbindelser samtidig.\nKlienter som ikke mottar noen lukkeramme, melder kode 1006; hvis alle kobler\nseg til igjen med en gang og fortsetter å prøve, kommer serveren opp til noe\nRFC-en sammenligner med et tjenestenektangrep. RFC 6455 ber klienter vente\nen tilfeldig tid før første forsøk, foreslår noe mellom 0 og 5 sekunder, og ber\ndem deretter vente lenger etter hver feil, for eksempel med avkortet binær\neksponentiell backoff. En server som lukker forbindelsene sine med 1001 før den\nstopper, forteller i det minste klientene at bruddet var planlagt.\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 uten at noen merker det.** En forbindelse uten trafikk gir\ningen av partene noe tegn på at veien fortsatt finnes, og en motpart som\nforsvant uten en lukkeramme, ser nøyaktig ut som en stille forbindelse helt til\nneste skriving feiler. Det er dette ping og pong er til for: et endepunkt må svare på en ping med en pong med mindre det allerede har\nmottatt en lukkeramme. Hvis flere pinger er ubesvart, kan det nøye seg med å\nsvare på den siste. RFC-en nevner at en ping kan fungere som keepalive eller\nsom en sjekk på at den andre siden fortsatt svarer. Nettleserens\nAPI har ingen måte å sende en ping på, så timeren hører hjemme på serveren: ping\nhver forbindelse med fast intervall, og lukk dem som ikke svarer med pong.\n\n**Én melding spiser opp serverens minne.** Lengdefeltet i en rammeheader gir\nplass til langt større innhold enn noen server har minne til, og RFC-en advarer\nom at en fiendtlig motpart kan sende én enorm ramme eller en endeløs rekke små\nfragmenter. Implementasjoner må beskytte seg selv, så sett en maksimal\nmeldingsstørrelse i serverbiblioteket, og lukk med kode 1009, message too big,\nnår en motpart går over den. Det samme etterslepet kan hope seg opp i motsatt\nretning. I nettleseren viser `bufferedAmount` hvor mange byte fra `send()` som\nfortsatt venter på å komme ut på nettverket, og WHATWGs eksempel sender neste\noppdatering først når tallet er null. På serveren fyller en klient som leser\nsakte, den utgående bufferen på samme måte, så hver forbindelse trenger et tak\nfor den og en regel for hva som skal skje når taket er nådd.\n\n## Les mer\n\n- [RFC 6455: The WebSocket Protocol](https://www.rfc-editor.org/rfc/rfc6455) —\n  håndtrykket, rammene, maskeringen og lukkekodene, og sikkerhetsbegrunnelsen\n  bak hver av dem.\n- [WebSockets Standard](https://websockets.spec.whatwg.org/) — nettleserens API:\n  konstruktøren, `send()`, `close()`, `bufferedAmount` og lukkehendelsen.\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 enveisalternativ med innebygd gjenoppkobling.\n- [RFC 8441: Bootstrapping WebSockets with HTTP/2](https://www.rfc-editor.org/rfc/rfc8441)\n  — extended CONNECT fø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-mekanismen for HTTP/3.\n\n\u003chttps://engineer.company/nb/glossary/websocket/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Slik blir én HTTP-forespørsel til en åpen toveisforbindelse, når det slår polling, og fem måter en langlivet forbindelse går galt på.","formats":{"gemtext":"https://engineer.company/nb/glossary/websocket/index.gmi","gopher":"https://engineer.company/nb/glossary/websocket/gophermap","html":"https://engineer.company/nb/glossary/websocket/","json":"https://engineer.company/nb/glossary/websocket/index.json","markdown":"https://engineer.company/nb/glossary/websocket/index.md","pdf":"https://engineer.company/nb/glossary/websocket/index.pdf"},"kind":"page","language":"nb","title":"Hva er WebSocket?","url":"https://engineer.company/nb/glossary/websocket/","version":1}