Introduction

Dans le monde des microservices et des systèmes distribués, une communication efficace entre les services est cruciale. C’est là qu’entre en jeu gRPC, un framework RPC (Remote Procedure Call) hautes performances développé par Google. Associé à Go, un langage de programmation compilé et typé statiquement conçu pour la simplicité et l'efficacité, gRPC peut vous aider à créer des services Web robustes et évolutifs.

Qu’est-ce que gRPC ?

gRPC signifie google Remote Pprocédure Call. Il s'agit d'un framework open source qui utilise HTTP/2 pour le transport, Protocol Buffers comme langage de description d'interface et fournit des fonctionnalités telles que l'authentification, l'équilibrage de charge, etc. gRPC vous permet de définir vos méthodes de service et vos types de messages dans un fichier .proto, qui peut ensuite être utilisé pour générer du code client et serveur dans plusieurs langues.

Pourquoi utiliser gRPC avec Go ?

1. Performances : gRPC utilise HTTP/2, qui permet de multiplexer plusieurs requêtes sur une seule connexion, réduisant ainsi la latence et améliorant les performances.
2. Génération de code : avec les tampons de protocole, vous pouvez définir votre service une seule fois et générer du code client et serveur dans Go, garantissant ainsi la cohérence et réduisant le code passe-partout.
3. Streaming : gRPC prend en charge le streaming côté client, côté serveur et bidirectionnel, ce qui le rend idéal pour les applications en temps réel.
4. Interopérabilité : les services gRPC peuvent être consommés par des clients écrits dans différentes langues, ce qui en fait un choix polyvalent pour les environnements polyglottes.

Premiers pas avec gRPC dans Go

• ### Prérequis

  Avant de commencer, assurez-vous que les éléments suivants sont installés :

  • Go (l'une des deux dernières versions majeures)
  • Compilateur de tampon de protocole (protoc)
  • Go plugins pour le compilateur de tampon de protocole

  Vous pouvez installer les plugins Go à l'aide des commandes suivantes :
  

  go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
  go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest
  

  Mettez à jour votre PATH pour que le compilateur de protocole puisse trouver les plugins :
  

  export PATH="$PATH:$(go env GOPATH)/bin"
  

  Confirmez que le protocole est installé et configuré sur votre système en ouvrant un terminal et en tapant :
  

  protoc --version
  

  Vous devriez voir un résultat similaire à celui-ci
  

  C:\Users\Guest>protoc --version
  ~ libprotoc 27.3
  

  S'il ne reconnaît pas la commande protoc, vous pouvez utiliser Chocolatey pour Windows pour installer les tampons de protocole :
  

  choco install protoc
  

  Si ce n'est pas le cas, si Chocolatey n'est pas installé ou si vous utilisez un autre système d'exploitation, vous pouvez consulter la documentation d'installation officielle ici.

  Définir le service

  Créez un fichier .proto pour définir votre service gRPC. Par exemple:

  helloworld.proto
  

  syntax = "proto3";
  package helloworld;
  
  message HelloRequest {
      string name = 1;
  }
  message HelloResponse {
      string message = 1;
  }
  
  service Greeter {
      rpc SayHello (HelloRequest) returns (HelloResponse) {}
  }
  

  Génération de code

  Générez le code Go à partir de votre fichier .proto :
  

  protoc --go_out=. --go-grpc_out=. helloworld.proto
  

  Implémentation du serveur

  Créer un serveur dans Go :

  server.go
  

  package main
  
  import (
      "context"
      "log"
      "net"
  
      "google.golang.org/grpc"
      pb "path/to/your/proto"
  )
  
  type server struct {
      pb.GreeterServer
  }
  
  func main() {
      lis, err := net.Listen("tcp", ":8080")
      if err != nil {
          log.Fatalf("failed to listen: %v", err)
      }
  
      log.Printf("Server started at %v", lis.Addr())
  
      grpcServer := grpc.NewServer()
      pb.RegisterGreeterServer(grpcServer, &server{})
      if err := grpcServer.Serve(lis); err != nil {
          log.Fatalf("failed to serve: %v", err)
      }
  }
  
  // SayHello name should be the same RPC name as defined in your proto file
  func (s *server) SayHello(ctx context.Context, in *pb.HelloRequest) (*pb.HelloResponse, error) {
      return &pb.HelloResponse{Message: "Hello "   in.Name}, nil
  }
  

  Création du client

  Créer un client dans Go :

  client.go
  

  package main
  
  import (
      "context"
      "log"
      "os"
      "time"
  
      "google.golang.org/grpc"
      pb "path/to/your/proto"
  )
  
  func main() {
      conn, err := grpc.NewClient("localhost:8080", grpc.WithTransportCredentials(insecure.NewCredentials()))
      if err != nil {
          log.Fatalf("did not connect: %v", err)
      }
      defer conn.Close()
      client := pb.NewGreeterClient(conn)
  
      name := "John Doe"
      if len(os.Args) > 1 {
          name = os.Args[1]
      }
  
      callSayHello( client, name )
  }
  
  func callSayHello(client pb.GrpcServiceClient, name string) {
      ctx, cancel := context.WithTimeout(context.Background(), time.Second)
      defer cancel()
  
      res, err := client.SayHello(ctx, &pb.HelloRequest{Name: name})
      if err != nil {
          log.Fatalf("Failed to called: %v", err)
      }
      log.Printf("%v", res)
  }
  

Conclusion

gRPC et Go offrent ensemble une combinaison puissante pour créer des services Web hautes performances et évolutifs. En tirant parti des atouts des deux, vous pouvez créer des applications efficaces et fiables, faciles à maintenir et à étendre.

Lien vers le dépôt de démonstration : Github.com