Golang GRPC

Qu'est-ce que GRPC?

GRPC est un cadre d'appel de procédure à distance haute performance qui permet aux développeurs de connecter les services entre les systèmes. À l'aide de GRPC, les applications client et serveur peuvent communiquer parfaitement.

En termes simples, GRPC permet à une application client d'accès et d'utiliser des méthodes sur une application de serveur (même dans les machines distantes) comme si elle était définie dans la même application. C'est un major de construction pour les microservices.

Exigences

Pour suivre ce tutoriel, vous devrez avoir:

1. La dernière version du compilateur Go.
2. Protocol Buffer Compiler (Protoc) Version 3
3. Go Plugins pour travailler avec des tampons de protocole.

Pour installer le compilateur de tampon de protocole, exécutez la commande comme prévu ci-dessous:

aller installer google.golang.org / protobuf / cmd / protoc-gen-go @ dernier
aller installer google.golang.org / grpc / cmd / protoc-gen-go-grpc @ dernier

L'étape suivante consiste à mettre à jour votre chemin afin que vous puissiez utiliser les commandes ProtoC:

Export Path = "$ path: $ (go env gopath) / bin"

Serveur Golang GRPC

Pour ce didacticiel, nous créerons un serveur GRPC simple qui prend le message envoyé par un client et le fait écho.

Commencez par créer un répertoire de travail:

MKDIR GRPC-TUT
CD GRPC-TUT

Ensuite, créez un serveur.go fichier qui conservera le code pour le serveur GRPC:

Serveur tactile.aller

Ouvrez le fichier avec votre éditeur de texte et ajoutez les lignes suivantes:

package principal
importer (
"enregistrer"
"filet"
)

Dans le code précédent, nous importons les packages de journaux et nets, qui nous permettra de journaliser les erreurs et d'établir un auditeur à l'aide du package net.

Ensuite, nous allons configurer la fonction principale et créer un écouteur sur le port 9001 / TCP:

func main ()
Écouteur, euh: = net.Écouter ("TCP", ": 9001")
Si err != nil
enregistrer.Fatal (euh)

L'étape suivante consiste à importer le package GRPC pour le programme GO. Cela nous permettra de configurer un serveur GRPC et les points de terminaison que nous souhaitons servir avant de le connecter avec l'auditeur sur TCP.

Importer "Google.golang.org / grpc "

De retour dans la fonction principale, nous pouvons créer un serveur GRPC comme indiqué dans le code suivant:

GrpServer: = Grpc.Journaliste ()
Si err: = GrpServer.Servir (auditeur); se tromper != nil
enregistrer.Fatal (euh)

Nous créons un serveur GRPC à l'aide de la méthode du journaliste () dans le code précédent. Nous servons ensuite le serveur sur l'écouteur TCP que nous avons créé plus tôt.

Et avec cela, nous avons un serveur GRPC. Cependant, ça ne fait pas grand-chose. Nous pouvons prolonger cela en créant une application d'écho simple.

L'application recevra le message du client et renverra le même message au client.

Echo Proto Fichier

Pour configurer notre application Echo, nous devrons créer un .fichier proto. Le fichier proto conservera les définitions de l'application.

toucher l'écho.proto

La première entrée du fichier Proto sera la déclaration de package. Cela empêche les collisions de noms dans d'autres applications.

syntax = "proto3";
Echo de package;
option go_package = "./écho";

Vous pouvez modifier le nom pour refléter le nom de votre package.

Une fois que nous avons la déclaration de package, nous devons ajouter des définitions de messages. Cela définit un conteneur ou une structure du message à recevoir des clients:

Message Message
corde de chaîne = 1;

Ensuite, nous devons définir le service. Dans notre exemple, nous appelons le service comme un echoservice comme indiqué:

Service Echoservice
rpc echo (message) renvoie (message)

Le service définit une méthode qu'un client GRPC appellera. La méthode prend simplement le message et renvoie le message. Cela crée une application d'écho.

Compilation des tampons de protocole

Maintenant, nous avons le proto définissant notre application. Ensuite, nous devons générer les classes que nous utiliserons pour lire et écrire des données à l'aide du langage de programmation Go.

Nous pouvons le faire en utilisant le compilateur de tampon de protocole:

protoc --go_out =./ echo --go-grpc_out =./ echo --go-grpc_opt = require_unImpleted_servers = false echo.proto

Les commandes précédentes doivent générer le code GO requis pour s'inscrire et appeler le serveur GRPC.

L'étape suivante consiste à définir le RPC pour la méthode d'écho. Nous pouvons le faire en créant un fichier go dans le répertoire Echo comme:

toucher l'écho.aller

Dans le fichier, ajoutez le code comme indiqué:

Echo de package
importer (
"FMT"
"Golang.org / x / net / context "// get demande contexte
)
type server struct

func (S * serveur) Echo (contexte CTX.Contexte, message * Message) (* Message, erreur)
fmt.Printf ("message reçue:% s", message.Corps)
retour et message corps: "salut en retour!", nil

L'étape suivante consiste à importer le code dans le package Echo. Retournez au serveur.Allez le fichier et ajoutez la clause d'importation suivante:

importer "grpc / echo"

Vous devrez initialiser le gestionnaire de modules GO pour votre projet.

Dans le fichier du serveur principal, ajoutez les lignes suivantes pour créer un nouveau serveur de chat et enregistrez-le:

S: = Echo.Serveur
écho.RegisterEchoservicesServer (GrpServer, & s)

Et avec cela, nous avons le code du serveur GRPC à l'écart.

Client GRPC

L'étape suivante consiste à créer un client qui peut interagir avec le serveur GRPC. Commencez par créer un client de fichier.aller dans le répertoire principal.

touche ./client.aller

Commençons par nos importations. Pour celui-ci, nous aurons besoin des packages de journal, de contexte, d'écho et de GRPC

importer (
"enregistrer"
"Golang.org / x / net / contexte "
"Google.golang.org / grpc "
"grpc / echo"
)

Ensuite, commençons par la fonction principale:

func main ()
// pointeur vers GRPC Conn
var conn * grpc.ClientConn
// Connectez-vous au serveur GRPC (connexion insécurité)
Conn, err: = grpc.Dial (": 9001", GRPC.WithinSecure ())
Si err != nil
enregistrer.Fatal (euh)

// ferme Conn
Déférer Conn.Fermer()
// Echo Service Client
e: = echo.NewEchoserviceClient (Conn)
// Corps du message
Message: = Echo.Message
Corps: "salut",

resp, err: = e.Écho (contexte.Fond (), & message)
Si err != nil
enregistrer.Fatal (euh)

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

Le code précédent implémente un client GRPC, qui envoie le message «Salut» et obtient «HI Retour» du serveur.

Essai

Une fois terminé, exécutez le serveur.Allez et client.aller. En cas de succès, le serveur doit répondre avec «HI Back» comme indiqué ci-dessous:

Vous avez réussi à construire un serveur et un client GRPC dans Go.

Conclusion

Ce guide sert de base absolue pour implémenter GRPC dans Go. Si vous êtes nouveau dans GRPC et Protobufs, il peut prendre du temps pour saisir l'implémentation. Cependant, avec quelques pratiques et mise en œuvre, vous serez en mesure de créer des services GRPC complexes. Nous espérons que vous avez trouvé cet article utile. Découvrez d'autres articles Linux pour plus de conseils et de tutoriels.