installation de grpc golang

gRPC (Google Remote Procedure Call) est un cadre d'appel de procédure à distance multilingue hautes performances qui définit les interfaces de service via des tampons de protocole (ProtoBuf) et prend en charge de nombreux langages de programmation. gRPC est largement utilisé dans le développement de systèmes distribués. Son mécanisme efficace de sérialisation et de désérialisation, son contrôle de flux basé sur HTTP/2, sa transmission fragmentée et d'autres fonctionnalités lui confèrent des avantages évidents dans la transmission réseau.

Cet article explique principalement comment installer gRPC dans Golang et écrire un exemple de code client et serveur simple.

1. Installez gRPC

Avant d'installer gRPC, vous devez installer Protocol Buffers 3. Protocol Buffers est un outil requis pour que gRPC génère automatiquement du code, et c'est également un outil pour sérialiser les données.

Tout d'abord, téléchargez le package d'installation de Protocol Buffers 3, en prenant Mac OS comme exemple :

$ curl -OL https://github.com/google/protobuf/releases/download/v3.9.1/protobuf-all-3.9.1.zip
$ unzip protobuf-all-3.9.1.zip
$ cd protobuf-3.9.1

Exécutez configure, make, make install pour installer Protocol Buffers :

$ ./configure
$ make
$ sudo make install

Après avoir installé Protocol Buffers, utilisez la commande suivante pour installer Go's gRPC et outils associés :

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

2. Écrire des fichiers ProtoBuf

Les fichiers ProtoBuf sont utilisés pour définir les interfaces de service et les structures de données, et générer automatiquement le code correspondant (y compris le code client et serveur) via l'outil gRPC.

Nous écrivons ici un exemple simple pour définir une interface de service de calculatrice qui prend en charge les opérations d'addition :

syntax = "proto3";

package calculator;

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

message AddRequest {
  int32 left = 1;
  int32 right = 2;
}

message AddResponse {
  int32 sum = 1;
}

Dans cet exemple, définissez une interface de service nommée Calculatrice, comprenant une méthode Add qui reçoit un paramètre AddRequest et renvoie un paramètre AddResponse.

AddRequest et AddResponse sont toutes deux des structures de message, chacune contenant deux champs de type int32, représentant les deux opérandes et le résultat de l'addition.

3. Générer du code

Après avoir écrit le fichier ProtoBuf, utilisez la commande suivante pour générer le code client et serveur :

$ protoc --go_out=plugins=grpc:. calculator.proto

Cette commande génère un fichier Go nommé calculator.pb.go, qui définit le code client et serveur du service de calculatrice. .

4. Écrivez le code client et serveur

Après avoir généré le code client et serveur, vous pouvez commencer à écrire le client et le serveur réels.

Le premier est le code du serveur. Nous créons un fichier nommé server.go et implémentons l'interface de la Calculatrice :

package main

import (
    "context"
    "log"
    "net"

    pb "calculator/calculator"

    "google.golang.org/grpc"
)

type server struct{}

func (s *server) Add(ctx context.Context, in *pb.AddRequest) (*pb.AddResponse, error) {
    sum := in.Left + in.Right
    return &pb.AddResponse{Sum: sum}, nil
}

const (
    port = ":50051"
)

func main() {
    lis, err := net.Listen("tcp", port)
    if err != nil {
        log.Fatalf("failed to listen: %v", err)
    }
    s := grpc.NewServer()
    pb.RegisterCalculatorServer(s, &server{})
    if err := s.Serve(lis); err != nil {
        log.Fatalf("failed to serve: %v", err)
    }
}

Dans cet exemple, nous définissons une structure nommée server et implémentons la méthode Add dans l'interface de la Calculatrice. La méthode Add reçoit un paramètre AddRequest, calcule la somme des deux opérandes et renvoie un paramètre AddResponse.

Enfin, enregistrez le service sur le serveur gRPC via la méthode RegisterCalculatorServer fournie par le framework gRPC et démarrez le serveur gRPC.

Ensuite pour écrire le code client, nous créons un fichier nommé client.go pour implémenter un exemple simple d'opérations d'addition via le service de calculatrice :

package main

import (
    "context"
    "log"
    "os"
    "strconv"

    pb "calculator/calculator"

    "google.golang.org/grpc"
)

const (
    address     = "localhost:50051"
    defaultName = "world"
)

func main() {
    // Set up a connection to the server.
    conn, err := grpc.Dial(address, grpc.WithInsecure())
    if err != nil {
        log.Fatalf("did not connect: %v", err)
    }
    defer conn.Close()
    c := pb.NewCalculatorClient(conn)

    // Contact the server and print out its response.
    left, err := strconv.Atoi(os.Args[1])
    if err != nil {
        log.Fatalf("could not parse left operand: %v", err)
    }
    right, err := strconv.Atoi(os.Args[2])
    if err != nil {
        log.Fatalf("could not parse right operand: %v", err)
    }
    r, err := c.Add(context.Background(), &pb.AddRequest{Left: int32(left), Right: int32(right)})
    if err != nil {
        log.Fatalf("could not add: %v", err)
    }
    log.Printf("Sum: %d", r.Sum)
}

Dans cet exemple, nous créons un fichier nommé client Objet client et nous nous connectons au serveur via la méthode grpc.Dial. Ensuite, nous analysons les deux opérandes de l'addition à partir des paramètres de ligne de commande et appelons la méthode Add pour envoyer la requête, obtenir les résultats renvoyés par le serveur et les afficher.

5. Exécutez l'exemple

Une fois les deux fichiers écrits, utilisez la commande suivante pour compiler et exécuter les deux programmes :

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

Ensuite, exécutez la commande suivante dans un autre terminal pour exécuter le programme client :

$ ./client 1 2

Le résultat en cours d'exécution sera la sortie du résultat du calcul 3.

Ce qui précède est l'installation et l'utilisation de gRPC dans Golang. L'écriture de systèmes distribués efficaces via gRPC deviendra très simple.

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!