Mikroservices mit TypeScript: Architektur und Praxis

Einführung: Warum TypeScript in Microservices?

Die Microservice-Architektur ist zum Standard für die Erstellung skalierbarer und ausfallsicherer Anwendungen geworden. Die Wahl der Programmiersprache kann jedoch die Entwicklungsgeschwindigkeit und Codequalität erheblich beeinflussen. TypeScript – eine streng typisierte Obermenge von JavaScript – bietet eine ideale Balance zwischen Flexibilität und Zuverlässigkeit. Dank statischer Typisierung, Interfaces und einem leistungsstarken Modulsystem ermöglicht TypeScript die Fehlererkennung bereits zur Kompilierzeit und nicht erst zur Laufzeit, was für verteilte Systeme entscheidend ist.

In diesem Artikel behandeln wir die wichtigsten Prinzipien der Erstellung von Microservices mit TypeScript, betrachten beliebte Frameworks (NestJS, Fastify), die Einrichtung der serviceübergreifenden Kommunikation über RabbitMQ sowie die Containerisierung mit Docker. Alle Codebeispiele werden in TypeScript präsentiert, damit Sie sie sofort in Ihren Projekten anwenden können.

1. Framework-Wahl: NestJS vs Fastify

Für die Erstellung von Microservices mit TypeScript gibt es mehrere Frameworks. Die beiden bekanntesten sind NestJS und Fastify. Betrachten wir ihre Besonderheiten.

NestJS – „Angular für das Backend“

NestJS bietet eine modulare Architektur, die von Angular inspiriert ist. Es wird mit einer fertigen Transportschicht für Microservices ausgeliefert (TCP, Redis, RabbitMQ, Kafka). Dies ist die ideale Wahl für große Projekte, bei denen Strukturiertheit und Teamunterstützung wichtig sind.

// Beispiel eines einfachen Microservices mit NestJSimport { NestFactory } from '@nestjs/core';import { Transport, MicroserviceOptions } 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: 'orders_queue',        queueOptions: { durable: false },      },    },  );  await app.listen();}bootstrap();

Fastify – Leistung und Einfachheit

Fastify ist ein extrem schnelles HTTP-Framework für Node.js. Es bietet keine integrierte Microservice-Unterstützung, lässt sich aber leicht über separate Pakete mit RabbitMQ oder NATS integrieren. Es eignet sich für Fälle, in denen die Leistung entscheidend ist und die Architektur bereits festgelegt wurde.

// Beispiel eines Servers mit Fastify + TypeScriptimport fastify from 'fastify';

const server = fastify({ logger: true });

server.get('/health', async (request, reply) => {  return { status: 'OK', service: 'payment-service' };});

const start = async () => {  try {    await server.listen({ port: 3000 });  } catch (err) {    server.log.error(err);    process.exit(1);  }};start();

Fazit: Für Einsteiger und Teamprojekte wählen Sie NestJS. Für hochlastige Systeme mit bereits durchdachter Architektur – Fastify.

2. Serviceübergreifende Kommunikation: RabbitMQ und Redis

In einer Microservice-Architektur kommunizieren Dienste über Message Broker oder direkte HTTP-Anfragen miteinander. Betrachten wir zwei gängige Ansätze.

RabbitMQ – Zuverlässige Message Queue

RabbitMQ gewährleistet die asynchrone Nachrichtenübertragung mit Zustellungsgarantie. In TypeScript wird für die Arbeit mit RabbitMQ häufig die Bibliothek amqplib oder die integrierten Module von NestJS verwendet.

// Veröffentlichen einer Nachricht in RabbitMQ (TypeScript)import * as amqp from 'amqplib';

async function publishOrder(order: any) {  const connection = await amqp.connect('amqp://localhost');  const channel = await connection.createChannel();  const queue = 'orders';

  await channel.assertQueue(queue, { durable: true });  channel.sendToQueue(queue, Buffer.from(JSON.stringify(order)), {    persistent: true,  });

  console.log(`Order sent: ${order.id}`);  setTimeout(() => connection.close(), 500)