Une brève analyse de la façon d'installer et d'utiliser grpc dans Golang

Golang est un langage de programmation populaire et de plus en plus de personnes l'utilisent pour développer différents types d'applications. Pour rendre Golang plus évolutif, Google a développé un framework RPC hautes performances appelé gRPC. gRPC utilise Protocol Buffers comme outil de sérialisation par défaut, ce qui le rend plus efficace et nécessite moins de surcharge que les autres frameworks RPC. Dans cet article, nous expliquerons comment installer gRPC et comment l'utiliser avec Golang.

1. Installer gRPC

Golang nécessite deux étapes pour installer gRPC : installez d'abord les tampons de protocole, puis installez gRPC.

1. Installer les tampons de protocole
   Vous pouvez ignorer cette étape si vous avez déjà installé les tampons de protocole. Sinon, vous pouvez télécharger et installer la version appropriée à votre système d'exploitation à partir de : https://github.com/protocolbuffers/protobuf/releases.
2. Installer gRPC
   Après avoir installé avec succès Protocol Buffers, vous pouvez utiliser la commande suivante pour installer gRPC :

$ go get -u google.golang.org/grpc

Une fois l'installation terminée, vous pouvez trouver le code source de gRPC dans $GOPATH/src/google.golang. Répertoire org/grpc .

2. Utilisez gRPC

Après avoir installé gRPC, vous pouvez l'utiliser pour la communication RPC dans Golang. Voici comment créer un client et un serveur de base à l'aide de gRPC :

1. Define Service

Tout d'abord, vous devez définir votre service dans un fichier .proto. Voici un exemple simple :

syntax = "proto3";

package greeter;

service Greeter {
    rpc SayHello (HelloRequest) returns (HelloReply) {}
}

message HelloRequest {
    string name = 1;
}

message HelloReply {
    string message = 1;
}

Le code ci-dessus définit un service appelé Greeter, qui contient un appel RPC appelé SayHello. Cet appel RPC reçoit un objet HelloRequest en tant que paramètre et renvoie un objet HelloReply comme valeur de retour.

2. Générer du code

Une fois que vous avez défini votre fichier .proto, vous devez utiliser le compilateur Protocol Buffers pour générer le code. Vous pouvez générer du code à l'aide de la commande suivante :

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

Le code généré sera stocké dans le même répertoire que le fichier .proto.

3. Implémentation du serveur

Ensuite, vous devez écrire le code pour implémenter le serveur. Voici un exemple simple :

package main

import (
    "context"
    "log"
    "net"

    "google.golang.org/grpc"
    pb "github.com/example/greeter"
)

const (
    port = ":50051"
)

type server struct{}

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

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

Le code ci-dessus implémente un service appelé Greeter et implémente l'appel RPC de SayHello. Cet appel concatène la chaîne « Hello » avec le nom fourni par le client et le renvoie.

4. Implémentation du client

Enfin, vous devez écrire le code client afin d'utiliser les services fournis par le serveur. Voici un exemple simple :

package main

import (
    "context"
    "log"

    "google.golang.org/grpc"
    pb "github.com/example/greeter"
)

const (
    address = "localhost:50051"
)

func main() {
    conn, err := grpc.Dial(address, grpc.WithInsecure())
    if err != nil {
        log.Fatalf("did not connect: %v", err)
    }
    defer conn.Close()

    c := pb.NewGreeterClient(conn)

    name := "world"
    r, err := c.SayHello(context.Background(), &pb.HelloRequest{Name: name})
    if err != nil {
        log.Fatalf("could not greet: %v", err)
    }
    log.Printf("Greeting: %s", r.Message)
}

Le code ci-dessus crée un client gRPC et appelle la méthode SayHello du serveur.

Conclusion

L'utilisation de gRPC peut rendre les applications Golang plus évolutives et plus performantes. L'installation et l'utilisation de gRPC sont très simples et ne nécessitent que quelques étapes. En suivant les étapes ci-dessus, vous pourrez créer plus facilement des appels RPC dans Golang à l'aide de gRPC et communiquer avec d'autres systèmes de manière efficace.

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!