{"canonical_url":"https://engineer.company/sv/glossary/http/","content_markdown":"# HTTP\n\n## Vad det är\n\nHTTP, Hypertext Transfer Protocol, är de regler som en webbläsare, en app eller ett skript följer\nnär den ber en server om något och tar emot ett svar. Går samtalet inuti en krypterad\nTLS-anslutning heter samma protokoll HTTPS. Varje utbyte har två halvor. Klienten skickar en\nbegäran: en metod som `GET` eller `POST`, det mål den vill åt, en lista med huvudfält och ibland en\nkropp. Servern svarar med en statuskod på tre siffror, egna huvudfält och oftast en kropp. Att\nladda en sida, hämta en bild och låta ett program anropa ett annat är alla samma utbyte, upprepat.\n\n```http\nGET /pricing/ HTTP/1.1\nHost: example.com\nAccept: text/html\n\nHTTP/1.1 200 OK\nContent-Type: text/html; charset=utf-8\nCache-Control: max-age=600\n```\n\nSpecifikationen kallar protokollet tillståndslöst. Varje begäran måste bära allt som servern\nbehöver för att förstå den, och protokollet minns ingenting från ett utbyte till nästa.\nInloggningar, varukorgar och sessioner byggs ovanpå, oftast med kakor: ett huvudfält som servern\nsätter en gång och som klienten skickar tillbaka i varje senare begäran.\n\nOrdförrådet är litet och exakt. `GET` och `HEAD` är säkra, vilket betyder att de ber om en\nrepresentation och förväntas lämna allt orört. `PUT` och `DELETE` är idempotenta: att skicka samma\nbegäran två gånger lämnar servern där en enda gång hade lämnat den. `POST` lovar ingetdera.\nStatuskoderna grupperas efter första siffran, 2xx för framgång, 3xx för omdirigering, 4xx för ett\nproblem med begäran och 5xx för ett problem på servern, så en klient som möter en okänd kod vet\nändå ungefär vad som hände.\n\nDen betydelsen har legat fast medan överföringsformatet har bytts ut två gånger. HTTP/1.1 skriver\nmeddelanden som textrader över en TCP-anslutning, och varje anslutning lämnar sina svar ett i\ntaget, i ordning. HTTP/2 behåller samma metoder och fält men ramar in dem binärt och flätar ihop\nmånga begäranden på en anslutning. HTTP/3 förmedlar samma semantik över QUIC, en transport byggd på UDP,\nsom undviker TCP:s blockering längst fram i kön på transportlagret mellan oberoende strömmar. Sedan 2022 publicerar IETF\nsemantiken i ett dokument och varje versions överföringsformat i ett annat, och därför har frågan om vad\n404 betyder och frågan om hur byteföljden är uppbyggd numera var sitt svar.\n\nHTTP mot HTTPS är alltså ingen tävling mellan två protokoll: HTTPS är HTTP med TLS under, som\nkrypterar utbytet och bevisar serverns namn. WebSocket börjar som en HTTP-begäran och uppgraderar\nsedan anslutningen till en kanal åt båda hållen, och gRPC är en konvention för att anropa\nfjärrfunktioner som körs över HTTP/2.\n\n## Varför det spelar roll\n\nNästan varje system som talar med ett annat över internet talar redan HTTP, så det beslut som\nräknas handlar sällan om huruvida ni ska använda det. Det handlar om ni använder det som HTTP\ndefinierar, eller behandlar det som ett rör och bygger upp resten på nytt ovanpå.\n\nAtt använda protokollet fullt ut lönar sig, eftersom en lång kedja av mjukvara redan läser\nordförrådet. Ett klientbibliotek får försöka igen med en `GET` som tog för lång tid; en `POST`\nmåste det låta bli, och detsamma gäller varje proxy på vägen. En cache kan spara ett svar märkt\n`max-age=600` i tio minuter och lämna det till nästa läsare utan att fråga servern. Övervakning\nräknar 5xx-svar som fel utan att någon säger åt den. Ett API som skickar varje anrop som en `POST`\ntill en enda adress och rapporterar fel inuti ett 200-svar avstår från allt det, och varje klient\nmåste då lära sig just det API:ets privata regler.\n\nModellen har sina gränser. Begäran och svar passar en klient som vet vad den vill ha; de passar\nbetydligt sämre en server som har nyheter att skicka ut, och därför färdas liveuppdateringar\noftast över WebSocket, server-sent events eller upprepad avfrågning.\n\nOkrypterad HTTP på det publika internet är en annan fråga med ett kort svar. Webbläsare märker\nden som osäker, vem som helst på vägen kan läsa och ändra den, och certifikat kostar ingenting,\nså publik trafik hör hemma på HTTPS. Valet mellan HTTP/1.1, HTTP/2 och HTTP/3 är mest en\ninställning på servern eller på kanten framför den, och applikationskoden förblir densamma\neftersom varje begäran betyder samma sak.\n\n## Så ser det ut i praktiken\n\nDet tydligaste fallet på den här webbplatsen är ett API som flyttades till ett ramverk byggt\nkring HTTP:s egen form.\n[HTTP-API:t flyttades från Fiber till Huma v2](/sv/portfolio/migrated-the-api-to-huma-v2-at-100-parity/),\nsom ligger ovanpå Fiber. Varje slutpunkt deklareras med structar för indata och utdata, och\nvalideringen följer av typerna i stället för av kontroller som skrivits för hand. En\nOpenAPI-beskrivning kommer på köpet ur samma deklarationer, och en kontroll i CI jämför de rutter\nsom servern registrerar med dem som beskrivningen utlovar. Vid 649 sökvägar och 760 operationer\när pariteten 100 %, och den ligger kvar där eftersom en rutt som saknar beskrivning stoppar\nbygget. Exakt två slutpunkter blev kvar på ren Fiber: de för WebSocket, där Humas modell med\nbegäran och svar inte passar.\n\nWebbplatsen själv använder innehållsförhandling. Varje sida publiceras både som HTML och som\nMarkdown, och ett sätt att få Markdown är att skicka\n[en begäran med `Accept: text/markdown` och låta servern välja](/sv/cli/). Samma sida förklarar\nvarför onion-adressen med avsikt är vanlig `http://`: adressen innehåller tjänstens publika nyckel i kodad form,\nså kretsen är autentiserad och krypterad innan något HTTP alls talas.\n\nHTTP dyker också upp som verktyg i infrastrukturkod. När en andra server provisionerades\n[skrevs båda leverantörernas brandväggar direkt mot deras REST-API:er](/sv/portfolio/provisioned-a-second-server-from-code/)\ngenom en generisk HTTP-task i stället för en collection från leverantören. Det tog bort ett\nberoende och dess versionsglidning, till priset av att varje begärans form skrivs för hand. Det\nhar ytterligare en kostnad som sidan namnger: den generiska HTTP-tasken deklarerar inget stöd för\ncheck mode, så en torrkörning av den play som skapar maskinen hoppar över varje task i den, och\nprovkörningen görs i stället mot brandväggens play.\n\n## Var det går fel\n\nDe flesta HTTP-buggar uppstår när ett ord i ordförrådet används för att betyda något annat än det\nsom resten av kedjan hör.\n\n### Ett fel som kommer fram som en framgång\n\nEtt API svarar 200 och lägger `\"error\": \"card declined\"` i kroppen. En cache kan spara svaret,\ninstrumentpanelerna räknar det som en framgång, och klientens logik för nya försök startar\naldrig. Skicka den statuskod som stämmer, 4xx eller 5xx, och beskriv problemet i kroppen;\nRFC 9457 definierar en JSON-form för det, serverad som `application/problem+json`.\n\n### En länk som raderar saker\n\nEn `GET`-begäran ändrar tillstånd, till exempel en länk för att avsluta en prenumeration eller\nradera något i ett mejl. Sökrobotar, länkförhandsvisningar i chattappar, säkerhetsskannrar och\nwebbläsarens förhämtning följer alla länkar på egen hand, och var och en av dem kan utlösa den.\nAllt som ändrar data hör hemma bakom `POST`, `PUT` eller `DELETE`, med en sida för bekräftelse om\nlänken måste finnas.\n\n### En betalning som dras två gånger\n\nKlienten skickar en `POST`, anslutningen bryts innan svaret kommer fram, och klienten försöker\nigen. Servern hade redan behandlat den första. HTTP ger klienten inget sätt att skilja de två\nfallen åt, så API:et måste göra det: ta emot en idempotensnyckel i ett huvudfält och lämna tillbaka\ndet sparade resultatet för en upprepad nyckel, eller låta klienten välja den nya resursens\nidentifierare och skapa den med `PUT`.\n\n### Ett formulär som blir en GET\n\nEn server svarar på en `POST` med 301 eller 302 för att skicka den vidare. Av historiska skäl\ntillåter specifikationen klienter att byta metod till `GET` för de två koderna, och många gör det,\nså kroppen försvinner på vägen. När metoden måste överleva omdirigeringen är det 307 eller 308\nsom gäller.\n\n### Fel variant ur en cache\n\nEn URL serverar HTML eller Markdown, engelska eller danska, beroende på huvudfälten i begäran. En\ncache som inte har fått veta något sparar den variant den såg först och lämnar den till nästa\nläsare. Svaret måste namnge de fält det beror på, till exempel `Vary: Accept`, så att en cache\nhåller en kopia per variant i stället för en per URL.\n\n## Läs mer\n\n- [RFC 9110: HTTP Semantics](https://www.rfc-editor.org/rfc/rfc9110) — metoder, statuskoder och\n  huvudfält, definierade en gång för alla versioner.\n- [RFC 9111: HTTP Caching](https://www.rfc-editor.org/rfc/rfc9111) — när ett sparat svar får\n  återanvändas och vad `Cache-Control` säger till en cache.\n- [RFC 9112: HTTP/1.1](https://www.rfc-editor.org/rfc/rfc9112) — trådformatet i text, hanteringen\n  av anslutningar och hur meddelanden avgränsas.\n- [RFC 9113: HTTP/2](https://www.rfc-editor.org/rfc/rfc9113) — binära ramar och många strömmar\n  över en anslutning.\n- [RFC 9114: HTTP/3](https://www.rfc-editor.org/rfc/rfc9114) — samma semantik överförd till\n  strömmar i QUIC.\n- [RFC 9457: Problem Details for HTTP APIs](https://www.rfc-editor.org/rfc/rfc9457) — en\n  standardiserad JSON-kropp som beskriver vad som gick fel.\n\n\u003chttps://engineer.company/sv/glossary/http/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hur en HTTP-begäran och ett svar är byggda, vad metoder och statuskoder lovar resten av kedjan, vad HTTP/2 och HTTP/3 ändrar och fem vanliga API-misstag.","formats":{"gemtext":"https://engineer.company/sv/glossary/http/index.gmi","gopher":"https://engineer.company/sv/glossary/http/gophermap","html":"https://engineer.company/sv/glossary/http/","json":"https://engineer.company/sv/glossary/http/index.json","markdown":"https://engineer.company/sv/glossary/http/index.md","pdf":"https://engineer.company/sv/glossary/http/index.pdf"},"kind":"page","language":"sv","title":"Vad är HTTP?","url":"https://engineer.company/sv/glossary/http/","version":1}