NestJS-இல் உள்ளமைந்த microservices ஆதரவு உள்ளது — இது HTTP-க்கு பதிலாக பல்வேறு transports (TCP, Redis, NATS, RabbitMQ, Kafka, gRPC) மீது தொடர்புகொள்ளும் ஒரு microservice ஆக இயங்க முடியும், ஒரு நிலையான, message-based programming model-ஐப் பயன்படுத்தி. அதே 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
}
}
இரண்டு தொடர்பு பாணிகள்: request-response-க்கான @MessagePattern (caller ஒரு result-க்காகக் காத்திருக்கிறது, RPC போல) மற்றும் events-க்கான @EventPattern (fire-and-forget, decoupled — publisher காத்திருப்பதில்லை).
@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 மூலம் configure செய்யப்பட்டது) மற்ற services-க்கு messages/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-இன் உள்ளமைந்த microservices ஆதரவு முக்கியமானது, ஏனெனில் HTTP-ஐ message-based transports-க்கு மாற்றும் அதே நேரத்தில் அதே பழக்கமான NestJS அமைப்பைப் (modules, providers, DI, decorators) பயன்படுத்தி distributed systems-ஐ உருவாக்க இது உங்களை அனுமதிக்கிறது — இது ஒரு பெரிய உற்பத்தித்திறன் மற்றும் நிலைத்தன்மை நன்மை.
Scalable systems-ஐ கட்டமைப்பதற்கு அதைப் புரிந்துகொள்வது முக்கியம்: message-pattern (request-response) vs event-pattern (fire-and-forget) வேறுபாடு அடிப்படை microservices தொடர்பு தேர்வுக்கு நேரடியாக மேப் செய்கிறது — synchronous RPC-style calls vs asynchronous, decoupled events (பிந்தையது, message brokers மூலம், microservices-ஐ வலுவாக்கும் resilience மற்றும் loose coupling-ஐ வழங்குகிறது).
Microservices-ஐ எப்படி உருவாக்குவது, message/event handlers-ஐ வரையறுப்பது, ClientProxy மூலம் மற்ற services-ஐ அழைப்பது, hybrid HTTP+microservice apps-ஐ உருவாக்குவது, மற்றும் transports-ஐ தேர்வுசெய்வது (lightweight pub/sub vs Kafka/RabbitMQ போன்ற durable queues vs high-performance gRPC) என அறிந்திருப்பது distributed back-ends-ஐ வடிவமைப்பதற்கான மதிப்புமிக்க senior-level அறிவாகும்.
Microservices உண்மையான சிக்கலைச் சேர்க்கின்றன (மேலும் monolith-க்கு மேல் எப்போதும் சரியான தேர்வாக இருப்பதில்லை) என்றாலும், NestJS implementation-ஐ சுத்தமாகவும் நிலையாகவும் ஆக்குகிறது, இது பெரிய அளவிலான, distributed NestJS systems-ஐ உருவாக்குவதற்கான ஒரு முக்கியமான கட்டிடக்கலை தலைப்பாக ஆக்குகிறது.