gRPC pour TypeScript : bibliothèques, configuration et exemples de code

gRPC pour TypeScript : bibliothèques et exemples

gRPC est un framework moderne et haute performance pour l'appel de procédure à distance (RPC), développé par Google. Il utilise Protocol Buffers (protobuf) comme langage de définition d'interface et format de sérialisation des données. En TypeScript, gRPC est implémenté via les paquets @grpc/grpc-js (pour la logique serveur et client) et protobufjs (pour travailler avec les fichiers .proto). Dans cet article, nous allons examiner les bibliothèques clés, la configuration de l'environnement et écrire un exemple fonctionnel en TypeScript.

Bibliothèques clés pour gRPC en TypeScript

• @grpc/grpc-js — implémentation pure JavaScript de gRPC (sans addons C++). Prend en charge toutes les fonctionnalités principales : appels unaires, streaming serveur et client, streaming bidirectionnel.
• protobufjs — bibliothèque pour charger, analyser et générer des classes à partir de fichiers .proto. Permet de créer dynamiquement des messages et des services.
• @grpc/proto-loader — paquet utilitaire qui simplifie le chargement des fichiers proto et génère automatiquement des types TypeScript basés sur les définitions.
• ts-protoc-gen — générateur de code pour le compilateur protoc. Permet de générer des classes et interfaces fortement typées à partir de fichiers .proto.

Pour la plupart des projets, la combinaison @grpc/grpc-js + @grpc/proto-loader est suffisante. Si une sécurité de typage maximale est requise, on utilise ts-protoc-gen ou protobufjs avec génération de types statiques.

Installation des dépendances

Créez un nouveau projet et installez les paquets nécessaires :

mkdir grpc-typescript-examplecd grpc-typescript-examplenpm init -ynpm install @grpc/grpc-js @grpc/proto-loadernpm install -D typescript @types/nodenpx tsc --init

Création du fichier proto

Définissons un service simple pour la gestion des utilisateurs. Créez le fichier user.proto :

syntax = "proto3";

package user;

service UserService {  rpc GetUser (GetUserRequest) returns (User);  rpc ListUsers (ListUsersRequest) returns (stream User);}

message GetUserRequest {  int32 id = 1;}

message ListUsersRequest {  int32 page = 1;  int32 limit = 2;}

message User {  int32 id = 1;  string name = 2;  string email = 3;}

Implémentation du serveur gRPC en TypeScript

Créons le fichier server.ts :

import * as grpc from '@grpc/grpc-js';import * as protoLoader from '@grpc/proto-loader';import path from 'path';

const PROTO_PATH = path.join(__dirname, 'user.proto');

const packageDefinition = protoLoader.loadSync(PROTO_PATH, {  keepCase: true,  longs: String,  enums: String,  defaults: true,  oneofs: true,});

const userProto = grpc.loadPackageDefinition(packageDefinition) as any;

// Simulation de base de donnéesconst users = [  { id: 1, name: 'Alice', email: 'alice@example.com' },  { id: 2, name: 'Bob', email: 'bob@example.com' },];

function getUser(  call: grpc.ServerUnaryCall<{ id: number }, any>,  callback: grpc.sendUnaryData<any>) {  const user = users.find(u => u.id === call.request.id);  if (!user) {    return callback({      code: grpc.status.NOT_FOUND,      message: 'Utilisateur non trouvé',    });  }  callback(null, user);}

function listUsers(call: grpc.ServerWritableStream<{ page: number; limit: number }, any>) {  const page = call.request.page || 1;  const limit = call.request.limit || 10;  const start = (page - 1) * limit;  const end = start + limit;  const paginatedUsers = users.slice(start, end);  paginatedUsers.forEach(user => call.write(user));  call.end();}

function main() {  const server = new grpc.Server();