gRPC pour Go (Golang) : bibliothèques, exemples et guide complet

gRPC pour Go (Golang) : bibliothèques et exemples

Qu'est-ce que gRPC et pourquoi l'utiliser en Go ?

gRPC est un framework d'appel de procédure à distance (RPC) haute performance développé par Google. Il utilise Protocol Buffers (protobuf) pour la sérialisation des données et HTTP/2 pour le transport. Dans l'écosystème Go, gRPC est devenu la référence pour construire une architecture de microservices grâce à :

• Des performances élevées (protocole binaire, multiplexage HTTP/2)
• Un typage fort (code généré en Go)
• La prise en charge du streaming (client, serveur et bidirectionnel)
• Une authentification et un équilibrage de charge intégrés

Dans cet article, nous allons explorer les bibliothèques essentielles, les outils et créer un exemple complet de serveur et client en Golang.

Bibliothèques et outils nécessaires

Pour travailler avec gRPC en Go, vous aurez besoin de :

• google.golang.org/grpc — la bibliothèque principale gRPC pour Go
• google.golang.org/protobuf — pour manipuler Protocol Buffers
• protoc — le compilateur de fichiers .proto
• protoc-gen-go — le plugin pour générer du code Go à partir de .proto
• protoc-gen-go-grpc — le plugin pour générer le code serveur/client gRPC

Installation des outils

# Installation de protoc (Linux/macOS)
sudo apt install protobuf-compiler  # ou brew install protobuf

# Installation des plugins Go
go install google.golang.org/protobuf/cmd/protoc-gen-go@latest
go install google.golang.org/grpc/cmd/protoc-gen-go-grpc@latest

# Vérification
protoc --version
protoc-gen-go --version

Création du fichier .proto

Commençons par définir le service et les messages dans le fichier hello.proto :

syntax = "proto3";

package hello;

option go_package = "github.com/votreutilisateur/grpc-exemple/hello";

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply);
  rpc SayHelloStream (HelloRequest) returns (stream HelloReply);
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

Génération du code Go

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

Après exécution, deux fichiers apparaissent :

• hello.pb.go — les structures des messages
• hello_grpc.pb.go — les interfaces serveur et client

Implémentation du serveur gRPC en Go

Créons le fichier server.go :

package main

import (
    "context"
    "log"
    "net"

    "google.golang.org/grpc"
    pb "github.com/votreutilisateur/grpc-exemple/hello"
)

type server struct {
    pb.UnimplementedGreeterServer
}

func (s *server) SayHello(ctx context.Context, req *pb.HelloRequest) (*pb.HelloReply, error) {
    log.Printf("Reçu : %v", req.GetName())
    return &pb.HelloReply{Message: "Bonjour, " + req.GetName()}, nil
}

func (s *server) SayHelloStream(req *pb.HelloRequest, stream pb.Greeter_SayHelloStreamServer) error {
    for i := 0; i < 5; i++ {
        if err := stream.Send(&pb.HelloReply{
            Message: "Bonjour " + req.GetName() + " - " + fmt.Sprint(i),
        }); err != nil {
            return err
        }
    }
    return nil
}

func main() {
    lis, err := net.Listen("tcp", ":50051")
    if err != nil {
        log.Fatalf("échec de l'écoute : %v", err)
    }

    s := grpc.NewServer()
    pb.RegisterGreeterServer(s, &server{})

    log.Println("Serveur à l'écoute sur le port :50051")
    if err := s.Serve(lis); err != nil {
        log.Fatalf("échec du service : %v", err)
    }
}

Implémentation du client gRPC en Go

Créons le fichier client.go :

package main

import (
    "context"
    "log"
    "time"

    "google.golang.org/grpc"
    "google.golang.org/grpc/credentials/insecure"
    pb "github.com/votreutilisateur/grpc-exemple/hello"
)

func main() {
    conn, err := grpc.Dial("localhost:50051",
        grpc.WithTransportCredentials(insecure.NewCredentials()))
    if err != nil {
        log.Fatalf("échec de la connexion : %v", err)
    }
    defer conn.Close()

    client := pb.NewGreeterClient(conn)

    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel()

    reponse, err := client.SayHello(ctx, &pb.HelloRequest{Name: "Monde"})
    if err != nil {
        log.Fatalf("échec de SayHello : %v", err)
    }
    log.Printf("Réponse du serveur : %s", reponse.GetMessage())
}

Conclusion

Vous avez maintenant un serveur et un client gRPC fonctionnels en Go. Cette base vous permet de construire des microservices performants et scalables. Pour aller plus loin, explorez les fonctionnalités avancées comme l'interception, l'authentification TLS et le streaming bidirectionnel.