Comment utiliser GRPC dans Go ?

Avec le développement continu des applications modernes, la demande de hautes performances et d'évolutivité est également de plus en plus élevée. Il existe donc une architecture distribuée basée sur le protocole RPC pour répondre à ces besoins. GRPC est un framework open source basé sur le StuB interne de Google. GRPC fournit un mécanisme hautement évolutif de communication entre langages de programmation, conçu pour gérer efficacement la communication standardisée entre les applications.

Cet article expliquera comment utiliser GRPC dans Go. Nous aborderons le concept de GRPC, les étapes pour communiquer à l'aide de GRPC et un exemple de mise en œuvre d'un service GRPC simple dans Go.

Le concept de GRPC

GRPC est un framework RPC basé sur HTTP/2, utilisant protobuf comme méthode de sérialisation des données par défaut. Cela signifie qu'il peut facilement permettre la communication entre différents langages (en tirant parti du code généré et du middleware fourni par grpc).

Extensibilité : GRPC peut implémenter une logique d'authentification et d'autorisation simple et complexe au niveau du flux de code et de la couche de connexion, et peut collaborer avec des plates-formes informatiques modernes telles que Kubernetes.

Communiquer à l'aide de GRPC

Dans cette section, nous présenterons les étapes détaillées pour communiquer à l'aide de GRPC. Dans cet article, nous allons implémenter un service GRPC simple utilisant le langage Go.

Étape 1 : Définir le fichier protobuf

Tout d'abord, nous devons définir notre fichier protobuf pour déclarer notre interface. Dans cet exemple, nous définissons un service simple qui ajoute deux nombres. Ci-dessous le contenu de notre fichier .proto :

syntax = "proto3";

option go_package = ".;main";

package calculator;

message AddRequest {
    int32 x = 1;
    int32 y = 2;
}

message AddResponse {
    int32 result = 1;
}

service Calculator {
    rpc Add(AddRequest) returns (AddResponse);
}

Dans ce fichier protobuf, nous définissons deux messages, AddRequest et AddResponse, et une interface de service Calculatrice, qui fournit une méthode Add qui reçoit deux nombres en paramètres et renvoie leur somme.

Étape 2 : Générer le code GO

Ensuite, nous devons utiliser l'outil protoc pour générer le code GO. Nous pouvons générer du code de la manière suivante :

protoc --go_out=plugins=grpc:. *.proto

Cette commande générera un fichier calculator.pb.go, qui contient le code GO pour les services et les messages que nous avons définis.

Étape 3 : Implémenter le côté serveur

Côté serveur, nous devons implémenter un service pour l'interface que nous avons définie. Dans notre cas, notre service est simplement un simple service d'addition qui additionne deux nombres et renvoie leur somme. Ci-dessous notre code serveur :

package main

import (
    "context"
    "net"
    "google.golang.org/grpc"
    pb "github.com/calculator"
)

type server struct{}

func (s *server) Add(ctx context.Context, req *pb.AddRequest) (*pb.AddResponse, error) {
    result := req.X + req.Y
    return &pb.AddResponse{Result:result}, nil
}

func main() {
    l, err := net.Listen("tcp", ":8080")
    if err != nil {
        panic(err)
    }
    s := grpc.NewServer()

    pb.RegisterCalculatorServer(s, &server{})

    err = s.Serve(l)
    if err != nil {
        panic(err)
    }
}

Nous définissons d'abord une structure appelée "serveur" et y ajoutons une méthode Add. Cette méthode recevra deux nombres x et y, calculera leur somme et renverra un AddResponse comme objet de réponse.

Nous définissons également une fonction principale dans laquelle nous créons un nouveau service grpc et le lions à l'adresse locale du port 8080. Nous injectons également le service que nous avons défini dans le serveur grpc et démarrons le serveur grpc.

Étape 4 : Implémenter le client

Enfin, nous devons écrire un code client qui peut envoyer des requêtes à notre serveur et recevoir des réponses. Veuillez noter que les fichiers .proto du code côté client et côté serveur doivent correspondre. Ci-dessous notre code client :

package main

import (
    "context"
    "fmt"
    "google.golang.org/grpc"
    pb "github.com/calculator"
)

func main() {
    conn, err := grpc.Dial(":8080", grpc.WithInsecure())
    if err != nil {
        panic(err)
    }

    client := pb.NewCalculatorClient(conn)

    req := pb.AddRequest{X:2, Y:3}
    resp, err := client.Add(context.Background(), &req)
    if err != nil {
        panic(err)
    }

    fmt.Printf("Result: %d", resp.Result)
}

Dans ce code client, nous créons d'abord une connexion au serveur GRPC puis utilisons cette connexion pour créer un nouveau client. Ensuite, nous créons un AddRequest, définissons ses valeurs sur 2 et 3 et envoyons la requête au serveur. Enfin, nous recevons et imprimons la réponse du serveur.

Comment exécuter l'exemple de code

Pour exécuter notre exemple de code, nous devons d'abord configurer l'environnement de développement Go et installer les dépendances associées. Supposons que notre package de code s'appelle main. Pour exécuter notre exemple de code localement, vous devez d'abord exécuter la commande suivante :

go get -u google.golang.org/grpc
go get -u github.com/golang/protobuf/protoc-gen-go

Exécutez ensuite la commande protoc pour générer du code go :

protoc --go_out=plugins=grpc:. *.proto

Puis compilez notre code de service et notre code client et démarrez-les séparément :

go build server.go
go build client.go
./server
./client

Si tout est normalement , le client enverra une demande d'ajout au serveur GRPC et affichera le résultat sous la forme 5.

Conclusion

Cet article présente comment utiliser GRPC en langage Go. Nous avons d'abord discuté du concept de GRPC, puis démontré comment utiliser protobuf pour définir les spécifications d'interface, comment générer du code GO et comment implémenter un service GRPC simple. En suivant ces étapes, vous pouvez commencer à utiliser GRPC dans Go pour implémenter des systèmes distribués hautes performances et évolutifs.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!