NestJS microservices का समर्थन कैसे करता है?

Question

Accepted Answer

NestJS में **बिल्ट-इन microservices समर्थन** है — यह एक microservice के रूप में चल सकता है जो HTTP के बजाय विभिन्न **transports** (TCP, Redis, NATS, RabbitMQ, Kafka, gRPC) पर संवाद करता है, एक सुसंगत, message-आधारित programming model का उपयोग करते हुए। वही NestJS संरचना (modules, services, DI) लागू होती है; केवल transport और message patterns बदलते हैं।

## एक microservice बनाना

```ts
// a microservice listens on a transport instead of HTTP
const app = await NestFactory.createMicroservice(AppModule, {
  transport: Transport.TCP,             // or REDIS, NATS, RMQ, KAFKA, GRPC
  options: { host: "0.0.0.0", port: 3001 },
});
await app.listen();
```

## Message patterns बनाम event patterns

```ts
@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 परिणाम की प्रतीक्षा करता है, RPC की तरह) और events के लिए **`@EventPattern`** (fire-and-forget, decoupled — publisher प्रतीक्षा नहीं करता)।

## किसी दूसरे microservice को कॉल करना (client)

```ts
@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` के माध्यम से configured) अन्य services को messages/events भेजता है — request-response के लिए `send()`, events के लिए `emit()`।

## Hybrid applications

```ts
// 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
```

## Transport का चुनाव मायने रखता है

```text
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 समर्थन महत्वपूर्ण है क्योंकि यह आपको *उसी* परिचित NestJS संरचना (modules, providers, DI, decorators) का उपयोग करके distributed systems बनाने देता है, जबकि HTTP को message-आधारित transports से बदल देता है — एक बड़ा उत्पादकता और सुसंगतता लाभ।

इसे समझना scalable systems को architect करने के लिए महत्वपूर्ण है: **message-pattern (request-response) बनाम event-pattern (fire-and-forget) भेद** सीधे मौलिक microservices संवाद विकल्प से मेल खाता है — synchronous RPC-शैली calls बनाम asynchronous, decoupled events (बाद वाला, message brokers के माध्यम से, वह resilience और loose coupling प्रदान करता है जो microservices को मज़बूत बनाता है)।

Microservices कैसे बनाएँ, message/event handlers कैसे परिभाषित करें, `ClientProxy` के माध्यम से अन्य services को कैसे कॉल करें, hybrid HTTP+microservice apps कैसे बनाएँ, और transports कैसे चुनें (lightweight pub/sub बनाम Kafka/RabbitMQ जैसी durable queues बनाम high-performance gRPC) — यह जानना distributed back-ends डिज़ाइन करने के लिए मूल्यवान senior-स्तरीय ज्ञान है।

हालाँकि microservices असली जटिलता जोड़ते हैं (और monolith की तुलना में हमेशा सही विकल्प नहीं होते), NestJS implementation को स्वच्छ और सुसंगत बनाता है, जिससे यह बड़े पैमाने के, distributed NestJS systems बनाने के लिए एक महत्वपूर्ण architectural विषय बन जाता है।