NestJS ha supporto integrato per microservizi — può essere eseguito come microservizio che comunica attraverso vari transport (TCP, Redis, NATS, RabbitMQ, Kafka, gRPC) invece di HTTP, utilizzando un modello di programmazione coerente e basato su messaggi. La stessa struttura NestJS (moduli, servizi, DI) si applica; solo il transport e i message pattern cambiano.
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
}
}
Due stili di comunicazione: @MessagePattern per request-response (il chiamante attende un risultato, come RPC) e @EventPattern per eventi (fire-and-forget, disaccoppiati — l'editore non attende).
@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);
}
}
Un ClientProxy (configurato via ClientsModule) invia messaggi/eventi ad altri servizi — send() per request-response, emit() per eventi.
// 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.
Il supporto integrato per microservizi di NestJS è significativo perché consente di costruire sistemi distribuiti utilizzando la stessa struttura NestJS familiare (moduli, provider, DI, decorator) mentre si sostituisce HTTP con transport basati su messaggi — un grande vantaggio di produttività e coerenza.
Comprendere questo è importante per progettare sistemi scalabili: la distinzione message-pattern (request-response) vs event-pattern (fire-and-forget) corrisponde direttamente alla scelta fondamentale di comunicazione nei microservizi — chiamate sincrone in stile RPC versus eventi asincroni e disaccoppiati (questi ultimi, attraverso message broker, fornendo la resilienza e l'accoppiamento loose che rendono i microservizi robusti).
Sapere come creare microservizi, definire handler di messaggi/eventi, chiamare altri servizi tramite ClientProxy, costruire app ibride HTTP+microservice, e scegliere transport (pub/sub leggero vs code durature come Kafka/RabbitMQ vs gRPC ad alte prestazioni) è una conoscenza preziosa a livello senior per progettare back-end distribuiti.
Mentre i microservizi aggiungono una vera complessità (e non sono sempre la scelta giusta rispetto a un monolite), NestJS rende l'implementazione pulita e coerente, rendendo questo un argomento architetturale importante per costruire sistemi NestJS distribuiti e su larga scala.