NestJS માइक્રોસર્વિસીસને કેવી રીતે સમર્થન આપે છે?

Question

Accepted Answer

NestJS માં **બિલ્ટ-ઇન માइક્રોસર્વિસીસ સપોર્ટ** છે — તે એક માइક્રોસર્વિસ તરીકે ચલાવી શકે છે જે વિવિધ **ટ્રાન્સપોર્ટ્સ** (TCP, Redis, NATS, RabbitMQ, Kafka, gRPC) પર HTTP ને બદલે સંચાર કરે છે, સુસંગત, સંદેશ-આધારિત પ્રોગ્રામિંગ મોડેલ વાપરીને. એક જ NestJS સ્ટ્રક્ચર (મોડ્યુલ્સ, સર્વિસીસ, DI) લાગુ થાય છે; ફક્ત ટ્રાન્સપોર્ટ અને સંદેશ પેટર્ન બદલાય છે.

## માइક્રોસર્વિસ બનાવવું

```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();
```

## સંદેશ પેટર્ન્સ વર્સ ઇવેન્ટ પેટર્ન્સ

```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
  }
}
```

દુઃ સંચાર શૈલીઓ: **`@MessagePattern`** વિનંતી-પ્રતિસાદ માટે (કોલર પરિણામની રાહ જોય છે, RPC જેવું) અને **`@EventPattern`** ઇવેન્ટ્સ માટે (ફાયર-અને-ભૂલી, અલગ-થપ્પો — પ્રકાશક રાહ જતો નથી).

## બીજી માइક્રોસર્વિસને કોલ કરવું (ક્લાયન્ટ)

```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` દ્વારા કૉન્ફિગર કરવામાં આવે છે) અન્ય સેવાઓને સંદેશ/ઇવેન્ટ્સ મોકલે છે — વિનંતી-પ્રતિસાદ માટે `send()`, ઇવેન્ટ્સ માટે `emit()`.

## હાઇબ્રિડ એપ્લિકેશનો

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

## ટ્રાન્સપોર્ટ પસંદગી મહત્વપૂર્ણ છે

```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 માટે બિલ્ટ-ઇન માइક્રોસર્વિસીસ સપોર્ટ નોંધણીય છે કારણ કે તે તમને HTTP ને સંદેશ-આધારિત ટ્રાન્સપોર્ટ માટે સ્વેપ કરીને એક જ પરિચિત NestJS સ્ટ્રક્ચર (મોડ્યુલ્સ, પ્રોવાઇડર્સ, DI, ડેકોરેટર્સ) વાપરીને વિતરિત સિસ્ટમો બનાવવા દે છે — એક મોટો ઉત્પાદકતા અને સુસંગતતા લાભ.
	ેની સમજ માપક્રમ પ્રણાલીઓ બનાવવા માટે મહત્વપૂર્ણ છે: **સંદેશ-પેટર્ન (વિનંતી-પ્રતિસાદ) વર્સ ઇવેન્ટ-પેટર્ન (ફાયર-અને-ભૂલી) તફાવત** સીધું માઈક્રોસર્વિસીસ સંચાર પસંદગીમાં મેપ કરે છે — સુસંગત RPC-સ્ટાઈલ કોલ્સ વર્સ અસુસંગત, અલગ-થપ્પો ઈવેન્ટ્સ (પછીનું, સંદેશ બ્રોકર્સ દ્વારા, સ્થિતિસ્થાપકતા અને લુઝ કપલિંગ પ્રદાન કરે છે જે માઈક્રોસર્વિસીસને મજબૂત બનાવે છે).

માઈક્રોસર્વિસીસ કેવી રીતે બનાવવી, સંદેશ/ઈવેન્ટ હેન્ડલર્સ વ્યાખ્યાયિત કરવી, `ClientProxy` દ્વારા અન્ય સેવાઓને કોલ કરવી, HTTP+માઈક્રોસર્વિસ હાઇબ્રિડ એપ્લિકેશનો બનાવવી, અને ટ્રાન્સપોર્ટ્સ પસંદ કરવી (હલકા pub/sub વર્સ ટકાઉ કતારો જેમ Kafka/RabbitMQ વર્સ ઉચ્ચ-પ્રદર્શન gRPC) જાણવું વરિષ્ઠ-સ્તરના જ્ઞાન માટે મૂલ્યવાન છે વિતરિત બેક-એન્ડ્સ ડિઝાઈન કરવા માટે.

જ્યારે માઈક્રોસર્વિસીસ વાસ્તવિક જટિલતા ઉમેરે છે (અને મોનોલીથ પર હમેશા સાચી પસંદ નથી), NestJS અમલીકરણને સ્વચ્છ અને સુસંગત બનાવે છે, આને બڑા-સ્કેલ, વિતરિત NestJS સિસ્ટમો બનાવવા માટે એક મહત્વપૂર્ણ આર્કિટેક્ચરલ વિષય બનાવે છે.