Qu'est-ce que gRPC ?

gRPC est un framework open source haute performance pour les appels de procédure distante (RPC), développé par Google, pour créer des applications distribuées et des microservices. Il est basé sur le protocole HTTP/2 pour le transport et utilise Protocol Buffers (Protobuf) comme langage de description d'interface et mécanisme de sérialisation.

Principales caractéristiques de gRPC :

• HTTP/2 : Exploite les avantages de HTTP/2, tels que la multiplexation des requêtes, la compression des en-têtes et le flux bidirectionnel, offrant de meilleures performances par rapport aux protocoles client-serveur traditionnels sur HTTP/1.1.
• Protocol Buffers (Protobuf) : Langage de description de données permettant de structurer les données et de générer du code pour la sérialisation et la désérialisation dans plusieurs langages. Protobuf est efficace en termes de taille de message et de vitesse de traitement.
• Streaming : Supporte quatre types de streaming :
  • Unary : RPC classique (une requête - une réponse).
  • Streaming côté serveur : Le client envoie une requête, le serveur répond avec un flux de messages.
  • Streaming côté client : Le client envoie un flux de messages, le serveur répond par un message.
  • Streaming bidirectionnel : Le client et le serveur échangent des flux de messages simultanément.
• Multilingue : Avec Protobuf, gRPC génère du code client et serveur pour plusieurs langages de programmation.
• Génération de code : Création automatisée de code pour le client et le serveur basé sur le fichier .proto, réduisant la codification manuelle.
• Métadonnées : Supporte la transmission de métadonnées (paires clé-valeur) avec les requêtes et réponses.
• Intercepteurs : Capacité à intercepter les requêtes et réponses pour effectuer une logique supplémentaire (par exemple, journalisation, authentification).

Comment fonctionne gRPC :

1. Le service API est défini en utilisant le langage Protocol Buffers dans un fichier .proto.
2. Du code client et serveur est généré dans le langage souhaité à l'aide du compilateur protoc.
3. Le serveur implémente l'interface du service générée.
4. Le client utilise le code généré pour appeler les méthodes du service sur le serveur.

Exemple de fichier .proto :

syntax = "proto3";

package greeting;

// Définition du service
service Greeter {
  // Méthode RPC unitaire
  rpc SayHello (HelloRequest) returns (HelloReply) {}
  // Méthode de streaming côté serveur
  rpc SayHelloStream (HelloRequest) returns (stream HelloReply) {}
}

// Définition des messages
message HelloRequest {
  string name = 1; // Champ avec numéro de position 1
}

message HelloReply {
  string message = 1;
}

Comparaison avec REST (utilisant JSON/XML) :

Caractéristique	gRPC (Protobuf)	REST (JSON/XML)
Protocole de transport	HTTP/2	HTTP/1.1 ou HTTP/2
Sérialisation des données	Protobuf (binaire)	JSON, XML (texte)
Performance	Élevée (format binaire, HTTP/2)	Inférieure (format texte, surcharge)
Langage de description API	Protocol Buffers (.proto)	OpenAPI/Swagger
Contrat API	Strict, basé sur Protobuf	Moins strict
Typage des données	Strict (défini dans .proto)	Faible (vérification à l'exécution)
Génération de code	Intégrée	Nécessite des outils tiers
Streaming	Intégré	Nécessite des mécanismes supplémentaires (par exemple, WebSockets)
Lisibilité	Difficile à lire sans .proto	Facile à lire par un humain

gRPC est très adapté pour l'interaction entre services dans des systèmes distribués, microservices, transmission de grands volumes de données, où la performance et un contrat API strict sont importants.