déploiement grpc golang

gRPC est le framework RPC (Remote Procedure Call) open source et hautes performances de Google, qui prend en charge plusieurs langues, dont Golang. Dans Golang, le code gRPC est très simple à écrire et à utiliser, mais peut rencontrer certains défis lorsqu'il est réellement déployé.

Cet article expliquera comment utiliser gRPC dans Golang et le déployer sur le serveur.

1. Installer gRPC

Dans Golang, vous devez installer gRPC et les bibliothèques protobuf associées. Vous pouvez utiliser la commande suivante pour installer les bibliothèques gRPC et protobuf :

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

2. Définir le fichier proto

Dans gRPC, vous devez définir un fichier proto pour décrire le service que vous souhaitez. Par exemple, vous souhaiterez peut-être définir un service Echo qui accepte un message et le renvoie au client.

Ce qui suit est un exemple de fichier proto pour un service Echo simple :

syntax = "proto3";

option go_package = "echo";

service EchoService {
  rpc Echo (EchoMessage) returns (EchoMessage);
}

message EchoMessage {
  string message = 1;
}

Dans cet exemple, nous définissons un service Echo, qui a un type de message EchoMessage, qui contient une chaîne de message, et une méthode Echo, qui accepte un message EchoMessage et renvoie ce message en réponse.

3. Générer du code Golang

Une fois que vous avez défini un fichier proto, vous pouvez utiliser le compilateur protobuf pour générer le code Golang correspondant. Pour générer du code Golang, vous devez exécuter la commande suivante :

$ protoc --go_out=. echo.proto

Cela générera un fichier appelé echo.pb.go qui contient le code de votre service Echo.

4. Mise en œuvre du service

Ensuite, vous devez implémenter votre service Echo. Dans votre service Echo, vous devez implémenter la méthode Echo afin de recevoir le message EchoMessage et renvoyer le message au client.

Ce qui suit est un exemple simple d'implémentation du service Echo :

type server struct{}

func (s *server) Echo(ctx context.Context, message *EchoMessage) (*EchoMessage, error) {
  return &EchoMessage{
    Message: message.Message,
  }, nil
}

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

Dans cet exemple, nous implémentons un type de serveur, qui contient une méthode Echo. Lorsque le client appelle la méthode Echo, il renvoie le message reçu.

Nous avons également créé un serveur gRPC dans la fonction principale et transmis notre implémentation à la fonction d'enregistrement RegisterEchoServiceServer. Ensuite, nous commençons à écouter sur le port 50051 et démarrons le serveur.

5. Compiler et déployer

Après avoir terminé la mise en œuvre du service gRPC, vous devez le compiler et le déployer sur le serveur. Vous pouvez utiliser la commande suivante pour compiler votre code :

$ go build .

Cela créera un fichier exécutable que vous pourrez déployer sur votre serveur. Sur votre serveur, vous pouvez exécuter la commande suivante pour démarrer votre service gRPC :

$ ./your-program

Dans cet exemple, le nom de votre programme est "votre-programme". Notez qu'avant d'exécuter votre programme, vous devez vous assurer que votre serveur peut accéder au port 50051.

6. Test du code

Après avoir terminé le déploiement, vous pouvez utiliser le client gRPC pour tester votre code. Vous pouvez installer le client gRPC à l'aide de la commande suivante :

$ go get -u google.golang.org/grpc/cmd/protoc-gen-go-grpc

Pour utiliser le client gRPC, vous devez créer une connexion, puis utiliser cette connexion pour appeler votre service Echo.

Voici un exemple simple de client gRPC :

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

  c := NewEchoServiceClient(conn)
  message := &EchoMessage{Message: "hello world"}
  res, err := c.Echo(context.Background(), message)
  if err != nil {
    log.Fatalf("echo failed: %v", err)
  }
  log.Printf("echo response: %s", res.Message)
}

Dans cet exemple, nous créons une connexion puis utilisons cette connexion pour appeler notre service Echo. Nous avons transmis un message EchoMessage, puis testé si notre code fonctionnait correctement en imprimant la réponse du serveur.

7. Conclusion

gRPC est un framework RPC efficace et il sera très simple de l'utiliser dans Golang, mais vous pourriez rencontrer quelques défis lors du processus de déploiement lui-même. Cet article décrit comment installer gRPC et les bibliothèques protobuf associées, comment définir des fichiers proto et comment générer du code Golang. Nous avons également montré comment implémenter le service Echo et comment le déployer sur le serveur. Enfin, nous avons également montré comment utiliser le client gRPC pour tester le code.

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!