Comment utiliser gRPC pour implémenter un serveur et un client de base dans Golang

gRPC est un framework d'appel de procédure à distance hautes performances, open source et universel, adapté aux appels RPC dans tous les langages et plates-formes. Il utilise le protocole protobuf développé par Google pour la transmission de données, peut réaliser rapidement une communication entre le serveur et le client et offre des fonctions riches et une évolutivité. Cet article explique comment utiliser gRPC pour implémenter des serveurs et des clients de base dans Golang.

1. Installez gRPC

Avant de commencer, nous devons d'abord installer gRPC et protobuf. Vous pouvez utiliser la commande suivante :

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

2. Créez le fichier protobuf

Ensuite, nous devons créer un fichier .proto, ceci. fichier nous définit Les données à transférer et la méthode à appeler. Dans cet exemple, nous avons créé un fichier appelé greet.proto.

syntax = "proto3";

package greet;

service GreetService {
  rpc SayHello (HelloRequest) returns (HelloResponse) {}
}

message HelloRequest {
  string name = 1;
}

message HelloResponse {
  string message = 1;
}

3. Générer du code

Générer du code lié à gRPC via le fichier protobuf. Exécutez la commande suivante :

$ protoc -I greet/ greet/greet.proto --go_out=plugins=grpc:greet

Le code généré sera enregistré dans le répertoire greet.

4. Implémenter le côté serveur

Dans l'implémentation côté serveur, nous devons implémenter l'interface de service définie dans le fichier proto. Nous pouvons terminer l'implémentation du code côté serveur en suivant les étapes suivantes :

• Créer un serveur gRPC
• Enregistrer le service
• Exécuter le serveur

Voici l'implémentation du code :

package main

import (
    "context"
    "log"
    "net"

    "google.golang.org/grpc"
    pb "path/to/greet"
)

type server struct {}

func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloResponse, error) {
    return &pb.HelloResponse{Message: "Hello " + in.Name}, nil
}

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

5. Implémenter le client

La mise en œuvre client est relativement simple. Il suffit de se connecter au serveur correspondant et d'instancier le client, puis de pouvoir appeler les méthodes fournies par le serveur. Dans l'implémentation du code client, vous devez d'abord créer une connexion pour la communication gRPC, puis utiliser la connexion pour créer un client et appeler la méthode d'interface.

Ce qui suit est l'implémentation du code client :

package main

import (
    "log"
    "os"
    "context"
    "google.golang.org/grpc"
    pb "path/to/greet"
)

func main() {
    address := "localhost:50051"
    if len(os.Args) > 1 {
        address = os.Args[1]
    }
    conn, err := grpc.Dial(address, grpc.WithInsecure())
    if err != nil {
        log.Fatalf("couldn't connect: %v", err)
    }
    defer conn.Close()

    c := pb.NewGreetServiceClient(conn)

    name := "world"
    if len(os.Args) > 2 {
        name = os.Args[2]
    }
    r, err := c.SayHello(context.Background(), &pb.HelloRequest{Name: name})
    if err != nil {
        log.Fatalf("error: %v", err)
    }
    log.Printf("Greeting: %s", r.Message)
}

6. Tests

Nous avons implémenté le code serveur et client, exécutons maintenant le serveur, puis démarrons le client pour tester.

$ go run greet_server.go

Après avoir exécuté le serveur, ouvrez un terminal et exécutez le client pour tester :

$ go run greet_client.go
Greeting: Hello world

7. Résumé

Cet article présente comment utiliser gRPC pour implémenter un serveur et un client de base dans Golang. gRPC offre de puissantes capacités d'encodage et de décodage tout en prenant en charge plusieurs formats de transport, notamment JSON et les données de tampon de protocole, ce qui le rend adapté à différents types d'applications. Par exemple, les systèmes distribués, les applications et jeux Web à grande échelle, etc. Si vous souhaitez en savoir plus sur gRPC, consultez la documentation officielle.

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!