Premier pas avec gRPC
Premier pas avec gRPC

Premier pas avec gRPC

Si vous développez des API en Node.js, vous respirez probablement du JSON et du REST à longueur de journée. C'est le standard, c'est flexible, et ça marche partout.

Mais avez-vous déjà eu l'impression que vos microservices "bavardaient" trop lentement ? Ou qu'une simple faute de frappe dans un nom de champ JSON faisait planter votre application en production ?

C'est là qu'intervient gRPC.

Dans cet article, nous allons voir comment cette technologie créée par Google peut transformer vos architectures Node.js, et nous allons construire ensemble votre premier client/serveur gRPC.

gRPC, c'est quoi ce truc ?

gRPC (gRemote Procedure Call) est un framework open-source qui permet à un service de communiquer avec un autre de manière extrêmement rapide et structurée.

Contrairement à REST qui envoie du texte (JSON) via HTTP/1.1, gRPC utilise :

  1. HTTP/2 : Pour la performance (multiplexage, streaming).

  2. Protocol Buffers (Protobuf) : Un format binaire ultra-léger pour les données.

Pourquoi les dévs JS s'y mettent ?

Le Tutoriel : Créons un service "News"

Assez de blabla. Mettons les mains dans le code. Nous allons créer une architecture simple :

  1. Un Serveur qui possède des articles de news.

  2. Un Client qui demande une news spécifique.

Prérequis

Créez un dossier pour votre projet et installez les dépendances gRPC pour Node.js :

Installer les dépendances gRPC
Bash
mkdir grpc-tuto && cd grpc-tuto
npm init -y
npm install @grpc/grpc-js @grpc/proto-loader

Note : On utilise @grpc/grpc-js qui est l'implémentation pure JavaScript moderne, remplaçant l'ancienne librairie grpc native.

Étape 1 : Le Contrat (Le fichier .proto)

C'est la pièce maîtresse. Nous allons définir à quoi ressemblent nos données et nos fonctions dans un fichier nommé news.proto.

Créez le fichier news.proto à la racine :

Protocol Buffersnews.proto
Proto
syntax = "proto3";

package news;

// 1. Définition du Service
service NewsService {
  rpc GetNews (NewsRequest) returns (NewsResponse) {}
}

// 2. Définition des Messages (les données)
message NewsRequest {
  string id = 1; // On envoie un ID
}

message NewsResponse {
  string id = 1;
  string title = 2;
  string body = 3;
  string image_url = 4;
}

Contrairement au JSON, chaque champ a un numéro unique (= 1, = 2). C'est ce qui permet de compresser les données en binaire : on n'envoie pas le mot "title" sur le réseau, juste le numéro 2.

Étape 2 : Le Serveur (Node.js)

Créez un fichier server.js. C'est ici que nous allons implémenter la logique.

Logique du serveur gRPCserver.js
JavaScript
const grpc = require('@grpc/grpc-js');
const protoLoader = require('@grpc/proto-loader');

// 1. Chargement du fichier .proto
const packageDefinition = protoLoader.loadSync('news.proto', {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
});
const newsProto = grpc.loadPackageDefinition(packageDefinition).news;

// Données fictives (mock)
const newsData = [
  { id: "1", title: "Node.js 20 est sorti", body: "Voici les nouveautés...", image_url: "img1.jpg" },
  { id: "2", title: "gRPC vs REST", body: "Le combat des chefs...", image_url: "img2.jpg" }
];

// 2. Implémentation de la méthode GetNews
function getNews(call, callback) {
  const newsId = call.request.id;
  const newsItem = newsData.find(n => n.id === newsId);

  if (newsItem) {
    // Succès : null en erreur, et l'objet en réponse
    callback(null, newsItem);
  } else {
    // Erreur : on renvoie une erreur gRPC standard
    callback({
      code: grpc.status.NOT_FOUND,
      details: "News introuvable"
    });
  }
}

// 3. Démarrage du serveur
function main() {
  const server = new grpc.Server();

  // On lie notre implémentation au service défini dans le proto
  server.addService(newsProto.NewsService.service, { GetNews: getNews });

  const address = '127.0.0.1:50051';
  server.bindAsync(address, grpc.ServerCredentials.createInsecure(), () => {
    console.log(`🚀 Serveur gRPC démarré sur ${address}`);
    server.start(); // Facultatif selon les versions, mais explicite
  });
}

main();

Étape 3 : Le Client (Node.js)

Maintenant, créons un script pour consommer notre API. Créez client.js.

Logique client gRPCclient.js
JavaScript
const grpc = require('@grpc/grpc-js');
const protoLoader = require('@grpc/proto-loader');

// On charge le même fichier proto ! C'est le contrat partagé.
const packageDefinition = protoLoader.loadSync('news.proto', {
  keepCase: true,
  longs: String,
  enums: String,
  defaults: true,
  oneofs: true
});
const newsProto = grpc.loadPackageDefinition(packageDefinition).news;

function main() {
  // Création du client
  const client = new newsProto.NewsService(
    '127.0.0.1:50051',
    grpc.credentials.createInsecure()
  );

  // Appel de la méthode
  console.log("📡 Appel du service...");

  client.GetNews({ id: "1" }, (error, response) => {
    if (!error) {
      console.log("✅ Réponse reçue du serveur :");
      console.log(response);
    } else {
      console.error("❌ Erreur :", error.details);
    }
  });
}

main();

Testons le tout !

  1. Ouvrez un terminal et lancez le serveur :

Commande Serveur Bash
Bash
node server.js

2. Ouvrez un deuxième terminal et lancez le client :

Commande Bash du client
Bash
node client.js

Vous devriez voir :

Réponse Bash
Bash
📡 Appel du service...
✅ Réponse reçue du serveur :
{
  id: '1',
  title: 'Node.js 20 est sorti',
  body: 'Voici les nouveautés...',
  image_url: 'img1.jpg'
}

Essayez de changer l'ID dans client.js par "99", et vous verrez l'erreur gRPC "News introuvable" s'afficher proprement.

Quand utiliser gRPC dans vos projets JS ?

Faut-il jeter toutes vos API REST Express ? Surtout pas.

Utilisez gRPC si :

Gardez REST si :

Conclusion

gRPC n'est pas juste une "hype", c'est un outil puissant pour structurer vos communications backend. En tant que développeur JS, l'apprentissage est rapide et le gain en robustesse est immédiat.

Alors, prêt à écrire votre premier fichier .proto ?