Kako NestJS podpira mikroservise?

Question

Accepted Answer

NestJS ima **vgrajeno podporo za mikroservise** — lahko deluje kot mikroservis, ki komunicira preko različnih **transportov** (TCP, Redis, NATS, RabbitMQ, Kafka, gRPC) namesto HTTP, z konsistentnim, sporočilno-orientiranim programskim modelom. Enaka NestJS struktura (moduli, storitve, DI) se ohrani; spreminjata se samo transport in sporočilni vzorci.

## Ustvarjanje mikroservisa

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

## Sporočilni vzorci vs vzorci dogodkov

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

Dva komunikacijska stila: **`@MessagePattern`** za zahtevo-odgovor (klicatelj čaka na rezultat, kot RPC) in **`@EventPattern`** za dogodke (izstreliti-in-pozabiti, nezavezujoče — objavljavec ne čaka).

## Klicanje drugega mikroservisa (odjemalec)

```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` (konfiguriran prek `ClientsModule`) pošilja sporočila/dogodke drugim storitvam — `send()` za zahtevo-odgovor, `emit()` za dogodke.

## Hibridne aplikacije

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

## Izbira transporta je wichtna

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

## Zakaj je to važno

Vgrajeno mikrostorivna podpora NestJS je pomembna, ker omogoča gradnjo distribuiranih sistemov z *isto* znano NestJS strukturo (moduli, ponudniki, DI, dekoratorji), medtem ko zamenjate HTTP za sporočilno-orientirane transporte — velika prednost v produktivnosti in konsistentnosti.

Razumevanje je pomembno za arhitekturo skalabilnih sistemov: **razlika med sporočilnim vzorcem (zahtevo-odgovor) in vzorcem dogodkov (izstreliti-in-pozabiti)** se neposredno preslika na temeljno izbiro komunikacije v mikroservisih — sinkrione RPC-slogove klice proti asinkronym, nezavezujočim dogodkom (slednji, prek sporočilnih posrednikov, zagotavljajo odpornost in ohlapno povezanost, ki naredita mikroservise trdne).

Znanje, kako ustvariti mikroservise, definirati upravljavce sporočil/dogodkov, klicati druge storitve prek `ClientProxy`, graditi hibridne HTTP+mikrostorivne aplikacije in izbirati transporte (lahke pub/sub proti trajnim čakalnikom, kot sta Kafka/RabbitMQ, proti visoko zmogljivemu gRPC) je dragoceno znanje vodilnega nivoja za oblikovanje distribuiranih hrbtnih delov.

Čeprav mikroservisi dodajajo pravo kompleksnost (in niso vedno prava izbira pred monolitom), NestJS naredi implementacijo čisto in konsistentno, kar naredi to važno arhitekturno temo za gradnjo velikih, distribuiranih NestJS sistemov.