NestJS hat integrierte Microservices-Unterstützung — es kann als Microservice ausgeführt werden, der über verschiedene Transporte (TCP, Redis, NATS, RabbitMQ, Kafka, gRPC) statt HTTP kommuniziert und dabei ein konsistentes, nachrichtenbasiertes Programmiermodell verwendet. Die gleiche NestJS-Struktur (Module, Services, DI) gilt; nur der Transport und die Nachrichtenmuster ändern sich.
app = .(, {
: .,
: { : , : },
});
app.();
@Controller()
export class MathController {
// REQUEST-RESPONSE: respond to a message and RETURN a result (RPC-style)
@MessagePattern({ cmd: "sum" })
sum(data: number[]): number {
return data.reduce((a, b) => a + b, 0); // the caller awaits this result
}
// EVENT-BASED: react to an event, NO response expected (fire-and-forget)
@EventPattern("order_created")
handleOrderCreated(data: OrderDto) {
this.processOrder(data); // just react; nothing returned
}
}
Zwei Kommunikationsstile: @MessagePattern für Request-Response (der Aufrufer wartet auf ein Ergebnis, ähnlich wie RPC) und @EventPattern für Events (Fire-and-Forget, lose gekoppelt — der Publisher wartet nicht).
@Injectable()
export class AppService {
constructor(@Inject("MATH_SERVICE") private client: ClientProxy) {}
async getSum() {
// send() → request-response (returns an Observable of the result)
return this.client.send({ cmd: "sum" }, [1, 2, 3]);
// emit() → fire an event (no response)
this.client.emit("order_created", orderData);
}
}
Ein ClientProxy (konfiguriert über ClientsModule) sendet Nachrichten/Events an andere Services — send() für Request-Response, emit() für Events.
// an app can serve HTTP AND connect microservice transports simultaneously
const app = await NestFactory.create(AppModule);
app.connectMicroservice({ transport: Transport.RMQ, options: {...} });
await app.startAllMicroservices();
await app.listen(3000); // HTTP too
TCP → simple direct service-to-service
Redis/NATS → lightweight pub/sub messaging
RabbitMQ/Kafka → robust message queues/streams (durability, retries, decoupling)
gRPC → high-performance, strongly-typed RPC (protobuf)
→ Async message brokers (RMQ/Kafka) give decoupling & resilience; gRPC gives speed+typing.
Die integrierte Microservices-Unterstützung von NestJS ist bedeutsam, weil sie es dir ermöglicht, verteilte Systeme mit der gleichen vertrauten NestJS-Struktur (Module, Provider, DI, Decorators) zu bauen, während du HTTP gegen nachrichtenbasierte Transporte austauschst — ein großer Produktivitäts- und Konsistenzvorteil.
Das Verständnis ist wichtig für die Architektur skalierbarer Systeme: Die Unterscheidung zwischen Message-Pattern (Request-Response) vs Event-Pattern (Fire-and-Forget) entspricht direkt der grundlegenden Microservices-Kommunikationswahl — synchrone RPC-ähnliche Aufrufe versus asynchrone, lose gekoppelte Events (letztere über Message Broker, die Ausfallsicherheit und lose Kopplung bieten, die Microservices robust machen).
Zu wissen, wie man Microservices erstellt, Message/Event-Handler definiert, andere Services über ClientProxy aufruft, hybride HTTP+Microservice-Apps erstellt und Transporte auswählt (leichte Pub/Sub vs dauerhafte Queues wie Kafka/RabbitMQ vs High-Performance gRPC), ist wertvolles Senior-Level-Wissen für die Gestaltung verteilter Back-Ends.
While Microservices echte Komplexität hinzufügen (und nicht immer die richtige Wahl gegenüber einem Monolithen sind), macht NestJS die Implementierung sauber und konsistent, was dieses Thema für den Aufbau großer, verteilter NestJS-Systeme zu einem wichtigen Architekturthema macht.