gRPC für TypeScript: Bibliotheken, Einrichtung und Codebeispiele

gRPC für TypeScript: Bibliotheken und Beispiele

gRPC ist ein modernes, hochleistungsfähiges Framework für entfernte Prozeduraufrufe (RPC), das von Google entwickelt wurde. Es verwendet Protocol Buffers (protobuf) als Schnittstellendefinitionssprache und Daten serialisierungsformat. In TypeScript wird gRPC über die Pakete @grpc/grpc-js (für Server- und Client-Logik) und protobufjs (für die Arbeit mit .proto-Dateien) implementiert. In diesem Artikel werden wir die wichtigsten Bibliotheken, die Einrichtung der Umgebung besprechen und ein funktionierendes Beispiel in TypeScript schreiben.

Wichtige Bibliotheken für gRPC in TypeScript

• @grpc/grpc-js — eine reine JavaScript-Implementierung von gRPC (ohne C++-Addons). Unterstützt alle grundlegenden Funktionen: unäre Aufrufe, Server- und Client-Streaming, bidirektionales Streaming.
• protobufjs — eine Bibliothek zum Laden, Parsen und Generieren von Klassen aus .proto-Dateien. Ermöglicht das dynamische Erstellen von Nachrichten und Diensten.
• @grpc/proto-loader — ein Hilfspaket, das das Laden von Proto-Dateien vereinfacht und automatisch TypeScript-Typen basierend auf den Definitionen generiert.
• ts-protoc-gen — ein Code-Generator für den protoc-Compiler. Ermöglicht die Generierung streng typisierter Klassen und Schnittstellen aus .proto-Dateien.

Für die meisten Projekte reicht die Kombination aus @grpc/grpc-js + @grpc/proto-loader aus. Wenn maximale Typsicherheit erforderlich ist, werden ts-protoc-gen oder protobufjs mit Generierung statischer Typen verwendet.

Installation der Abhängigkeiten

Erstellen Sie ein neues Projekt und installieren Sie die erforderlichen Pakete:

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

Erstellen der Proto-Datei

Definieren wir einen einfachen Dienst für die Arbeit mit Benutzern. Erstellen Sie die Datei 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;}

Implementierung des gRPC-Servers in TypeScript

Erstellen wir die Datei 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 einer Datenbankconst 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: 'User not found',    });  }  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();