Golang GRPC

Hva er GRPC?

GRPC er et rammeverk med høy ytelse ekstern prosedyre som lar utviklere koble til tjenester på tvers av systemer. Ved hjelp av GRPC kan klient- og serverappene kommunisere feilfritt.

Enkelt sagt tillater GRPC en klientapplikasjon å få tilgang til og bruke metoder på en serverapplikasjon (selv i eksterne maskiner) som om den er definert i samme applikasjon. Det er en stor byggestein for mikroservices.

Krav

For å følge med denne opplæringen, må du ha:

1. Den siste versjonen av Go -kompilatoren.
2. Protocol Buffer Compiler (Protoc) versjon 3
3. Gå plugins for å jobbe med protokollbuffere.

For å installere protokollbufferkompilatoren, kjør kommandoen som angitt nedenfor:

Gå og installer Google.Golang.org/protobuf/cmd/protoc-gen-go@siste
Gå og installer Google.Golang.org/grpc/cmd/protoc-gen-go-grpc@siste

Neste trinn er å oppdatere banen din slik at du kan bruke protokkommandoene:

Export Path = "$ Path: $ (Go Env Gopath)/Bin"

Golang GRPC -server

For denne opplæringen vil vi bygge en enkel GRPC -server som tar meldingen sendt av en klient og gjenspeiler den tilbake.

Begynn med å lage en fungerende katalog:

mkdir grpc-tut
CD GRPC-TUT

Neste, opprette en server.GO -fil som holder koden for GRPC -serveren:

Touch Server.gå

Åpne filen med tekstredigereren din og legg til følgende linjer:

pakkehoved
import (
"Logg"
"nett"
)

I forrige kode importerer vi log- og nettpakkene, som lar oss logge feil og etablere en lytter ved hjelp av nettpakken.

Deretter setter vi opp hovedfunksjonen og oppretter en lytter på port 9001/TCP:

func main ()
lytter, feil: = netto.Hør ("TCP", ": 9001")
Hvis feil != nil
Logg.Fatal (feil)

Neste trinn er å importere GRPC -pakken for GO -programmet. Dette vil tillate oss å sette opp en GRPC -server og endepunktene vi ønsker å tjene før vi kobler den til lytteren på TCP.

Importer "Google.Golang.org/grpc "

Tilbake i hovedfunksjonen kan vi opprette en GRPC -server som vist i følgende kode:

grpserver: = grpc.Newserver ()
Hvis feil: = grpserver.Server (lytter); feil != nil
Logg.Fatal (feil)

Vi oppretter en GRPC -server ved hjelp av Newserver () -metoden i forrige kode. Vi serverer serveren over TCP -lytteren vi opprettet tidligere.

Og med det har vi en GRPC -server. Imidlertid gjør det ikke mye. Vi kan utvide dette ved å lage en enkel Echo -applikasjon.

Søknaden vil motta meldingen fra klienten og returnere den samme meldingen til klienten.

Echo Proto -fil

For å sette opp Echo -applikasjonen vår, må vi opprette en .Proto -fil. Proto -filen vil inneholde definisjonene for applikasjonen.

Touch Echo.Proto

Den første oppføringen i Proto -filen vil være pakkeutdannelsen. Dette forhindrer navnekollisjoner i andre applikasjoner.

Syntaks = "Proto3";
pakke ekko;
alternativ go_package = "./ekko";

Du kan endre navnet for å gjenspeile navnet på pakken din.

Når vi har pakkedeklarasjonen, må vi legge til meldingsdefinisjoner. Dette definerer en beholder eller struktur for meldingen du vil motta fra klientene:

meldingsmelding
streng kropp = 1;

Deretter må vi definere tjenesten. I vårt eksempel kaller vi tjenesten som EchoService som vist:

Service EchoService
RPC Echo (melding) Returnerer (melding)

Tjenesten definerer en metode som en GRPC -klient vil ringe. Metoden tar ganske enkelt meldingen og returnerer meldingen. Dette skaper en ekko -applikasjon.

Å sammenstille protokollbufferne

Nå har vi proto som definerer for søknaden vår. Deretter må vi generere klassene vi vil bruke for å lese og skrive data ved hjelp av Go -programmeringsspråket.

Vi kan gjøre dette ved hjelp av protokollbufferkompilatoren:

protoc --go_out =./ekko-go-grpc_out =./ekko-go-grpc_opt = krevende_unimplemented_servers = falsk ekko.Proto

De tidligere kommandoene skal generere GO -koden som kreves for å registrere og ringe GRPC -serveren.

Neste trinn er å definere RPC for ekko -metoden. Vi kan gjøre dette ved å lage en GO -fil i Echo -katalogen som:

Touch Echo.gå

I filen, legg til koden som vist:

Pakke ekko
import (
"FMT"
"Golang.org/x/nett/kontekst "// få forespørselskontekst
)
type serverstruktur

func (s *server) ekko (CTX -kontekst.Kontekst, melding *melding) ( *melding, feil)
fmt.Printf ("Melding mottatt: %s", melding.Kropp)
Return & Message Body: "Hei tilbake!", null

Neste trinn er å importere koden i Echo -pakken. Gå tilbake til serveren.Gå fil og legg til følgende importklausul:

Importer "GRPC/Echo"

Du må initialisere Go Module Manager for prosjektet ditt.

I hovedserverfilen, legg til følgende linjer for å opprette en ny chat -server og registrere den:

s: = ekko.Server
ekko.REGISTERCHOSERVICESERVER (GrpServer, & S)

Og med det har vi koden for GRPC -serveren ute av veien.

GRPC -klient

Neste trinn er å bygge en klient som kan samhandle med GRPC -serveren. Begynn med å opprette en filklient.Gå i hovedkatalogen.

ta på ./klient.gå

La oss starte med importen vår. For denne trenger vi loggen, konteksten, ekkoet og GRPC -pakkene

import (
"Logg"
"Golang.org/x/nett/kontekst "
"Google.Golang.org/grpc "
"GRPC/Echo"
)

La oss deretter starte med hovedfunksjonen:

func main ()
// peker til grpc conn
var conn *grpc.ClientConn
// Koble til GRPC Server (usikker tilkobling)
Conn, feil: = grpc.Dial (": 9001", GRPC.WitSeSecure ())
Hvis feil != nil
Logg.Fatal (feil)

// Lukk Conn
utsett Conn.Lukk()
// Echo Service Client
e: = ekko.NeweChoServiceClient (Conn)
// Meldingsorgan
Melding: = ekko.Beskjed
Kropp: "Hei",

resp, feil: = e.Ekko (kontekst.Bakgrunn (), og melding)
Hvis feil != nil
Logg.Fatal (feil)

fmt.Printf ("%s", resp.Kropp)

Den forrige koden implementerer en GRPC -klient, som sender meldingen “hei” og får “hei tilbake” fra serveren.

Testing

Når du er fullført, kjør serveren.gå og klient.gå. Hvis den lykkes, bør serveren svare med "hei tilbake" som vist nedenfor:

Du har bygget en GRPC -server og klient i Go.

Konklusjon

Denne guiden fungerer som et absolutt grunnleggende for å implementere GRPC i Go. Hvis du er ny på GRPC og Protobufs, kan det ta tid å forstå implementeringen. Imidlertid, med noen få praksis og implementering, vil du være i stand til å bygge komplekse GRPC -tjenester. Vi håper du fant denne artikkelen nyttig. Sjekk ut andre Linux -artikler for flere tips og opplæringsprogrammer.