¿Cómo NestJS soporta microservicios?

Question

Accepted Answer

NestJS tiene **soporte integrado para microservicios** — puede ejecutarse como un microservicio que se comunica por varios **transportes** (TCP, Redis, NATS, RabbitMQ, Kafka, gRPC) en lugar de HTTP, utilizando un modelo de programación consistente basado en mensajes. La misma estructura de NestJS (módulos, servicios, inyección de dependencias) se aplica; solo el transporte y los patrones de mensajes cambian.

## Creando un microservicio

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

## Patrones de mensaje vs patrones de eventos

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

Dos estilos de comunicación: **`@MessagePattern`** para request-response (el llamador espera un resultado, como RPC) y **`@EventPattern`** para eventos (disparar y olvidar, desacoplado — el publicador no espera).

## Llamando a otro microservicio (el 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);
  }
}
```

Un `ClientProxy` (configurado vía `ClientsModule`) envía mensajes/eventos a otros servicios — `send()` para request-response, `emit()` para eventos.

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

## La elección 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 qué es importante

El soporte integrado de microservicios de NestJS es significativo porque te permite construir sistemas distribuidos usando la *misma* estructura familiar de NestJS (módulos, proveedores, inyección de dependencias, decoradores) mientras cambias HTTP por transportes basados en mensajes — una gran ventaja en productividad y consistencia.

Entenderlo es importante para arquitectar sistemas escalables: la **distinción entre message-pattern (request-response) y event-pattern (disparar y olvidar)** se mapea directamente a la elección fundamental de comunicación en microservicios — llamadas síncronas estilo RPC versus eventos asíncronos y desacoplados (estos últimos, vía message brokers, proporcionando la resiliencia y el bajo acoplamiento que hacen los microservicios robustos).

Saber cómo crear microservicios, definir manejadores de mensajes/eventos, llamar a otros servicios vía `ClientProxy`, construir aplicaciones híbridas HTTP+microservicio, y elegir transportes (pub/sub ligero vs colas durables como Kafka/RabbitMQ vs gRPC de alto rendimiento) es conocimiento valioso de nivel senior para diseñar back-ends distribuidos.

Aunque los microservicios añaden complejidad real (y no siempre son la opción correcta sobre un monolito), NestJS hace la implementación limpia y consistente, haciendo este un tema arquitectónico importante para construir sistemas NestJS grandes y distribuidos.