{"canonical_url":"https://engineer.company/nb/glossary/grpc/","content_markdown":"# gRPC\n\n## Hva det er\n\ngRPC er et rammeverk for fjernprosedyrekall. Et program kaller en metode på en\nserver som kjører på en annen maskin, som om serveren var et lokalt objekt, og\ngRPC frakter kallet over nettverket i en egen protokoll oppå HTTP/2 og leverer\nsvaret tilbake som en returverdi.\n\nAlt begynner med en tjenestedefinisjon: metodene som kan kalles utenfra, med\ntypen til hver forespørsel og hvert svar. Som standard skrives den i Protocol\nBuffers, Googles format med åpen kildekode for å serialisere data uavhengig av\nspråk og plattform, i en fil med et navn som slutter på `.proto`. Andre formater\nkan kobles inn, men protocol buffers er det gRPC bruker med mindre noe annet er\nangitt. Kompilatoren `protoc` leser filen sammen med en gRPC-plugin og genererer\nkode for begge halvdelene. Klienten får en stub, et lokalt objekt med de samme\nmetodene som tjenesten (i noen språk heter den rett og slett klienten), og\nserveren får et grensesnitt den skal implementere. Fordi begge halvdelene kommer\nfra samme fil, kan en server skrevet i Java svare klienter skrevet i Go, Python\neller Ruby.\n\nEn metode har én av fire former. En unær metode tar én forespørsel og returnerer\nett svar, som et vanlig funksjonskall. En metode med serverstrømming tar én\nforespørsel og sender tilbake en strøm av svar, en metode med klientstrømming\ngjør det motsatte, og en metode med toveis strømming lar begge sider sende\nstrømmene sine uavhengig av hverandre. Innenfor ett kall garanterer gRPC at\nmeldingene kommer frem i den rekkefølgen de ble sendt.\n\nUnder panseret kjører gRPC over HTTP/2. Hvert kall er en `POST` til en sti som\nbestår av det fullt kvalifiserte navnet på tjenesten og navnet på metoden, med\ninnholdstypen `application/grpc`. Hver melding sendes bak et prefiks på fem\nbyte: én byte som sier om meldingen er komprimert, og fire som angir lengden.\nUtfallet av kallet er ikke HTTP-statusen. Et svar som gRPC selv lager, har\nstatus 200 også når kallet feiler, og det egentlige resultatet kommer i\ntrailere, headerfelt som sendes etter kroppen: `grpc-status` med et tall og\neventuelt `grpc-message` med en beskrivelse av feilen.\n\nDet gjør gRPC til noe helt annet enn REST. Et REST-API navngir ressurser og\narbeider på dem med metodene og statuskodene i selve HTTP, som regel med kropper\ni JSON som alle kan lese. Et gRPC-API er en liste med metoder med typede, binære\nmeldinger, og HTTP/2 er bare transporten under. Dokumentasjonen til Protocol\nBuffers kaller selv formatet sitt «som JSON, bare mindre og raskere».\n\n## Hvorfor det er viktig\n\nKontrakten kommer først, og koden følger av den. I mange HTTP-API-er er\nbeskrivelsen og koden som leverer API-et, to separate ting som kan gli fra\nhverandre, og en klient blir ofte skrevet for hånd ut fra et dokument. I gRPC er\n`.proto`-filen det ene stedet der en metode eller et felt defineres, og alle\nklienter og servere genereres fra den. En endring i en melding når ut til alle\nspråk gjennom den samme generatoren og ikke ved at noen leser et dokument på\nnytt.\n\nKodingen er kompakt, fordi hvert felt sendes som nummeret og verdien sin i\nstedet for navnet sitt. Prisen er at en melding ikke kan tolkes fullt ut uten\n`.proto`-filen sin, siden protocol buffers ikke beskriver seg selv, og at\nformatet går ut fra at en hel melding får plass i minnet på én gang. Formatets\negen dokumentasjon anbefaler en annen løsning for data på mer enn noen få\nmegabyte.\n\nStrømming er en del av designet og ikke et tillegg. Kall kjører som strømmer på\nHTTP/2-forbindelser, så en metode med serverstrømming kan fortsette å sende\nresultater gjennom det samme maskineriet som et kall som svarer én gang.\n\nTidsgrensene følger med kallet. En klient setter en tidsfrist, en deadline som\ngRPC kaller det, gRPC sender det som er igjen av den, i headeren `grpc-timeout`,\nog når tiden er ute, får klienten `DEADLINE_EXCEEDED`, og serverens side av\nkallet blir avbrutt. Når en server i sin tur kaller en annen server, sender noen\nimplementasjoner tidsfristen videre: Java og Go gjør det som standard, mens det\nmå slås på i C++. Fordi tidsfristen krysser hvert ledd som gjenværende tid og\nikke som et klokkeslett, gir maskiner med klokker som går ulikt, likevel opp på\nsamme tidspunkt.\n\nFeil har ett felles vokabular. gRPC definerer 17 statuskoder, fra 0 `OK` til 16\n`UNAUTHENTICATED`, og de er en del av selve protokollen, så en Go-klient og en\nJava-server er enige om hva `NOT_FOUND` eller `UNAVAILABLE` betyr.\n\nAlt dette passer for trafikk mellom tjenester som ett team eller ett selskap\nkontrollerer, der begge ender kan dele `.proto`-filene og bygge fra dem. Det\npasser dårligere for nettleseren. gRPC-prosjektets egne protokollnotater sier at\nnettlesere ikke gir skript tilgang til rammene i HTTP/2 og aldri kommer til å\ngjøre det, så kode i nettleseren snakker en egen protokoll, gRPC-Web, og i det\nvanlige oppsettet oversetter en proxy den til vanlig gRPC.\n\n## Slik ser det ut i praksis\n\nHer er en liten faktureringstjeneste. En unær metode henter en faktura, og en\nmetode med serverstrømming sender en kundes fakturaer én om 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 standardverdier. Det er feltnumre, og i den binære kodingen\nidentifiserer de hvert felt i stedet for navnet. Numrene fra 1 til 15 tar én\nbyte, så de hører til feltene som oftest er satt. De to `reserved`-linjene\nholder orden på et felt som fantes en gang, nummer 4 med navnet `discount_code`,\nslik at verken nummeret eller navnet kan komme tilbake som et annet felt.\n\nFor Python genererer én kommando `billing_pb2.py` med meldingsklassene og\n`billing_pb2_grpc.py` med klient- og serverklassene:\n\n```sh\npython -m grpc_tools.protoc -Iprotos \\\n  --python_out=. --grpc_python_out=. protos/billing.proto\n```\n\nEtt enkelt kall til `GetInvoice` ser da slik ut som HTTP/2-rammer:\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` betyr to sekunder, og `te = trailers` er der for å oppdage proxyer som ikke\ner kompatible med gRPC. Hvis fakturaen ikke finnes, begynner svaret likevel med\n`:status = 200`, og den siste rammen bærer `grpc-status = 5`, som er\n`NOT_FOUND`, sammen med en `grpc-message` som `invoice not found`. En server som\nfeiler med en gang, kan til og med sende én enkelt `HEADERS`-ramme med statusen\nog ingen melding i det hele tatt.\n\nÅ generere begge sider fra én kontrakt er ikke noe særegent for gRPC. Et\nprosjekt i nettstedets portefølje\n[genererte API-kontrakten fra databasen og utover](/nb/portfolio/generated-the-api-contract-from-the-database-out/)\nfor et API beskrevet med OpenAPI. Kjeden starter i databasen og går utover:\nGo-typene definerer API-et, Huma lager OpenAPI-beskrivelsen ut fra dem, en typet\nTypeScript-klient og mock-handlere genereres fra den beskrivelsen, og en\nkontraktskontroll i CI får bygget til å feile når det frontenden sender, ikke\nlenger stemmer med det API-et forventer. gRPC bygger den samme disiplinen inn i\nverktøykjeden sin, med `.proto`-filen som eneste kilde.\n\n## Hvor det går galt\n\n**Et kall uten tidsfrist kan vente for alltid.** gRPC setter ingen tidsfrist som\nstandard, så en klient som kaller en server som har hengt seg, kan i praksis\nvente på svar for alltid. Gi hvert kall en realistisk tidsfrist. I Python er det\nargumentet `timeout`, oppgitt 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 er ute, kaster kallet `grpc.RpcError`, og unntakets `code()`\nreturnerer `grpc.StatusCode.DEADLINE_EXCEEDED`. På serveren avbryter gRPC kallet\nmed `CANCELLED` når tidsfristen er passert, men det er tjenestens egen kode som\nmå stoppe arbeidet handleren har satt i gang, så en handler som jobber lenge,\nselv må sjekke om kallet er avbrutt, og stoppe.\n\n**En timeout betyr ikke at ingenting har skjedd.** Klient og server avgjør hver\nfor seg om et kall lyktes, så et kall kan fullføres på serveren og likevel feile\nhos klienten med `DEADLINE_EXCEEDED`. Endringer som ble gjort før en avbrytelse,\nblir heller ikke rullet tilbake. En klient som bare prøver igjen, kan opprette\nden samme fakturaen to ganger. Protokollen antar ikke at et kall er idempotent,\nmed mindre det uttrykkelig er merket slik. `UNAVAILABLE` er koden som oftest er\nforbigående og verdt å prøve igjen med backoff, men dokumentasjonen av\nstatuskodene advarer om at det ikke alltid er trygt å gjenta operasjoner som\nikke er idempotente. Det samme dokumentet overlater til koden som gjør kallene,\nå velge hvilke koder som skal prøves på nytt.\n\n**Et gjenbrukt feltnummer ødelegger data.** Et feltnummer kan ikke endres når\nmeldingstypen først er i bruk. Hvis et felt slettes og nummeret senere går til\net nytt felt, dekoder eldre klienter og lagrede meldinger det nye feltet ut fra\nbytes som betydde noe annet. Veiledningen til Protocol Buffers lister opp hva\nsom kan følge: parsefeil, lekkede personopplysninger og ødelagte data. Nummerer\naldri om et felt, og reserver hvert slettede nummer og navn, som i eksemplet\nover.\n\n**Hver feil ser ut som en suksess for HTTP.** Fordi gRPC svarer med HTTP-status\n200 også når et kall feiler, teller alt som bedømmer trafikk ut fra\nHTTP-statusen alene, for eksempel en tilgangslogg eller en feilrate bygd på\nstatuskoder, feil som suksesser. Spesifikasjonen ber servere svare 415 på\nforespørsler med en annen innholdstype enn `application/grpc`, nettopp av den\ngrunn, slik at andre HTTP/2-klienter ikke leser en gRPC-feil som en suksess.\nTell på `grpc-status`, ikke på `:status`.\n\n**Lange strømmer binder belastningen sin til én server.** Kall kjører som\nstrømmer på en delt HTTP/2-forbindelse, og når en strøm først har startet, kan\nden ikke flyttes til en annen server. En strøm som varer i timevis, holder\nbelastningen der den begynte, uansett hvor mange servere som kommer til senere.\nHver forbindelse har også en grense for samtidige strømmer, og når den er nådd,\nventer flere kall hos klienten til en strøm er ferdig. Ytelsesguiden til gRPC\nanbefaler å strømme bare der det gir en betydelig gevinst i ytelse eller\nenkelhet, og å gi hvert område med høy belastning sin egen kanal.\n\n**Store datamengder får ikke plass i én melding.** gRPC håndhever en maksimal\nmeldingsstørrelse, og en melding som er større enn den innstilte grensen, feiler\nmed `RESOURCE_EXHAUSTED` på den siden som sender eller mottar den. Å heve\ngrensen flytter bare problemet, fordi protocol buffers forventer hele meldingen\ni minnet, og med store data kan flere serialiserte kopier av den ligge der\nsamtidig. Del store data opp i en strøm av mindre meldinger, eller flytt dem ut\nav gRPC.\n\n## Les mer\n\n- [Core concepts, architecture and lifecycle](https://grpc.io/docs/what-is-grpc/core-concepts/)\n  — tjenestedefinisjoner, de fire typene metoder, stubber, tidsfrister og\n  avbrytelse.\n- [gRPC over HTTP2](https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md)\n  — protokollen på nettverksnivå: stier, headere, meldingsprefikset og statusen\n  i trailerne.\n- [Status Codes](https://grpc.io/docs/guides/status-codes/) — alle de 17 kodene,\n  hva hver av dem betyr, og hvilke biblioteket selv aldri lager.\n- [Deadlines](https://grpc.io/docs/guides/deadlines/) — hvorfor det ikke finnes\n  noen standard, hvordan tidsfrister når frem til serveren, og hvordan de sendes\n  videre mellom tjenester.\n- [Language Guide (proto 3)](https://protobuf.dev/programming-guides/proto3/) —\n  feltnumre, reserverte felt og reglene for å endre en meldingstype trygt.\n\n\u003chttps://engineer.company/nb/glossary/grpc/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Slik blir en .proto-fil til genererte klienter og servere som snakker sammen over HTTP/2, og hvor tidsfrister, feltnumre og nye forsøk går galt.","formats":{"gemtext":"https://engineer.company/nb/glossary/grpc/index.gmi","gopher":"https://engineer.company/nb/glossary/grpc/gophermap","html":"https://engineer.company/nb/glossary/grpc/","json":"https://engineer.company/nb/glossary/grpc/index.json","markdown":"https://engineer.company/nb/glossary/grpc/index.md","pdf":"https://engineer.company/nb/glossary/grpc/index.pdf"},"kind":"page","language":"nb","title":"Hva er gRPC?","url":"https://engineer.company/nb/glossary/grpc/","version":1}