{"canonical_url":"https://engineer.company/sv/glossary/websocket/","content_markdown":"# WebSocket\n\n## Vad det är\n\nWebSocket är ett protokoll för en anslutning som båda parter kan skriva till\nnär som helst. En HTTP-handskakning upprättar den, och den hålls öppen tills\nen part stänger den eller anslutningen bryts. IETF publicerade det som RFC 6455 i december 2011, och den del\nsom en webbläsare gör tillgänglig för skript, objektet `WebSocket`, är\ndefinierad i WHATWG:s WebSockets Standard. I kod och dokumentation stavas namnet\nockså ofta ”websocket” eller ”web socket”, och pluralformen WebSockets brukar\nsyfta på tekniken som helhet.\n\nI den klassiska HTTP/1.1-handskakningen börjar anslutningen med en vanlig\n`GET`. Klienten lägger till\n`Upgrade: websocket` och `Connection: Upgrade`, en `Sec-WebSocket-Version` på 13\noch en `Sec-WebSocket-Key`, som är ett slumpmässigt värde på 16 byte kodat i\nbase64. En server som säger ja svarar med statuskoden 101 Switching Protocols\noch huvudfältet `Sec-WebSocket-Accept`. Värdet bevisar att servern har läst just\nden här handskakningen och inte spelar upp ett gammalt svar: det är klientens\nnyckel med ett fast GUID tillagt, hashat med SHA-1 och kodat i base64. Från och\nmed då är det slut med HTTP på anslutningen, och parterna skickar ramar i\nstället. HTTP/2 och HTTP/3 för i stället WebSocket över en ström med extended\nCONNECT, enligt RFC 8441 och RFC 9220.\n\nEn ram är liten. Ramhuvudet är minst två byte, växer med två eller åtta när\ninnehållet är längre än 125 byte, och med ytterligare fyra på ramar från\nklienten, som bär en maskeringsnyckel. Varje ram har en opcode: text, binärdata eller fortsättning när ett meddelande\när uppdelat på flera ramar, och därtill tre kontrollramar för stängning, ping\noch pong. Ett fullständigt textmeddelande måste vara giltig UTF-8; ett enskilt\nfragment kan dela en UTF-8-sekvens.\nVarje ram som en klient skickar maskeras med en ny slumpmässig 32-bitarsnyckel,\noch en server maskerar aldrig. Maskering är inte kryptering. Den finns för att\nett fientligt skript inte ska kunna välja exakt vilka byte som korsar nätverket\noch använda dem för att förgifta cachen i en proxy någonstans längs vägen.\n\nAdresserna börjar med `ws://` eller `wss://`, med port 80 och port 443 som\nstandard, och `wss` kör hela utbytet inuti TLS. Det är samma portar som HTTP\nredan använder, och det är avsiktligt: för brandväggar och proxyer längs vägen\nser handskakningen ut som vilken annan webbförfrågan som helst.\n\n## Varför det spelar roll\n\nMed korta HTTP-svar talar servern bara när den blir tilltalad. Många\nprodukter behöver det motsatta: ett chattmeddelande, ett pris som just har\nändrats, en markör i ett delat dokument, ett bakgrundsjobb som har blivit klart.\nUtan en kanal som servern kan skriva till måste klienten polla. Den frågar med\nnågra sekunders mellanrum, de flesta svaren säger bara att ingenting har\nändrats, varje svar bär en full uppsättning huvudfält, och en nyhet väntar upp\ntill ett helt intervall innan någon ser den. En öppen WebSocket-anslutning tar\nbort båda kostnaderna. Servern kan skicka när något händer utan att vänta på nästa pollning. Varje\nmeddelande behöver bara några få byte ramdata i stället för en fullständig\nuppsättning HTTP-huvudfält.\n\nPriset är att anslutningen bär tillstånd. En HTTP-förfrågan kan hamna på vilken\nserver som helst bakom en lastbalanserare, medan en WebSocket-anslutning hör\ntill en enda process så länge den lever. Den processen binder minne för varje\nöppen anslutning, en driftsättning eller omstart bryter alla på en gång, och\nvarje proxy och lastbalanserare längs vägen måste stödja handskakningen\noch tåla en anslutning som kanske är tyst i flera minuter. Kör man mer än en\nserver uppstår en fråga som vanlig HTTP aldrig ställer: när något händer på\nserver A, hur når det fram till en klient vars anslutning lever på server B? Det\nvanliga svaret är en gemensam publish/subscribe-kanal som alla servrar lyssnar\npå, och det är ännu ett system att hålla i drift.\n\nWebSocket är alltså ett medvetet val, inte en utgångspunkt. När bara servern har\nnågot att berätta kan server-sent events, som definieras i HTML-standarden,\nskicka händelser över ett vanligt HTTP-svar av typen `text/event-stream`, och\nwebbläsaren ansluter på nytt av sig själv när svaret bryts. WebSocket gör skäl\nför sina extra rörliga delar när klienten har lika mycket att säga som servern,\nsom i chatt, spel och samtidig redigering av samma dokument.\n\n## Så ser det ut i praktiken\n\nUtbytet nedan öppnar en chattanslutning. Nyckeln är exempelvärdet från själva\nRFC 6455, och värdet i `Sec-WebSocket-Accept` är det som standarden själv visar\noch som varje korrekt server måste skicka tillbaka för just den nyckeln.\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 tomma raden som avslutar serverns svar är ingenting på anslutningen\nHTTP längre. En webbläsare sköter hela handskakningen bakom ett enda anrop till\nkonstruktorn och lämnar resten åt händelselyssnare:\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\nStängningshändelsen berättar hur anslutningen slutade. Kod 1000 är en normal\nstängning, och 1001 betyder att ena parten går därifrån, till exempel en server\nsom stängs av eller en webbläsare som lämnar sidan. Kod 1006 betyder att\nanslutningen försvann helt utan någon stängningsram. Ingen av parterna får\nskicka den; den finns bara för att programmet ovanpå ska kunna skilja ett\nonormalt slut från ett rent.\n\nGränsen mellan förfrågan och svar å ena sidan och en öppen socket å den andra\nsyns tydligt i ett projekt i webbplatsens portfölj. När ett API flyttades över\ntill Huma v2,\n[gick de befintliga rutterna över till Humas modell med anrop och svar, utom exakt två](/sv/portfolio/migrated-the-api-to-huma-v2-at-100-parity/):\nslutpunkterna för WebSocket blev kvar på ren Fiber, eftersom koden där verkligen\nvill åt själva socketen och Humas modell inte passar. Ett ramverk som är byggt\nkring HTTP:s egen form beskriver och validerar förfrågningar och svar väl, och\nen långlivad tvåvägsanslutning är helt enkelt något annat.\n\n## Var det går fel\n\n**En sida på en annan webbplats öppnar en anslutning med dina besökares kakor.**\nWebbläsaren skickar handskakningsförfrågan till serverns värd och kan ta med\nvärdens kakor enligt webbläsarens kakpolicy. Där policyn tillåter\nautentiserade förfrågningar mellan webbplatser kan en server som autentiserar\nmed kakor och ignorerar `Origin` godta en anslutning som en sida på en annan\nwebbplats öppnar i besökarens namn. RFC 6455 säger att en server som bara är avsedd för vissa\nwebbplatser bör kontrollera `Origin` mot dem den väntar sig och avvisa resten\nmed 403 Forbidden. Gör det i handskakningen, innan anslutningen godtas.\n\n**En åtkomsttoken hamnar i loggarna.** Webbläsarens `WebSocket`-konstruktor tar\nen URL och en valfri lista med subprotokoll och inget annat, så ett skript kan\ninte lägga till ett `Authorization`-fält. Den snabba genvägen är en token i\nURL:en, där en omvänd proxy och åtkomstloggar skriver ned den. RFC:n lämnar\nautentiseringen öppen och nämner kakor, HTTP-autentisering och TLS-autentisering\nsom möjligheter. En kaka tillsammans med `Origin`-kontrollen ovan fungerar, och\ndet gör även en kortlivad engångsbiljett som sidan hämtar via ett autentiserat\nHTTP-anrop och använder i handskakningen.\n\n**En omstart gör alla klienter till en flodvåg.** En abrupt driftsättning eller omstart kan stänga alla anslutningar på en\ngång. Klienter som inte får någon stängningsram rapporterar kod 1006; om alla\nansluter igen direkt och fortsätter försöka kommer servern upp till något som\nRFC:n liknar vid en överbelastningsattack. RFC 6455 ber klienterna vänta en\nslumpmässig tid före första försöket, föreslår något mellan 0 och 5 sekunder och\nber dem sedan vänta längre efter varje misslyckande, till exempel med avkortad\nbinär exponentiell backoff. En server som stänger sina anslutningar med 1001\ninnan den stoppar talar åtminstone om för klienterna att avbrottet var planerat.\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**Anslutningar dör utan att någon märker det.** En anslutning utan trafik ger\ningen av parterna något tecken på att vägen fortfarande finns, och en motpart\nsom försvann utan en stängningsram ser precis ut som en tyst anslutning ända\ntills nästa skrivning misslyckas. Det är det ping och pong är till för: en slutpunkt måste svara på en ping med en pong om den inte redan har fått\nen stängningsram. Om flera ping är obesvarade får den nöja sig med att svara\npå den senaste. RFC:n nämner att en ping kan fungera som keepalive eller som\nen kontroll av att andra sidan fortfarande svarar. Webbläsarens API har inget sätt att skicka en ping, så timern hör hemma\npå servern: pinga varje anslutning med ett fast intervall och stäng dem som inte\nsvarar med pong.\n\n**Ett meddelande äter upp serverns minne.** Längdfältet i ett ramhuvud ger plats\nför innehåll som är långt större än någon server har minne till, och RFC:n\nvarnar för att en fientlig motpart kan skicka en enda enorm ram eller en ändlös\nrad små fragment. Implementationer måste skydda sig själva, så sätt en största\ntillåtna meddelandestorlek i serverbiblioteket och stäng med kod 1009, message\ntoo big, när en motpart går över den. Samma eftersläpning kan byggas upp åt\nandra hållet. I webbläsaren visar `bufferedAmount` hur många byte från `send()`\nsom fortfarande väntar på att komma ut på nätverket, och WHATWG:s exempel\nskickar nästa uppdatering först när talet är noll. På servern fyller en klient\nsom läser långsamt den utgående bufferten på samma sätt, så varje anslutning\nbehöver ett tak för den och en regel för vad som ska hända när taket är nått.\n\n## Läs mer\n\n- [RFC 6455: The WebSocket Protocol](https://www.rfc-editor.org/rfc/rfc6455) —\n  handskakningen, ramarna, maskeringen och stängningskoderna, och\n  säkerhetsresonemanget bakom var och en av dem.\n- [WebSockets Standard](https://websockets.spec.whatwg.org/) — webbläsarens API:\n  konstruktorn, `send()`, `close()`, `bufferedAmount` och stängningshändelsen.\n- [RFC 9110: HTTP Semantics](https://www.rfc-editor.org/rfc/rfc9110) —\n  huvudfältet `Upgrade` och statuskoden 101 Switching Protocols, som\n  handskakningen bygger på.\n- [Server-sent events](https://html.spec.whatwg.org/multipage/server-sent-events.html)\n  — HTML-standardens envägsalternativ med inbyggd återanslutning.\n- [RFC 8441: Bootstrapping WebSockets with HTTP/2](https://www.rfc-editor.org/rfc/rfc8441)\n  — extended CONNECT för WebSocket över en multiplexerad HTTP/2-ström.\n- [RFC 9220: Bootstrapping WebSockets with HTTP/3](https://www.rfc-editor.org/rfc/rfc9220)\n  — motsvarande extended-CONNECT-mekanism för HTTP/3.\n\n\u003chttps://engineer.company/sv/glossary/websocket/\u003e\n","date_modified":"2026-11-09T21:50:25Z","description":"Hur en enda HTTP-förfrågan blir en öppen tvåvägsanslutning, när det slår polling och fem sätt som en långlivad anslutning kan gå fel på.","formats":{"gemtext":"https://engineer.company/sv/glossary/websocket/index.gmi","gopher":"https://engineer.company/sv/glossary/websocket/gophermap","html":"https://engineer.company/sv/glossary/websocket/","json":"https://engineer.company/sv/glossary/websocket/index.json","markdown":"https://engineer.company/sv/glossary/websocket/index.md","pdf":"https://engineer.company/sv/glossary/websocket/index.pdf"},"kind":"page","language":"sv","title":"Vad är WebSocket?","url":"https://engineer.company/sv/glossary/websocket/","version":1}