Golang Grpc

Cos'è GRPC?

GRPC è un framework di chiamate di procedura remota ad alte prestazioni che consente agli sviluppatori di connettere i servizi tra i sistemi. Utilizzando GRPC, le app client e server possono comunicare in modo impeccabile.

In poche parole, GRPC consente a un'applicazione client di accedere e utilizzare i metodi su un'applicazione del server (anche in macchine remote) come se fosse definita nella stessa applicazione. È un importante blocco per i microservizi.

Requisiti

Per seguire questo tutorial, dovrai avere:

1. L'ultima versione del compilatore Go.
2. Compilatore buffer protocollo (protocollo) versione 3
3. GO plugin per lavorare con i buffer di protocolli.

Per installare il compilatore buffer protocollo, eseguire il comando come previsto di seguito:

Vai a installare Google.Golang.org/protobuf/cmd/protoc-gen-go@ultimo
Vai a installare Google.Golang.Org/GRPC/CMD/Protoc-Gen-Go-GRPC@ultimo

Il prossimo passo è aggiornare il tuo percorso in modo da poter utilizzare i comandi di protocollo:

Export Path = "$ Path: $ (Go env gophat)/bin"

Server Golang GRPC

Per questo tutorial, creeremo un semplice server GRPC che riceve il messaggio inviato da un client e lo riecheggia.

Inizia creando una directory di lavoro:

MKDIR GRPC-TUT
CD GRPC-TUT

Quindi, crea un server.GO FILE che trattiene il codice per il server GRPC:

Touch Server.andare

Apri il file con il tuo editor di testo e aggiungi le seguenti righe:

Pacchetto principale
importazione (
"tronco d'albero"
"netto"
)

Nel codice precedente, importiamo i pacchetti di registro e net, che ci consentiranno di registrare errori e stabilire un ascoltatore utilizzando il pacchetto net.

Successivamente, imposteremo la funzione principale e creeremo un ascoltatore sulla porta 9001/TCP:

func main ()
ascoltatore, err: = net.Ascolta ("TCP", ": 9001")
Se err != nil
tronco d'albero.Fatale (err)

Il prossimo passo è importare il pacchetto GRPC per il programma GO. Questo ci consentirà di impostare un server GRPC e gli endpoint che desideriamo servire prima di collegarlo con l'ascoltatore su TCP.

Importa "Google.Golang.org/grpc "

Di nuovo nella funzione principale, possiamo creare un server GRPC come mostrato nel seguente codice:

grpserver: = Grpc.Newserver ()
Se err: = Grpserver.Servire (ascoltatore); err != nil
tronco d'albero.Fatale (err)

Creiamo un server GRPC utilizzando il metodo Newserver () nel codice precedente. Serviamo quindi il server tramite l'ascoltatore TCP che abbiamo creato in precedenza.

E con ciò, abbiamo un server GRPC. Tuttavia, non fa molto. Possiamo estenderlo creando una semplice applicazione Echo.

L'applicazione riceverà il messaggio dal client e restituirà lo stesso messaggio al client.

Echo Proto File

Per impostare la nostra applicazione Echo, dovremo creare un .File proto. Il file proto terrà le definizioni per l'applicazione.

toccare l'eco.Proto

La prima voce nel file proto sarà la dichiarazione del pacchetto. Ciò impedisce le collisioni del nome in altre applicazioni.

sintax = "proto3";
pacchetto eco;
opzione go_package = "./eco";

Puoi cambiare il nome per riflettere il nome del pacchetto.

Una volta che abbiamo la dichiarazione del pacchetto, dobbiamo aggiungere definizioni di messaggi. Questo definisce un contenitore o una struttura del messaggio da ricevere dai clienti:

messaggio messaggio
corda di stringa = 1;

Successivamente, dobbiamo definire il servizio. Nel nostro esempio, chiamiamo il servizio come echoservice come mostrato:

servizio echoservice
rpc echo (messaggio) returns (messaggio)

Il servizio definisce un metodo che un client GRPC chiamerà. Il metodo prende semplicemente il messaggio e restituisce il messaggio. Questo crea un'applicazione Echo.

Compilare i tamponi del protocollo

Ora abbiamo il proto che definisce la nostra applicazione. Successivamente, dobbiamo generare le classi che useremo per leggere e scrivere i dati utilizzando il linguaggio di programmazione Go.

Possiamo farlo usando il compilatore buffer protocollo:

protocollo --go_out =./echo --go-brpc_out =./echo --Go-GRPC_OPT = requisite_unimplement_servers = false echo.Proto

I comandi precedenti dovrebbero generare il codice GO richiesto per registrarsi e chiamare il server GRPC.

Il prossimo passo è definire l'RPC per il metodo Echo. Possiamo farlo creando un file GO nella directory Echo come:

toccare l'eco.andare

Nel file, aggiungi il codice come mostrato:

pacchetto eco
importazione (
"FMT"
"Golang.org/x/net/contesto "// Ottieni contesto di richiesta
)
tipo server struct

Func (S *Server) Echo (contesto CTX.Contesto, messaggio *messaggio) ( *messaggio, errore)
fmt.Printf ("Messaggio recuperato: %s", messaggio.Corpo)
return & message body: "ciao!", zero

Il prossimo passo è importare il codice all'interno del pacchetto Echo. Torna al server.GO FILE e Aggiungi la seguente clausola di importazione:

Importa "GRPC/ECHO"

Dovrai inizializzare il manager del modulo GO per il tuo progetto.

Nel file del server principale, aggiungi le seguenti righe per creare un nuovo server di chat e registrarlo:

s: = eco.Server
eco.Registerchoserviceserver (Grpserver, & s)

E con ciò, abbiamo il codice per il server GRPC.

Cliente GRPC

Il prossimo passo è costruire un client in grado di interagire con il server GRPC. Inizia creando un client file.Vai nella directory principale.

tocco ./cliente.andare

Cominciamo con le nostre importazioni. Per questo, avremo bisogno dei pacchetti di registro, contesto, eco e GRPC

importazione (
"tronco d'albero"
"Golang.org/x/net/contesto "
"Google.Golang.org/grpc "
"GRPC/ECHO"
)

Successivamente, iniziamo con la funzione principale:

func main ()
// puntatore a GRPC Conn
var conn *Grpc.ClientConn
// Connettiti al server GRPC (connessione non sicura)
Conn, err: = Grpc.Dial (": 9001", GRPC.Withinsecure ())
Se err != nil
tronco d'albero.Fatale (err)

// Chiudi Conn
Defer Conn.Vicino()
// Echo Service Client
E: = eco.NewechoserviceClient (Conn)
// corpo del messaggio
Messaggio: = eco.Messaggio
Corpo: "ciao",

resp, err: = e.Eco (contesto.Background () e messaggio)
Se err != nil
tronco d'albero.Fatale (err)

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

Il codice precedente implementa un client GRPC, che invia il messaggio "ciao" e ottiene "ciao” dal server.

Test

Una volta completato, eseguire il server.Vai e cliente.andare. In caso di successo, il server dovrebbe rispondere con "ciao back" come mostrato di seguito:

Hai creato correttamente un server GRPC e un client in GO.

Conclusione

Questa guida funge da base assoluta per l'implementazione di GRPC in GO. Se sei nuovo a GRPC e Protobufs, potrebbe volerci del tempo per cogliere l'implementazione. Tuttavia, con alcune pratiche e implementazione, sarai in grado di costruire servizi GRPC complessi. Speriamo che tu abbia trovato questo articolo utile. Dai un'occhiata ad altri articoli Linux per ulteriori suggerimenti e tutorial.