A NestJS rendelkezik beépített mikroszolgáltatás-támogatással — képes mikroszolgáltatásként futni, amely különböző szállítókon keresztül kommunikál (TCP, Redis, NATS, RabbitMQ, Kafka, gRPC) HTTP helyett, egy konzisztens, üzenetalapú programozási modell használatával. Ugyanez a NestJS szerkezet (modulok, szolgáltatások, DI) érvényes; csak a szállító és az üzenetminták változnak meg.
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
}
}
Két kommunikációs stílus: @MessagePattern a kérés-válasz kommunikációhoz (a hívó vár az eredményre, mint az RPC) és @EventPattern az eseményekhez (tüzelés és elfelejtés, szétcsatolt — a közzétevő nem vár).
@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);
}
}
Egy ClientProxy (a ClientsModule segítségével konfigurálva) üzeneteket/eseményeket küld más szolgáltatásoknak — send() a kérés-válasz kommunikációhoz, emit() az eseményekhez.
// 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.
A NestJS beépített mikroszolgáltatás-támogatása azért jelentős, mert lehetővé teszi elosztott rendszerek építését ugyanazzal az ismert NestJS szerkezettel (modulok, szolgáltatók, DI, dekorátorok), miközben a HTTP helyett üzenetalapú szállítókat használ — jelentős produktivitás és konzisztencia előnyt jelent.
A megértése fontos a skálázható rendszerek architektúrájához: az üzenetminta (kérés-válasz) és az eseményminta (tüzelés és elfelejtés) megkülönböztetése közvetlenül leképződik a mikroszolgáltatások kommunikációjának alapvető választására — szinkron RPC-stílusú hívások versus aszinkron, szétcsatolt események (az utóbbi, üzenetközvetítőkön keresztül, a rugalmasságot és laza csatolást biztosítja, amely robusztussá teszi a mikroszolgáltatásokat).
Annak ismerete, hogy hogyan kell mikroszolgáltatásokat létrehozni, üzenet-/eseménykezelőket definiálni, más szolgáltatásokat a ClientProxy segítségével meghívni, hibrid HTTP+mikroszolgáltatás alkalmazásokat építeni, és szállítókat választani (könnyű pub/sub versus tartós várólisták, mint a Kafka/RabbitMQ, versus nagy teljesítményű gRPC) értékes senior szintű tudás az elosztott back-endek tervezéséhez.
Bár a mikroszolgáltatások valódi összetettséget jelentenek (és nem mindig jobb választás, mint egy monolitikus alkalmazás), a NestJS tiszta és konzisztens megvalósítást kínál, ami ezt egy fontos architekturális témává teszi a nagy méretű, elosztott NestJS rendszerek építéséhez.