NestJS బిల్ట్-ఇన్ మైక్రోసర్విసెస్ సపోర్ట్ ఉంది — ఇది HTTP కి బదులుగా వివిధ transports (TCP, Redis, NATS, RabbitMQ, Kafka, gRPC) లపై కమ్యూనికేట్ చేసే మైక్రోసర్విస్గా రన్ చేయవచ్చు, స్థిరమైన, సందేశ-ఆధారిత ప్రోగ్రామింగ్ మోడల్ను ఉపయోగిస్తుంది. ఒకే NestJS సంరचన (modules, services, DI) వర్తిస్తుంది; transport మరియు message patterns మాత్రమే మారుతాయి.
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
}
}
రెండు కమ్యూనికేషన్ స్టైల్లు: @MessagePattern request-response కోసం (కాలర్ ఫలితం కోసం ఎదురుచూస్తాడు, RPC వంటిది) మరియు @EventPattern events కోసం (fire-and-forget, decoupled — పబ్లిషర్ ఎదురుచూడదు).
@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);
}
}
ClientProxy (ClientsModule ద్వారా కాన్ఫిగర్ చేయబడింది) ఇతర సేవలకు సందేశలు/events పంపుతుంది — request-response కోసం send(), events కోసం emit().
// 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.
NestJS యొక్క బిల్ట్-ఇన్ మైక్రోసర్విసెస్ సపోర్ట్ ముఖ్యమైనది ఎందుకంటే ఇది మీకు HTTP కి బదులుగా సందేశ-ఆధారిత transports కి మారుతూ ఒకే సుపరిచితమైన NestJS సంరచన (modules, providers, DI, decorators) ఉపయోగించి వितరణ చేయబడిన సిస్టమ్లను నిర్మించడానికి అనుమతిస్తుంది — ఎక్కువ ఉత్పాదకత మరియు స్థిరత సమన్వయం.
avaliதું చేయడం స్కేలేబిల్ సిస్టమ్లను ఆర్కిటెక్చర్ చేయడానికి ముఖ్యమైనది: message-pattern (request-response) vs event-pattern (fire-and-forget) వ్యత్యాసం మూలాధార మైక్రోసర్విసెస్ కమ్యూనికేషన్ ఎంపికకు నేరుగా నిమిషమైనది — సింక్రోనస్ RPC-స్టైల్ కాల్లు వర్సెస్ అసింక్రోనస్, decoupled events (చివరటి, message brokers ద్వారా, నిస్సందేహమైన మైక్రోసర్విసెస్ను మరియు కఠినమైన చేయటానికి అందిస్తున్న దృఢత మరియు loose coupling ఏర్పాటు చేస్తుంది).
మైక్రోసర్విసెస్ సృష్టించడం, message/event handlers నిర్వచించడం, ClientProxy ద్వారా ఇతర సేవలకు కాల్ చేయడం, హైబ్రిడ్ HTTP+microservice apps నిర్మించడం, మరియు transports ఎంచుకోవడం (lightweight pub/sub వర్సెస్ durable queues కేవలం Kafka/RabbitMQ వర్సెస్ high-performance gRPC) విస్తృత-స్థాయి, వితరణ చేయబడిన back-ends రూపకల్పన చేయడానికి విలువైన సీనియర్-స్థాయి జ్ఞానం.
మైక్రోసర్విసెస్ నిజమైన సంక్లిష్టత జోడించినప్పటికీ (మరియు మోనోలిత్పై ఎల్లప్పుడూ సరైన ఎంపిక కాదు), NestJS అమలును శుభ్రంగా మరియు స్థిరంగా చేస్తుంది, ఇది విస్తృత-స్కేల్, వితరణ చేయబడిన NestJS సిస్టమ్లను నిర్మించడానికి ఒక ముఖ్యమైన ఆర్కిటెక్చరల్ విషయం.