{"canonical_url":"https://engineer.company/da/glossary/grpc/","content_markdown":"# gRPC\n\n## Hvad det er\n\ngRPC er et framework til fjernprocedurekald. Et program kalder en metode på en\nserver, der kører på en anden maskine, som om serveren var et lokalt objekt, og\ngRPC fører kaldet over netværket i sin egen protokol oven på HTTP/2 og leverer\nsvaret tilbage som en returværdi.\n\nAlt begynder med en tjenestedefinition: de metoder, der kan kaldes udefra, med\ntypen på hver forespørgsel og hvert svar. Som standard skrives den i Protocol\nBuffers, Googles open source-format til at serialisere data uafhængigt af sprog\nog platform, i en fil, hvis navn ender på `.proto`. Andre formater er mulige,\nmen protocol buffers er standardvalget. Compileren `protoc` læser filen sammen\nmed et gRPC-plugin og genererer kode til begge halvdele. Klienten får en stub,\net lokalt objekt med de samme metoder som tjenesten (i nogle sprog hedder den\nbare klienten), og serveren får en grænseflade, den skal implementere. Fordi\nbegge halvdele kommer fra samme fil, kan en server skrevet i Java svare klienter\nskrevet i Go, Python eller Ruby.\n\nEn metode har en af fire former. En unær metode tager én forespørgsel og\nreturnerer ét svar, ligesom et almindeligt funktionskald. En metode med\nserverstreaming tager én forespørgsel og sender en strøm af svar tilbage, en\nmetode med klientstreaming gør det omvendte, og en metode med tovejsstreaming\nlader begge sider sende deres strømme uafhængigt af hinanden. Inden for ét kald\ngaranterer gRPC, at beskederne når frem i den rækkefølge, de blev sendt i.\n\nUnder motorhjelmen kører gRPC over HTTP/2. Hvert kald er en `POST` til en sti,\nder består af tjenestens fuldt kvalificerede navn og metodens navn, med\nindholdstypen `application/grpc`. Hver besked sendes bag et præfiks på fem byte:\nén byte, der angiver, om beskeden er komprimeret, og fire, der angiver dens\nlængde. Kaldets udfald er ikke HTTP-statussen. Et svar, som gRPC selv danner,\nhar status 200, også når kaldet fejler, og det egentlige resultat kommer i\ntrailere, headerfelter, der sendes efter brødteksten: `grpc-status` med et tal\nog eventuelt `grpc-message` med en beskrivelse af fejlen.\n\nDet gør gRPC til noget helt andet end REST. Et REST-API navngiver ressourcer og\narbejder på dem med HTTP's egne metoder og statuskoder, som regel med\nbrødtekster i JSON, som alle kan læse. Et gRPC-API er en liste af metoder med\ntypede, binære beskeder, og HTTP/2 er bare transporten nedenunder.\nDokumentationen til Protocol Buffers sammenfatter selv sit format som »ligesom\nJSON, bare mindre og hurtigere«.\n\n## Hvorfor det betyder noget\n\nKontrakten kommer først, og koden følger af den. Med mange HTTP-API'er er\nbeskrivelsen og den kode, der leverer API'et, to adskilte ting, der kan glide\nfra hinanden, og en klient bliver ofte skrevet i hånden ud fra et dokument. I\ngRPC er `.proto`-filen det ene sted, hvor en metode eller et felt defineres, og\nalle klienter og servere genereres ud fra den. En ændring af en besked når ud\ntil alle sprog gennem den samme generator og ikke ved, at nogen genlæser et\ndokument.\n\nKodningen er kompakt, fordi hvert felt sendes som sit nummer og sin værdi i\nstedet for sit navn. Prisen er, at en besked ikke kan tolkes fuldt ud uden sin\n`.proto`-fil, da protocol buffers ikke beskriver sig selv, og at formatet går ud\nfra, at en hel besked kan ligge i hukommelsen på én gang. Formatets egen\ndokumentation anbefaler en anden løsning til data på mere end et par megabyte.\n\nStreaming er en del af designet og ikke en tilføjelse. Kald kører som streams på\nHTTP/2-forbindelser, så en metode med serverstreaming kan blive ved med at sende\nresultater gennem det samme maskineri som et kald, der svarer én gang.\n\nTidsgrænser følger med kaldet. En klient sætter en deadline, gRPC sender det,\nder er tilbage af den, i headeren `grpc-timeout`, og når tiden løber ud, får\nklienten `DEADLINE_EXCEEDED`, og serverens side af kaldet bliver annulleret. Når\nen server selv kalder en anden server, sender nogle implementeringer deadlinen\nvidere: Java og Go gør det som standard, mens det skal slås til i C++. Fordi\ndeadlinen krydser hvert led som den resterende tid og ikke som et klokkeslæt,\ngiver maskiner, hvis ure går forskelligt, alligevel op på samme tidspunkt.\n\nFejl har ét fælles ordforråd. gRPC definerer 17 statuskoder, fra 0 `OK` til 16\n`UNAUTHENTICATED`, og de er en del af selve protokollen, så en Go-klient og en\nJava-server er enige om, hvad `NOT_FOUND` eller `UNAVAILABLE` betyder.\n\nAlt dette passer til trafik mellem tjenester, som ét team eller én virksomhed\nstyrer, hvor begge ender kan dele `.proto`-filerne og bygge ud fra dem. Det\npasser dårligere til browseren. gRPC-projektets egne protokolnoter siger, at\nbrowsere ikke giver scripts adgang til HTTP/2-framingen og aldrig vil gøre det,\nså kode i browseren taler en separat protokol, gRPC-Web, og i den typiske\nopsætning oversætter en proxy den til almindelig gRPC.\n\n## Sådan ser det ud i praksis\n\nHer er en lille faktureringstjeneste. En unær metode henter en faktura, og en\nmetode med serverstreaming sender en kundes fakturaer én ad gangen:\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\nTallene er ikke standardværdier. Det er feltnumre, og i den binære kodning\nidentificerer de hvert felt i stedet for dets navn. Numrene fra 1 til 15 fylder\nén byte, så de hører til de felter, der oftest er sat. De to `reserved`-linjer\nholder styr på et felt, der engang fandtes, nummer 4 med navnet `discount_code`,\nså hverken nummeret eller navnet kan vende tilbage som et andet felt.\n\nTil Python genererer én kommando `billing_pb2.py` med beskedklasserne og\n`billing_pb2_grpc.py` med klient- og serverklasserne:\n\n```sh\npython -m grpc_tools.protoc -Iprotos \\\n  --python_out=. --grpc_python_out=. protos/billing.proto\n```\n\nEt enkelt kald til `GetInvoice` ser så sådan ud som HTTP/2-frames:\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 to sekunder, og `te = trailers` er der for at opdage proxyer, der\nikke er kompatible med gRPC. Hvis fakturaen ikke findes, begynder svaret stadig\nmed `:status = 200`, og den sidste frame bærer `grpc-status = 5`, som er\n`NOT_FOUND`, sammen med en `grpc-message` som `invoice not found`. En server,\nder fejler med det samme, kan endda sende en enkelt `HEADERS`-frame med\nstatussen og slet ingen besked.\n\nAt generere begge sider ud fra én kontrakt er ikke noget særligt for gRPC. Et\nprojekt i sitets portefølje\n[genererede API-kontrakten udad fra databasen](/da/portfolio/generated-the-api-contract-from-the-database-out/)\ntil et API beskrevet med OpenAPI. Kæden starter ved databasen og løber udad:\nGo-typerne definerer API'et, Huma genererer OpenAPI-beskrivelsen ud fra dem, en\ntypet TypeScript-klient og mock-handlere genereres ud fra den beskrivelse, og et\nkontrakttjek i CI får buildet til at fejle, når det, frontenden sender, ikke\nlængere stemmer med det, API'et forventer. gRPC bygger den samme disciplin ind i\nsin værktøjskæde med `.proto`-filen som eneste kilde.\n\n## Hvor det går galt\n\n**Et kald uden deadline kan vente for evigt.** gRPC sætter ingen deadline som\nstandard, så en klient, der kalder en server, som er gået i stå, kan i praksis\nvente på et svar for evigt. Giv hvert kald en realistisk deadline. I Python er\ndet 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 løber ud, rejser kaldet `grpc.RpcError`, og dets `code()` returnerer\n`grpc.StatusCode.DEADLINE_EXCEEDED`. På serveren annullerer gRPC kaldet med\n`CANCELLED`, når deadlinen er overskredet, men det er tjenestens egen kode, der\nskal standse det arbejde, handleren har sat i gang, så en handler, der arbejder\nlænge, selv må tjekke, om kaldet er annulleret, og stoppe.\n\n**En timeout betyder ikke, at intet er sket.** Klient og server afgør hver for\nsig, om et kald lykkedes, så et kald kan gennemføres på serveren og alligevel\nfejle hos klienten med `DEADLINE_EXCEEDED`. Ændringer, der blev foretaget før en\nannullering, bliver heller ikke rullet tilbage. En klient, der bare prøver igen,\nkan oprette den samme faktura to gange. Protokollen antager ikke, at et kald er\nidempotent, medmindre det udtrykkeligt er angivet. `UNAVAILABLE` er den kode,\nder oftest er forbigående og værd at prøve igen med backoff, men dokumentationen\naf statuskoderne advarer om, at det ikke altid er sikkert at gentage\noperationer, der ikke er idempotente. Samme dokument overlader det til den kode,\nder foretager kaldene, at vælge, hvilke koder der skal prøves igen.\n\n**Et genbrugt feltnummer ødelægger data.** Et feltnummer kan ikke ændres, når\nbeskedtypen først er i brug. Hvis et felt slettes, og dets nummer senere går til\net nyt felt, afkoder ældre klienter og gemte beskeder det nye felt ud fra bytes,\nder betød noget andet. Guiden til Protocol Buffers opregner, hvad der kan følge:\nparsefejl, lækkede persondata og ødelagte data. Omnummerer aldrig et felt, og\nreserver hvert slettet nummer og navn, som i eksemplet ovenfor.\n\n**Enhver fejl ligner en succes for HTTP.** Fordi gRPC svarer med HTTP-status\n200, også når et kald fejler, tæller alt, der bedømmer trafik ud fra\nHTTP-statussen alene, for eksempel en adgangslog eller en fejlrate bygget på\nstatuskoder, fejl som succeser. Specifikationen beder servere svare 415 på\nforespørgsler, hvis indholdstype ikke er `application/grpc`, netop af den grund,\nså andre HTTP/2-klienter ikke læser en gRPC-fejl som en succes. Tæl på\n`grpc-status`, ikke på `:status`.\n\n**Lange streams binder deres belastning til én server.** Kald kører som streams\npå en delt HTTP/2-forbindelse, og når en stream først er startet, kan den ikke\nflyttes til en anden server. En stream, der varer i timevis, holder sin\nbelastning, hvor den begyndte, uanset hvor mange servere der kommer til senere.\nHver forbindelse har også en grænse for samtidige streams, og når den er nået,\nventer yderligere kald hos klienten, til en stream bliver færdig. gRPC's guide\nom ydeevne anbefaler kun at streame, hvor det giver en væsentlig gevinst i\nydeevne eller enkelhed, og at give hvert område med høj belastning sin egen\nkanal.\n\n**Store mængder data passer ikke i én besked.** gRPC håndhæver en maksimal\nbeskedstørrelse, og en besked, der er større end den indstillede grænse, fejler\nmed `RESOURCE_EXHAUSTED` på den side, der sender eller modtager den. At hæve\ngrænsen flytter kun problemet, fordi protocol buffers forventer hele beskeden i\nhukommelsen, og med store data kan der ligge flere serialiserede kopier af den\nder på én gang. Del store data op i en stream af mindre beskeder, eller flyt dem\nuden for gRPC.\n\n## Læs mere\n\n- [Core concepts, architecture and lifecycle](https://grpc.io/docs/what-is-grpc/core-concepts/)\n  — tjenestedefinitioner, de fire slags metoder, stubs, deadlines og\n  annullering.\n- [gRPC over HTTP2](https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md)\n  — protokollen på forbindelsen: stier, headere, beskedpræfikset og statussen i\n  trailerne.\n- [Status Codes](https://grpc.io/docs/guides/status-codes/) — alle 17 koder,\n  hvad hver af dem betyder, og hvilke biblioteket selv aldrig danner.\n- [Deadlines](https://grpc.io/docs/guides/deadlines/) — hvorfor der ikke er\n  nogen standard, hvordan deadlines når frem til serveren, og hvordan de sendes\n  videre mellem tjenester.\n- [Language Guide (proto 3)](https://protobuf.dev/programming-guides/proto3/) —\n  feltnumre, reserverede felter og reglerne for at ændre en beskedtype sikkert.\n\n\u003chttps://engineer.company/da/glossary/grpc/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Sådan bliver en .proto-fil til genererede klienter og servere, der taler sammen over HTTP/2, og hvor deadlines, feltnumre og genforsøg går galt.","formats":{"gemtext":"https://engineer.company/da/glossary/grpc/index.gmi","gopher":"https://engineer.company/da/glossary/grpc/gophermap","html":"https://engineer.company/da/glossary/grpc/","json":"https://engineer.company/da/glossary/grpc/index.json","markdown":"https://engineer.company/da/glossary/grpc/index.md","pdf":"https://engineer.company/da/glossary/grpc/index.pdf"},"kind":"page","language":"da","title":"Hvad er gRPC?","url":"https://engineer.company/da/glossary/grpc/","version":1}