Un article présentant comment utiliser gRPC Golang

gRPC est un framework RPC hautes performances, polyvalent et open source développé et open source par Google. gRPC prend en charge plusieurs langages de programmation, dont Golang. Cet article explique comment utiliser gRPC Golang.

1. Installez gRPC

Avant de développer gRPC Golang, vous devez d'abord installer gRPC. Vous pouvez l'installer via la commande suivante :

go get -u google.golang.org/grpc

Une fois l'installation terminée, vous devez également installer le générateur de code de langue Go de gRPC, protoc-gen-go, qui peut être installé via la commande suivante :

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

2. Créez le Fichier .proto

Lors de l'utilisation de gRPC Golang Avant de développer, vous devez d'abord définir le fichier .proto. Le fichier .proto définit l'interface du service et le format du message. Voici un exemple de fichier .proto :

syntax = "proto3";

package helloworld;

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

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

• la syntaxe définit la version de syntaxe utilisée par le fichier .proto
• package définit le nom du package
• service définit un service
• rpc définit une méthode qui contient l'entrée de la requête et return output
• message Définissez le format du message

3. Générez le code de langue Go

Une fois le fichier .proto défini, vous devez utiliser l'outil protoc pour générer le code de langue Go. Il peut être généré via la commande suivante :

protoc -I helloworld/ helloworld/helloworld.proto --go_out=plugins=grpc:helloworld

Le code de langue Go généré sera enregistré dans le répertoire helloworld spécifié.

4. Implémentez le serveur

Après avoir généré le code de langue Go, vous devez implémenter le service. Voici un exemple de service qui implémente la méthode SayHello :

package main

import (
    "context"
    "fmt"
    "net"

    "google.golang.org/grpc"
    pb "github.com/your_username/helloworld"
)

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 {
        fmt.Printf("failed to listen: %v", err)
        return
    }
    s := grpc.NewServer()
    pb.RegisterGreeterServer(s, &server{})
    fmt.Printf("server listening at %v", lis.Addr())
    if err := s.Serve(lis); err != nil {
        fmt.Printf("failed to serve: %v", err)
    }
}

• La structure du serveur qui implémente la méthode SayHello
• La méthode SayHello reçoit un contexte (ctx) et un objet HelloRequest en entrée, et renvoie un objet HelloReply et une erreur
• via grpc.NewServer() crée un serveur gRPC
• Utilisez pb.RegisterGreeterServer pour enregistrer le service sur le serveur
• Démarrez le serveur

5. Implémentez le client

En implémentant le client, vous pouvez appeler le service. Voici un exemple de client qui implémente l'appel de la méthode SayHello :

package main

import (
    "context"
    "log"
    "os"
    "time"

    "google.golang.org/grpc"
    pb "github.com/your_username/helloworld"
)

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

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

    // Contact the server and print out its response.
    name := defaultName
    if len(os.Args) > 1 {
        name = os.Args[1]
    }
    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel()
    r, err := c.SayHello(ctx, &pb.HelloRequest{Name: name})
    if err != nil {
        log.Fatalf("could not greet: %v", err)
    }
    log.Printf("Greeting: %s", r.Message)
}

• Utilisez la méthode grpc.Dial pour créer une connexion
• Créez un objet GreeterClient c
• Utilisez la méthode c.SayHello pour demander le service
• Imprimez la réponse du service

Six, compilez et exécutez le programme

Utilisez les commandes suivantes pour compiler les programmes serveur et client :

go build -o server ./server/main.go
go build -o client ./client/main.go

Exécutez le programme serveur :

./server

Exécutez le programme client :

./client

7. Résumé

Cet article présente l'utilisation de gRPC Golang, notamment l'installation de gRPC et de protoc-gen-go, la création de fichiers .proto, la génération de code en langage Go, l'implémentation du serveur et du client, et enfin la compilation et l'exécution du programme. gRPC Golang fournit un framework RPC polyvalent et hautes performances qui peut être utilisé pour la communication entre les services dans les systèmes distribués.

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!