Comment NestJS supporte-t-il les microservices ?

Question

Accepted Answer

NestJS a un **support des microservices intégré** — il peut s'exécuter en tant que microservice qui communique sur différents **transports** (TCP, Redis, NATS, RabbitMQ, Kafka, gRPC) au lieu de HTTP, en utilisant un modèle de programmation cohérent et basé sur les messages. La même structure NestJS (modules, services, DI) s'applique ; seuls le transport et les motifs de message changent.

## Créer un microservice

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

## Motifs de message vs motifs d'événement

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

Deux styles de communication : **`@MessagePattern`** pour requête-réponse (l'appelant attend un résultat, comme RPC) et **`@EventPattern`** pour les événements (déclencher et oublier, découplé — l'éditeur n'attend pas).

## Appeler un autre microservice (le client)

```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` (configuré via `ClientsModule`) envoie des messages/événements à d'autres services — `send()` pour requête-réponse, `emit()` pour les événements.

## Applications hybrides

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

## Le choix du transport compte

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

## Pourquoi c'est important

Le support des microservices intégré de NestJS est significatif car il vous permet de construire des systèmes distribués en utilisant la *même* structure NestJS familière (modules, providers, DI, décorateurs) tout en remplaçant HTTP par des transports basés sur les messages — un avantage majeur en termes de productivité et de cohérence.

Le comprendre est important pour architecting des systèmes scalables : la **distinction message-pattern (requête-réponse) vs event-pattern (déclencher et oublier)** se mappe directement au choix de communication fondamental des microservices — les appels synchrones de style RPC versus les événements asynchrones et découplés (ce dernier, via les courtiers de messages, fournissant la résilience et le couplage lâche qui rendent les microservices robustes).

Savoir comment créer des microservices, définir des gestionnaires de messages/événements, appeler d'autres services via `ClientProxy`, construire des apps hybrides HTTP+microservice, et choisir des transports (pub/sub léger vs files d'attente durables comme Kafka/RabbitMQ vs gRPC haute performance) est une connaissance précieuse de niveau senior pour concevoir des back-ends distribués.

Bien que les microservices ajoutent une vraie complexité (et ne sont pas toujours le bon choix par rapport à un monolithe), NestJS rend l'implémentation propre et cohérente, faisant de ce sujet un élément architectural important pour construire de grands systèmes NestJS distribués.