Maison > développement back-end > Golang > le corps du texte

Un article présentant comment utiliser gRPC Golang

PHPz
Libérer: 2023-04-13 09:54:25
original
1047 Les gens l'ont consulté

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

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

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

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

Exécutez le programme serveur :

./server
Copier après la connexion

Exécutez le programme client :

./client
Copier après la connexion

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!

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