Como o NestJS suporta microsserviços?

Question

Accepted Answer

O NestJS possui **suporte integrado para microsserviços** — ele pode ser executado como um microsserviço que se comunica por vários **transportes** (TCP, Redis, NATS, RabbitMQ, Kafka, gRPC) em vez de HTTP, usando um modelo de programação consistente baseado em mensagens. A mesma estrutura do NestJS (módulos, serviços, DI) se aplica; apenas o transporte e os padrões de mensagem mudam.

## Criando um microsserviço

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

## Padrões de mensagem vs padrões de evento

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

Dois estilos de comunicação: **`@MessagePattern`** para request-response (o chamador espera um resultado, como RPC) e **`@EventPattern`** para eventos (fire-and-forget, desacoplado — o publisher não espera).

## Chamando outro microsserviço (o cliente)

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

Um `ClientProxy` (configurado via `ClientsModule`) envia mensagens/eventos para outros serviços — `send()` para request-response, `emit()` para eventos.

## Aplicações híbridas

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

## A escolha de transporte importa

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

## Por que isso importa

O suporte integrado de microsserviços do NestJS é significativo porque permite construir sistemas distribuídos usando a *mesma* estrutura familiar do NestJS (módulos, providers, DI, decoradores) enquanto substitui HTTP por transportes baseados em mensagens — uma vantagem importante de produtividade e consistência.

Compreender isso é importante para arquitetar sistemas escaláveis: a **distinção entre message-pattern (request-response) e event-pattern (fire-and-forget)** mapeia diretamente para a escolha fundamental de comunicação em microsserviços — chamadas síncronas do tipo RPC versus eventos assíncronos e desacoplados (este último, através de message brokers, fornecendo a resiliência e acoplamento fraco que tornam os microsserviços robustos).

Saber como criar microsserviços, definir handlers de mensagem/evento, chamar outros serviços via `ClientProxy`, construir aplicações híbridas HTTP+microsserviço e escolher transportes (pub/sub leve vs filas duráveis como Kafka/RabbitMQ vs gRPC de alto desempenho) é conhecimento valioso de nível sênior para projetar back-ends distribuídos.

Embora microsserviços adicionem complexidade real (e nem sempre sejam a escolha correta sobre um monolito), o NestJS torna a implementação limpa e consistente, tornando este um tópico arquitetural importante para construir sistemas NestJS distribuídos em larga escala.