{"canonical_url":"https://engineer.company/sv/glossary/grpc/","content_markdown":"# gRPC\n\n## Vad det är\n\ngRPC är ett ramverk för fjärrproceduranrop. Ett program anropar en metod på en\nserver som körs på en annan maskin som om servern vore ett lokalt objekt, och\ngRPC för anropet över nätverket i ett eget protokoll ovanpå HTTP/2 och lämnar\ntillbaka svaret som ett returvärde.\n\nAllt börjar med en tjänstedefinition: de metoder som kan anropas utifrån, med\ntypen för varje begäran och varje svar. Som standard skrivs den i Protocol\nBuffers, Googles format med öppen källkod för att serialisera data oberoende av\nspråk och plattform, i en fil vars namn slutar på `.proto`. Andra format kan\nkopplas in, men protocol buffers är det gRPC använder om inget annat anges.\nKompilatorn `protoc` läser filen tillsammans med ett gRPC-plugin och genererar\nkod för båda halvorna. Klienten får en stub, ett lokalt objekt med samma metoder\nsom tjänsten (i vissa språk kallas den helt enkelt klienten), och servern får\nett gränssnitt att implementera. Eftersom båda halvorna kommer från samma fil\nkan en server skriven i Java svara klienter skrivna i Go, Python eller Ruby.\n\nEn metod har en av fyra former. En unär metod tar emot en begäran och returnerar\nett svar, som ett vanligt funktionsanrop. En metod med serverströmning tar emot\nen begäran och skickar tillbaka en ström av svar, en metod med klientströmning\ngör tvärtom, och en metod med dubbelriktad strömning låter båda sidor skicka\nsina strömmar oberoende av varandra. Inom ett och samma anrop garanterar gRPC\natt meddelandena kommer fram i den ordning de skickades.\n\nUnder huven körs gRPC över HTTP/2. Varje anrop är en `POST` till en sökväg som\nbestår av tjänstens fullständigt kvalificerade namn och metodens namn, med\ninnehållstypen `application/grpc`. Varje meddelande skickas bakom ett prefix på\nfem byte: en byte som anger om meddelandet är komprimerat och fyra som anger\ndess längd. Anropets utfall är inte HTTP-statusen. Ett svar som gRPC själv\nskapar har status 200 även när anropet misslyckas, och det egentliga resultatet\nkommer i trailers, huvudfält som skickas efter meddelandekroppen: `grpc-status`\nmed ett tal och eventuellt `grpc-message` med en beskrivning av felet.\n\nDet gör gRPC till något helt annat än REST. Ett REST-API namnger resurser och\narbetar med dem genom HTTP:s egna metoder och statuskoder, oftast med\nJSON-kroppar som vem som helst kan läsa. Ett gRPC-API är en lista med metoder\nmed typade, binära meddelanden, och HTTP/2 är bara transporten under.\nDokumentationen för Protocol Buffers sammanfattar själv sitt format så här: ”som\nJSON, fast mindre och snabbare”.\n\n## Varför det spelar roll\n\nKontraktet kommer först och koden följer av det. I många HTTP-API:er är\nbeskrivningen och koden som levererar API:et två separata saker som kan glida\nisär, och en klient skrivs ofta för hand utifrån ett dokument. I gRPC är\n`.proto`-filen det enda stället där en metod eller ett fält definieras, och alla\nklienter och servrar genereras från den. En ändring av ett meddelande når alla\nspråk genom samma generator och inte genom att någon läser om ett dokument.\n\nKodningen är kompakt eftersom varje fält skickas som sitt nummer och sitt värde\ni stället för sitt namn. Priset är att ett meddelande inte kan tolkas fullt ut\nutan sin `.proto`-fil, eftersom protocol buffers inte beskriver sig själva, och\natt formatet förutsätter att ett helt meddelande ryms i minnet på en gång.\nFormatets egen dokumentation rekommenderar en annan lösning för data som är\nstörre än några megabyte.\n\nStrömning är en del av designen och inte ett tillägg. Anrop körs som strömmar på\nHTTP/2-anslutningar, så en metod med serverströmning kan fortsätta skicka\nresultat genom samma maskineri som ett anrop som svarar en gång.\n\nTidsgränser följer med anropet. En klient sätter en tidsfrist, en deadline som\ngRPC kallar det, gRPC skickar det som återstår av den i huvudfältet\n`grpc-timeout`, och när tiden tar slut får klienten `DEADLINE_EXCEEDED` och\nserverns sida av anropet avbryts. När en server i sin tur anropar en annan\nserver skickar vissa implementationer tidsfristen vidare: Java och Go gör det\nsom standard, medan det måste slås på i C++. Eftersom tidsfristen passerar varje\nled som återstående tid och inte som ett klockslag, ger maskiner vars klockor\ngår olika ändå upp vid samma tidpunkt.\n\nFel har ett gemensamt ordförråd. gRPC definierar 17 statuskoder, från 0 `OK`\ntill 16 `UNAUTHENTICATED`, och de är en del av själva protokollet, så en\nGo-klient och en Java-server är överens om vad `NOT_FOUND` eller `UNAVAILABLE`\nbetyder.\n\nAllt detta passar trafik mellan tjänster som ett team eller ett företag\nkontrollerar, där båda ändar kan dela `.proto`-filerna och bygga från dem. Det\npassar sämre för webbläsaren. gRPC-projektets egna protokollanteckningar säger\natt webbläsare inte ger skript tillgång till ramarna i HTTP/2 och aldrig kommer\natt göra det, så kod i webbläsaren talar ett separat protokoll, gRPC-Web, och i\nden vanliga uppsättningen översätter en proxy det till vanlig gRPC.\n\n## Så ser det ut i praktiken\n\nHär är en liten faktureringstjänst. En unär metod hämtar en faktura och en metod\nmed serverströmning skickar en kunds fakturor en i taget:\n\n```protobuf\nsyntax = \"proto3\";\n\npackage billing.v1;\n\nservice InvoiceService {\n  rpc GetInvoice(GetInvoiceRequest) returns (Invoice);\n  rpc WatchInvoices(WatchInvoicesRequest) returns (stream Invoice);\n}\n\nmessage GetInvoiceRequest {\n  string invoice_id = 1;\n}\n\nmessage WatchInvoicesRequest {\n  string customer_id = 1;\n}\n\nmessage Invoice {\n  reserved 4;\n  reserved \"discount_code\";\n  string invoice_id = 1;\n  string customer_id = 2;\n  int64 total_cents = 3;\n  string currency = 5;\n}\n```\n\nSiffrorna är inte standardvärden. De är fältnummer, och i den binära kodningen\nidentifierar de varje fält i stället för dess namn. Nummer 1 till 15 tar en byte\natt koda, så de hör till de fält som oftast är satta. De två `reserved`-raderna\nhåller reda på ett fält som en gång fanns, nummer 4 med namnet `discount_code`,\nså att varken numret eller namnet kan komma tillbaka som ett annat fält.\n\nFör Python genererar ett enda kommando `billing_pb2.py` med meddelandeklasserna\noch `billing_pb2_grpc.py` med klient- och serverklasserna:\n\n```sh\npython -m grpc_tools.protoc -Iprotos \\\n  --python_out=. --grpc_python_out=. protos/billing.proto\n```\n\nEtt enskilt anrop till `GetInvoice` ser då ut så här som HTTP/2-ramar:\n\n```text\nHEADERS (flags = END_HEADERS)\n:method = POST\n:scheme = https\n:path = /billing.v1.InvoiceService/GetInvoice\n:authority = billing.example.com\nte = trailers\ncontent-type = application/grpc+proto\ngrpc-timeout = 2S\n\nDATA (flags = END_STREAM)\n\u003cLength-Prefixed Message\u003e\n\nHEADERS (flags = END_HEADERS)\n:status = 200\ncontent-type = application/grpc+proto\n\nDATA\n\u003cLength-Prefixed Message\u003e\n\nHEADERS (flags = END_STREAM, END_HEADERS)\ngrpc-status = 0\n```\n\n`2S` betyder två sekunder, och `te = trailers` finns där för att upptäcka\nproxyservrar som inte är kompatibla med gRPC. Om fakturan inte finns börjar\nsvaret ändå med `:status = 200`, och den sista ramen bär `grpc-status = 5`, som\när `NOT_FOUND`, tillsammans med ett `grpc-message` som `invoice not found`. En\nserver som misslyckas direkt kan till och med skicka en enda `HEADERS`-ram med\nstatusen och inget meddelande alls.\n\nAtt generera båda sidor från ett kontrakt är inget unikt för gRPC. Ett projekt i\nwebbplatsens portfölj\n[genererade API-kontraktet utåt från databasen](/sv/portfolio/generated-the-api-contract-from-the-database-out/)\nför ett API som beskrivs med OpenAPI. Kedjan börjar i databasen och går utåt:\nGo-typerna definierar API:et, Huma genererar OpenAPI-beskrivningen utifrån dem,\nen typad TypeScript-klient och mock-hanterare genereras från den beskrivningen,\noch en kontraktskontroll i CI stoppar bygget när det frontenden skickar inte\nlängre stämmer med vad API:et förväntar sig. gRPC bygger in samma disciplin i\nsin verktygskedja, med `.proto`-filen som enda källa.\n\n## Var det går fel\n\n**Ett anrop utan tidsfrist kan vänta för evigt.** gRPC sätter ingen tidsfrist\nsom standard, så en klient som anropar en server som har hängt sig kan i\npraktiken vänta på ett svar för evigt. Ge varje anrop en realistisk tidsfrist. I\nPython är det argumentet `timeout`, angivet i sekunder:\n\n```python\nimport grpc\n\nimport billing_pb2\nimport billing_pb2_grpc\n\ncredentials = grpc.ssl_channel_credentials()\nwith grpc.secure_channel(\"billing.example.com:443\", credentials) as channel:\n    stub = billing_pb2_grpc.InvoiceServiceStub(channel)\n    request = billing_pb2.GetInvoiceRequest(invoice_id=\"INV-1001\")\n    invoice = stub.GetInvoice(request, timeout=2.0)\n```\n\nNär tiden tar slut kastar anropet `grpc.RpcError`, och undantagets `code()`\nreturnerar `grpc.StatusCode.DEADLINE_EXCEEDED`. På servern avbryter gRPC anropet\nmed `CANCELLED` när tidsfristen har passerat, men det är tjänstens egen kod som\nmåste stoppa det arbete som hanteraren har satt i gång, så en hanterare som\narbetar länge måste själv kontrollera om anropet har avbrutits och sluta.\n\n**En timeout betyder inte att inget har hänt.** Klient och server avgör var för\nsig om ett anrop lyckades, så ett anrop kan slutföras på servern och ändå\nmisslyckas hos klienten med `DEADLINE_EXCEEDED`. Ändringar som gjordes före ett\navbrott rullas inte heller tillbaka. En klient som bara försöker igen kan skapa\nsamma faktura två gånger. Protokollet antar inte att ett anrop är idempotent om\ndet inte uttryckligen är markerat så. `UNAVAILABLE` är den kod som oftast är\ntillfällig och värd att försöka igen med backoff, men dokumentationen av\nstatuskoderna varnar för att det inte alltid är säkert att upprepa operationer\nsom inte är idempotenta. Samma dokument överlåter åt koden som gör anropen att\nvälja vilka koder som ska försökas igen.\n\n**Ett återanvänt fältnummer förstör data.** Ett fältnummer kan inte ändras när\nmeddelandetypen väl används. Om ett fält tas bort och dess nummer senare går\ntill ett nytt fält, avkodar äldre klienter och lagrade meddelanden det nya\nfältet från byte som betydde något annat. Guiden för Protocol Buffers räknar upp\nvad som kan följa: parsningsfel, läckta personuppgifter och korrupta data.\nNumrera aldrig om ett fält, och reservera varje borttaget nummer och namn, som i\nexemplet ovan.\n\n**Varje fel ser ut som en framgång för HTTP.** Eftersom gRPC svarar med\nHTTP-status 200 även när ett anrop misslyckas, räknar allt som bedömer trafik\nefter HTTP-statusen ensam, till exempel en åtkomstlogg eller en felfrekvens\nbyggd på statuskoder, fel som lyckade anrop. Specifikationen ber servrar svara\n415 på begäranden vars innehållstyp inte är `application/grpc`, just av det\nskälet, så att andra HTTP/2-klienter inte läser ett gRPC-fel som en framgång.\nRäkna på `grpc-status`, inte på `:status`.\n\n**Långa strömmar binder sin last till en server.** Anrop körs som strömmar på en\ndelad HTTP/2-anslutning, och när en ström väl har startat kan den inte flyttas\ntill en annan server. En ström som lever i timmar behåller sin last där den\nbörjade, hur många servrar som än läggs till senare. Varje anslutning har också\nen gräns för samtidiga strömmar, och när den är nådd väntar ytterligare anrop\nhos klienten tills en ström blir klar. Prestandaguiden för gRPC rekommenderar\natt strömma bara där det ger en väsentlig vinst i prestanda eller enkelhet, och\nen separat kanal för varje område med hög last.\n\n**Stora datamängder ryms inte i ett meddelande.** gRPC tillämpar en maximal\nmeddelandestorlek, och ett meddelande som är större än den inställda gränsen\nmisslyckas med `RESOURCE_EXHAUSTED` på den sida som skickar eller tar emot det.\nAtt höja gränsen flyttar bara problemet, eftersom protocol buffers förväntar sig\nhela meddelandet i minnet, och med stora data kan flera serialiserade kopior av\ndet ligga där samtidigt. Dela upp stora data i en ström av mindre meddelanden,\neller flytta dem utanför gRPC.\n\n## Läs mer\n\n- [Core concepts, architecture and lifecycle](https://grpc.io/docs/what-is-grpc/core-concepts/)\n  — tjänstedefinitioner, de fyra typerna av metoder, stubbar, tidsfrister och\n  avbrytande.\n- [gRPC over HTTP2](https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md)\n  — protokollet på nätverksnivå: sökvägar, huvudfält, meddelandeprefixet och\n  statusen i trailers.\n- [Status Codes](https://grpc.io/docs/guides/status-codes/) — alla 17 koder, vad\n  var och en betyder och vilka biblioteket självt aldrig skapar.\n- [Deadlines](https://grpc.io/docs/guides/deadlines/) — varför det inte finns\n  något standardvärde, hur tidsfrister når servern och hur de förs vidare mellan\n  tjänster.\n- [Language Guide (proto 3)](https://protobuf.dev/programming-guides/proto3/) —\n  fältnummer, reserverade fält och reglerna för att ändra en meddelandetyp på\n  ett säkert sätt.\n\n\u003chttps://engineer.company/sv/glossary/grpc/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Hur en .proto-fil blir genererade klienter och servrar över HTTP/2, och vad som kan gå fel med tidsfrister, fältnummer och omförsök.","formats":{"gemtext":"https://engineer.company/sv/glossary/grpc/index.gmi","gopher":"https://engineer.company/sv/glossary/grpc/gophermap","html":"https://engineer.company/sv/glossary/grpc/","json":"https://engineer.company/sv/glossary/grpc/index.json","markdown":"https://engineer.company/sv/glossary/grpc/index.md","pdf":"https://engineer.company/sv/glossary/grpc/index.pdf"},"kind":"page","language":"sv","title":"Vad är gRPC?","url":"https://engineer.company/sv/glossary/grpc/","version":1}