Jak NestJS podporuje mikroslužby?

Question

Accepted Answer

NestJS má **vestavěnou podporu mikroslužeb** — může běžet jako mikroslužba, která komunikuje přes různé **transporty** (TCP, Redis, NATS, RabbitMQ, Kafka, gRPC) místo HTTP, přičemž používá konzistentní, založený na zprávách programovací model. Stejná struktura NestJS (moduly, služby, DI) se aplikuje; mění se pouze transport a message patterns.

## Vytvoření mikroslužby

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

Dva komunikační styly: **`@MessagePattern`** pro request-response (volající čeká na výsledek, jako RPC) a **`@EventPattern`** pro eventy (fire-and-forget, decoupled — vydavatel nečeká).

## Volání jiné mikroslužby (klient)

```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` (konfigurován přes `ClientsModule`) odesílá zprávy/eventy jiným službám — `send()` pro request-response, `emit()` pro eventy.

## Hybridní aplikace

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

## Volba transportu má značení

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

## Proč na tom záleží

Vestavěná podpora mikroslužeb NestJS je významná, protože vám umožňuje budovat distribuované systémy pomocí *stejné* známé struktury NestJS (moduly, poskytovatelé, DI, dekorátory), zatímco nahradíte HTTP zprávami založenými na zprávách — hlavní výhoda produktivity a konzistence.

Porozumění jí je důležité pro architektoniku škálovatelných systémů: **rozlišení message-pattern (request-response) vs event-pattern (fire-and-forget)** přímo mapuje na fundamentální volbu komunikace mikroslužeb — synchronní RPC-style volání versus asynchronní, decoupled eventy (ty prostřednictvím message brokerů poskytují odolnost a volné propojení, které činí mikroslužby robustními).

Vnímání, jak vytvářet mikroslužby, definovat message/event handlery, volat jiné služby přes `ClientProxy`, budovat hybridní HTTP+microservice aplikace a volit transporty (lightweight pub/sub vs trvanlivé fronty jako Kafka/RabbitMQ vs vysokovýkonné gRPC) je cenné znalosti na úrovni senior pro návrh distribuovaných back-endů.

Ačkoli mikroslužby přidávají skutečnou komplexnost (a ne vždy jsou správnou volbou oproti monolit), NestJS činí implementaci čistou a konzistentní, což z tohoto tématu činí důležité architektonické téma pro budování velkých, distribuovaných NestJS systémů.