Kaip NestJS palaiko mikrotarnybas?

Question

Accepted Answer

NestJS turi **integruotą mikrotarnybų palaikymą** — jis gali veikti kaip mikrotarnyba, kuri komunikuoja per įvairius **transportus** (TCP, Redis, NATS, RabbitMQ, Kafka, gRPC) vietoje HTTP, naudodama nuoseklų, žinučių pagrindu pagrįstą programavimo modelį. Ta pati NestJS struktūra (moduliai, paslaugos, DI) taikoma; keičiasi tik transportas ir žinučių šablonai.

## Mikrotarnybos kūrimas

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

## Žinučių šablonai vs įvykių šablonai

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

Dvi komunikacijos stiliai: **`@MessagePattern`** prašymui-atsakymui (skambintojui laukti rezultato, kaip RPC) ir **`@EventPattern`** įvykiams (paleisti ir pamiršti, atsietos — leidėjas nelaukia).

## Kitos mikrotarnybos iškvieitimas (klienatas)

```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` (sukonfigūruota per `ClientsModule`) siunčia žinutes/įvykius į kitas paslaugas — `send()` prašymui-atsakymui, `emit()` įvykiams.

## Hibridinės aplikacijos

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

## Transporto pasirinkimas svarbus

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

## Kodėl tai svarbu

NestJS integruotas mikrotarnybų palaikymas yra svarbus, nes leidžia kurti paskirstytas sistemas naudojant *tą pačią* žinomą NestJS struktūrą (moduliai, teikėjai, DI, dekoratoriai), keičiant HTTP į žinučių pagrindu pagrįstus transportus — tai yra didelis produktyvumo ir nuoseklumo pranašumas.

Supratimas apie tai yra svarbus dėl skalabilių sistemų architektūros: **žinučių šablono (prašymas-atsakymas) vs įvykio šablono (paleisti ir pamiršti) skirtumas** tiesiogiai atitinka pagrindinį mikrotarnybų komunikacijos pasirinkimą — sinchroninius RPC stiliaus skambučius verus asinchroninius, atsietuosius įvykius (pastarieji, naudojant žinučių brokerius, suteikia atsparumą ir laisvą sujungimą, kurie padaro mikrotarnyba patvarią).

Žinojimas, kaip kurti mikrotarnybes, apibrėžti žinučių/įvykių tvarkytuvus, iškviesti kitas paslaugas per `ClientProxy`, kurti hibridines HTTP+mikrotarnybų aplikacijas ir pasirinkti transportus (lengvi pub/sub vs ilgalaikės eilės, tokios kaip Kafka/RabbitMQ, vs aukšto našumo gRPC) yra vertingas aukščiausios lygio žinojimas paskirstytų galinių dalių projektavimui.

Nors mikrotarnybos prideda tikrą sudėtingumą (ir ne visada yra geriau nei monolitas), NestJS daro implementaciją švaria ir nuoseklia, todėl tai yra svarbi architektūrinė tema didinės apimties, paskirstytų NestJS sistemų kūrimui.