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; }
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) } }
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) }
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!