Microservices en TypeScript : architecture et pratique

Introduction : Pourquoi TypeScript dans les microservices ?

L'architecture microservices est devenue la norme pour construire des applications évolutives et résilientes. Cependant, le choix du langage de programmation peut considérablement influencer la vitesse de développement et la qualité du code. TypeScript — un sur-ensemble de JavaScript strictement typé — offre un équilibre idéal entre flexibilité et fiabilité. Grâce au typage statique, aux interfaces et à un système de modules puissant, TypeScript permet de détecter les erreurs à la compilation plutôt qu'à l'exécution, ce qui est crucial pour les systèmes distribués.

Dans cet article, nous allons analyser les principes clés de la construction de microservices en TypeScript, examiner les frameworks populaires (NestJS, Fastify), la configuration de la communication inter-services via RabbitMQ, ainsi que la conteneurisation avec Docker. Tous les exemples de code seront présentés en TypeScript afin que vous puissiez les appliquer immédiatement dans vos projets.

1. Choix du framework : NestJS vs Fastify

Pour créer des microservices en TypeScript, plusieurs frameworks existent. Les deux plus populaires sont NestJS et Fastify. Examinons leurs caractéristiques.

NestJS — « Angular pour le backend »

NestJS propose une architecture modulaire, inspirée d'Angular. Il est livré avec une couche de transport prête à l'emploi pour les microservices (TCP, Redis, RabbitMQ, Kafka). C'est le choix idéal pour les grands projets où la structuration et le support par une équipe de développeurs sont importants.

// Exemple de microservice de base sur NestJSimport { NestFactory } from '@nestjs/core';import { Transport, MicroserviceOptions } from '@nestjs/microservices';import { AppModule } from './app.module';

async function bootstrap() {  const app = await NestFactory.createMicroservice<MicroserviceOptions>(    AppModule,    {      transport: Transport.RMQ,      options: {        urls: ['amqp://localhost:5672'],        queue: 'orders_queue',        queueOptions: { durable: false },      },    },  );  await app.listen();}bootstrap();

Fastify — performance et simplicité

Fastify est un framework HTTP ultra-rapide pour Node.js. Il n'offre pas de support intégré pour les microservices, mais s'intègre facilement avec RabbitMQ ou NATS via des packages séparés. Il convient aux cas où la performance est critique et où l'architecture est déjà définie.

// Exemple de serveur sur Fastify + TypeScriptimport fastify from 'fastify';

const server = fastify({ logger: true });

server.get('/health', async (request, reply) => {  return { status: 'OK', service: 'payment-service' };});

const start = async () => {  try {    await server.listen({ port: 3000 });  } catch (err) {    server.log.error(err);    process.exit(1);  }};start();

Conclusion : pour les débutants et les projets d'équipe, choisissez NestJS. Pour les systèmes à forte charge avec une architecture déjà bien pensée, optez pour Fastify.

2. Communication inter-services : RabbitMQ et Redis

Dans l'architecture microservices, les services communiquent entre eux via des courtiers de messages ou des requêtes HTTP directes. Examinons deux approches populaires.

RabbitMQ — file d'attente de messages fiable

RabbitMQ assure une transmission asynchrone des messages avec garantie de livraison. En TypeScript, on utilise souvent la bibliothèque amqplib ou les modules intégrés de NestJS pour travailler avec RabbitMQ.

// Publication d'un message dans RabbitMQ (TypeScript)import * as amqp from 'amqplib';

async function publishOrder(order: any) {  const connection = await amqp.connect('amqp://localhost');  const channel = await connection.createChannel();  const queue = 'orders';

  await channel.assertQueue(queue, { durable: true });  channel.sendToQueue(queue, Buffer.from(JSON.stringify(order)), {    persistent: true,  });

  console.log(`Order sent: ${order.id}`);  setTimeout(() => connection.close(), 500);}