Microservices en JavaScript : architecture et pratique de A à Z

Introduction à l'architecture microservices en JavaScript

L'architecture microservices est une approche de développement logiciel où l'application est construite comme un ensemble de petits services déployables indépendamment. Chaque service implémente une fonction métier unique et interagit avec les autres via des protocoles légers (généralement HTTP/REST ou files de messages). JavaScript, et plus particulièrement l'environnement d'exécution Node.js, est idéal pour créer des microservices grâce à son modèle d'E/S asynchrone, son vaste écosystème de packages (npm) et sa rapidité de développement.

Dans cet article, nous analyserons les aspects clés de la création de microservices en JavaScript : de la conception de l'architecture au déploiement dans des conteneurs. Vous apprendrez à organiser l'échange de données, à assurer la tolérance aux pannes et à tester un système distribué.

1. Conception de l'architecture des microservices

La première étape est la décomposition de l'application monolithique en services. Chaque microservice doit posséder sa propre base de données (database per service) et être totalement autonome. Prenons l'exemple d'une boutique en ligne :

• Service Users — inscription, authentification, profils.
• Service Products — catalogue de produits, prix, stocks.
• Service Orders — création et traitement des commandes.
• Service Payments — intégration avec les passerelles de paiement.
• Service Notifications — envoi d'emails/SMS.

Pour l'interaction entre les services, nous utilisons deux approches : synchrone (REST/gRPC) pour les requêtes nécessitant une réponse immédiate, et asynchrone (files de messages) pour les événements qui ne nécessitent pas de blocage.

2. Création d'un microservice avec Node.js et Express

Commençons par un microservice simple pour la gestion des utilisateurs. Installons Express et la bibliothèque pour travailler avec UUID :

npm init -ynpm install express uuid

Créons le fichier users-service.js :

const express = require('express');const { v4: uuidv4 } = require('uuid');const app = express();app.use(express.json());

const users = [];

// Création d'un utilisateurapp.post('/users', (req, res) => {    const { name, email } = req.body;    const user = { id: uuidv4(), name, email };    users.push(user);    res.status(201).json(user);});

// Obtention de la liste des utilisateursapp.get('/users', (req, res) => {    res.json(users);});

// Obtention d'un utilisateur par IDapp.get('/users/:id', (req, res) => {    const user = users.find(u => u.id === req.params.id);    if (!user) return res.status(404).json({ error: 'User not found' });    res.json(user);});

app.listen(3001, () => console.log('Users service running on port 3001'));

Lancez le service : node users-service.js. Vous avez maintenant un microservice fonctionnel avec une API REST. Les services pour les produits et les commandes sont créés de la même manière (sur les ports 3002 et 3003 respectivement).

3. Interaction asynchrone via RabbitMQ

Pour les événements tels que "commande créée" ou "utilisateur inscrit", nous utilisons des files de messages. Installons le client pour RabbitMQ :

npm install amqplib

Créons un utilitaire pour publier des messages (event-bus.js) :

const amqp = require('amqplib');let channel;

async function connect() {    const connection = await amqp.connect('amqp://localhost');    channel = await connection.createChannel();    await channel.assertExchange('order_events', 'topic', { durable: true });}

async function publishEvent(routingKey, data) {    if (!channel) await connect();    channel.publish('order_events', routingKey, Buffer.from(JSON.stringify(data)));    console.log(`Event published: ${routingKey}`);}

module.exports = { publishEvent };

Maintenant, dans le service de commandes (orders-service.js), lors de la création d'une commande, publiez