Maison > développement back-end > Golang > installation de grpc golang

installation de grpc golang

WBOY
Libérer: 2023-05-16 12:50:07
original
650 Les gens l'ont consulté

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
Copier après la connexion

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

$ ./configure
$ make
$ sudo make install
Copier après la connexion

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
Copier après la connexion

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;
}
Copier après la connexion

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
Copier après la connexion

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)
    }
}
Copier après la connexion

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)
}
Copier après la connexion

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
Copier après la connexion

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

$ ./client 1 2
Copier après la connexion

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!

source:php.cn
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal