Kako NestJS podržava mikroservise?

Question

Accepted Answer

NestJS ima **ugrađenu podršku za mikroservise** — može se pokrenuti kao mikroservis koji komunicira preko različitih **prijenosnika** (TCP, Redis, NATS, RabbitMQ, Kafka, gRPC) umjesto HTTP-a, koristeći dosljedan, model zasnovan na porukama. Ista NestJS struktura (moduli, servisi, DI) se primjenjuje; mijenjaju se samo prijenosnik i obrasci poruka.

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

## Obrasci poruka nasuprot obrascima događaja

```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 stila komunikacije: **`@MessagePattern`** za zahtjev-odgovor (pozivač čeka rezultat, poput RPC-a) i **`@EventPattern`** za događaje (ispaliti-i-zaboraviti, odvajajući — izdavač ne čeka).

## Pozivanje drugog mikroservisa (klijent)

```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 kroz `ClientsModule`) šalje poruke/događaje drugim servisima — `send()` za zahtjev-odgovor, `emit()` za događaje.

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

## Izbor prijenosnika je važan

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

## Zašto je to važno

Ugrađena podrška NestJS-a za mikroservise je značajna jer vam omogućava da gradite distribuirane sustave koristeći *istu* poznatou NestJS strukturu (moduli, pružatelji, DI, dekoratori) dok zamjenjujete HTTP s prijenosnicima zasnovanim na porukama — velika prednost u produktivnosti i konzistentnosti.

Razumijevanje je važno za arhitekturiranje skalabilnih sustava: **razlika između message-pattern (zahtjev-odgovor) i event-pattern (ispaliti-i-zaboraviti)** izravno se mapira na temeljni izbor komunikacije u mikroservisima — sinkroni RPC-stil poziva nasuprot asinkroni, odvajajućim događajima (potonji, kroz poruke brokera, pružajući otpornost i labavo spajanje koja čine mikroservise robusnim).

Znanje kako kreirati mikroservise, definirati rukovalce poruka/događaja, pozivati druge servise kroz `ClientProxy`, graditi hibridne HTTP+mikroservis aplikacije, i odabrati prijenosnike (lagani pub/sub nasuprot trajne redove kao što su Kafka/RabbitMQ nasuprot visokoperformantan gRPC) je dragocjeno znanje na vinoj razini za dizajniranje distribuiranih back-enda.

Mada mikroservisi dodaju pravu kompleksnost (i nisu uvijek pravi izbor umjesto monolita), NestJS čini implementaciju čistom i dosljednom, čineći ovo važnom arhitekturnom temom za izgradnju velikih, distribuiranih NestJS sustava.