Mikroservices mit TypeScript: Architektur und Praxis

Einleitung: Warum TypeScript ideal für Microservices ist

Die Microservice-Architektur ist zum Standard für die Entwicklung komplexer, skalierbarer und ausfallsicherer Anwendungen geworden. TypeScript ist dank seiner strengen Typisierung, seines reichen Ökosystems und seiner Unterstützung für Asynchronität eine der besten Sprachen für die Implementierung von Microservices. Es ermöglicht das Schreiben von Code, der leichter zu refaktorisieren, zu testen und zu dokumentieren ist, was entscheidend ist, wenn ein System in Dutzende unabhängige Dienste aufgeteilt wird.

In diesem Artikel werden wir Architekturprinzipien erläutern, einen einfachen Microservice mit NestJS erstellen, die Kommunikation zwischen Diensten über RabbitMQ einrichten und alles in Docker Compose verpacken. Sie erhalten eine praktische, sofort nutzbare Grundlage für den Einstieg.

Microservice-Architektur mit TypeScript

Die richtige Architektur ist der Schlüssel zum Erfolg. Für TypeScript-Microservices werden drei wesentliche Schichten unterschieden:

• Transportschicht – zuständig für den Empfang und das Senden von Anfragen (HTTP, gRPC, Message Queues).
• Geschäftslogik – reine Funktionen und Dienste, die unabhängig vom Framework sind.
• Datenschicht – Repositories und ORM (TypeORM, Prisma).

Jeder Microservice sollte autonom sein: eine eigene Datenbank, CI/CD und Bereitstellungslogik besitzen. Die Kommunikation zwischen Diensten wird in der Regel über asynchrone Warteschlangen (RabbitMQ, Kafka) oder synchrone Aufrufe (gRPC) realisiert.

Praxis: Erstellen eines Microservices mit NestJS

Schritt 1: Projektinitialisierung

Installieren Sie die NestJS CLI und erstellen Sie ein neues Projekt:

npm i -g @nestjs/clinest new user-service --package-manager npmcd user-service

Schritt 2: Hinzufügen der Microservice-Unterstützung

NestJS bietet integrierte Unterstützung für Microservice-Transporter. Installieren wir RabbitMQ:

npm install @nestjs/microservices amqplib amqp-connection-manager

Erstellen wir die main.ts, die den Dienst als Microservice startet:

import { NestFactory } from '@nestjs/core';import { MicroserviceOptions, Transport } from '@nestjs/microservices';import { AppModule } from './app.module';

async function bootstrap() {  const app = await NestFactory.createMicroservice<MicroserviceOptions>(    AppModule,    {      transport: Transport.RMQ,      options: {        urls: ['amqp://localhost:5672'],        queue: 'user_queue',        queueOptions: { durable: false },      },    },  );  await app.listen();}bootstrap();

Schritt 3: Implementierung des Controllers

Erstellen wir einen einfachen Controller, der Nachrichten aus der Warteschlange verarbeitet:

import { Controller } from '@nestjs/common';import { MessagePattern, Payload } from '@nestjs/microservices';

@Controller()export class UserController {  @MessagePattern('user.create')  createUser(@Payload() data: { name: string; email: string }): string {    // Hier sollte die Geschäftslogik zur Benutzererstellung stehen    return `Benutzer ${data.name} erstellt`;  }}

Jetzt kann jeder Dienst eine Nachricht mit dem Muster user.create an die Warteschlange user_queue senden und eine Antwort erhalten.

Kommunikation zwischen Diensten: synchron und asynchron

Synchron: gRPC

Für hochlastige Systeme, die strenge Typisierung und niedrige Latenz erfordern, verwenden Sie gRPC. Installieren Sie das Paket:

npm install @nestjs/microservices @grpc/grpc-js @grpc/proto-loader

Definieren Sie die .proto-Datei:

syntax = "proto3";package user;service UserService {  rpc GetUser (UserId) returns (User);}message UserId { int32 id = 1; }message User { string name = 1; string email = 2; }

Verwenden Sie im Controller den Decorator @GrpcMethod, um die Anfrage zu verarbeiten.

Asynchron: RabbitMQ