Microservices en JavaScript : architecture et pratique de A à Z

Introduction : Pourquoi les microservices en JavaScript ?

Le développement web moderne s'éloigne de plus en plus des applications monolithiques au profit de l'architecture microservices. JavaScript, et plus précisément son environnement serveur Node.js, est idéal pour construire des microservices grâce à son asynchronisme, son modèle orienté événements et son immense écosystème communautaire. Dans cet article, nous allons voir comment concevoir, développer et déployer des microservices en JavaScript — de la théorie aux exemples pratiques de code.

1. Fondamentaux de l'architecture microservices

L'architecture microservices est une approche où l'application est divisée en petits services indépendants. Chaque service est responsable de sa propre logique métier, possède son propre stockage de données et peut être déployé, mis à l'échelle et mis à jour séparément.

Avantages des microservices avec Node.js

\n
• Évolutivité : Node.js gère facilement des milliers de connexions simultanées grâce aux entrées-sorties non bloquantes.
\n
• Prototypage rapide : Les paquets npm et frameworks (Express, Fastify, NestJS) permettent de créer rapidement des API REST/GraphQL.
\n
• Isolation des erreurs : Une panne dans un service ne paralyse pas toute l'application.
\n
• Flexibilité technologique : Différents services peuvent utiliser différentes versions de Node.js ou même différents langages.
\n

Composants clés

\n
• API Gateway — point d'entrée unique qui achemine les requêtes vers les services appropriés.
\n
• Courtier de messages (RabbitMQ, Redis, Kafka) — pour l'échange asynchrone de données.
\n
• Registre de services (Consul, etcd) — pour la découverte de services.
\n
• Conteneurisation (Docker, Kubernetes) — pour standardiser l'environnement.
\n

2. Pratique : Création de deux microservices

Analysons un exemple de système de commandes. Nous aurons deux microservices : user-service (gestion des utilisateurs) et order-service (gestion des commandes). Ils communiqueront via REST API et de manière asynchrone via RabbitMQ.

2.1. Service de base avec Express

Commençons par user-service. Installez les dépendances :

npm init -y\nnpm install express body-parser

Créez le fichier index.js :

const express = require('express');\nconst bodyParser = require('body-parser');\nconst app = express();\nconst PORT = process.env.PORT || 3001;\n\napp.use(bodyParser.json());\n\nconst users = [];\n\napp.post('/users', (req, res) => {\n    const { name, email } = req.body;\n    const user = { id: users.length + 1, name, email };\n    users.push(user);\n    res.status(201).json(user);\n});\n\napp.get('/users/:id', (req, res) => {\n    const user = users.find(u => u.id === parseInt(req.params.id));\n    if (!user) return res.status(404).json({ error: 'User not found' });\n    res.json(user);\n});\n\napp.listen(PORT, () => {\n    console.log(`User service running on port ${PORT}`);\n});

Créez de même order-service sur le port 3002. Il contiendra un tableau de commandes et deux endpoints : POST /orders et GET /orders/:id.

2.2. API Gateway

Créons une passerelle simple sur le port 3000, qui redirige les requêtes en fonction du chemin :

const express = require('express');\nconst httpProxy = require('http-proxy-middleware');\nconst app = express();\n\napp.use('/users', httpProxy.createProxyMiddleware({ target: 'http://localhost:3001', changeOrigin: true }));\napp.use('/orders', httpProxy.createProxyMiddleware({ target: 'http://localhost:3002', changeOrigin: true }));\n\napp.listen(3000, () => console.log('API Gateway on port 3000'));

Désormais, toutes les requêtes vers /users vont au user-service, et celles vers /orders au order-service.

2.3. Interaction asynchrone avec RabbitMQ

Supposons que lors de la création d'une commande, nous devions vérifier l'utilisateur. Au lieu d'un appel synchrone, nous pouvons utiliser RabbitMQ pour une communication asynchrone. Installez le client :

npm install amqplib

Dans order-service, après avoir créé une commande, publiez un message dans la file d'attente order_created :

const amqp = require('amqplib');\n\nasync function publishOrderCreated(order) {\n    const connection = await amqp.connect('amqp://localhost');\n    const channel = await connection.createChannel();\n    await channel.assertQueue('order_created');\n    channel.sendToQueue('order_created', Buffer.from(JSON.stringify(order)));\n    console.log('Order created message sent');\n}

Dans user-service, écoutez cette file d'attente et mettez à jour les données utilisateur si nécessaire :

async function consumeOrderCreated() {\n    const connection = await amqp.connect('amqp://localhost');\n    const channel = await connection.createChannel();\n    await channel.assertQueue('order_created');\n    channel.consume('order_created', (msg) => {\n        const order = JSON.parse(msg.content.toString());\n        console.log('Received order:', order);\n        // Logique de mise à jour utilisateur\n        channel.ack(msg);\n    });\n}

Ainsi, les services fonctionnent de manière asynchrone, améliorant la tolérance aux pannes et l'évolutivité.

3. Conteneurisation avec Docker

Pour faciliter le déploiement, conteneurisons chaque service. Créez un Dockerfile pour user-service :

FROM node:18-alpine\nWORKDIR /app\nCOPY package*.json ./\nRUN npm install\nCOPY . .\nEXPOSE 3001\nCMD ["node", "index.js"]

Créez un fichier docker-compose.yml pour orchestrer tous les services :

version: '3.8'\nservices:\n  user-service:\n    build: ./user-service\n    ports:\n      - "3001:3001"\n  order-service:\n    build: ./order-service\n    ports:\n      - "3002:3002"\n  gateway:\n    build: ./gateway\n    ports:\n      - "3000:3000"\n    depends_on:\n      - user-service\n      - order-service\n  rabbitmq:\n    image: rabbitmq:3-management\n    ports:\n      - "5672:5672"\n      - "15672:15672"

Exécutez docker-compose up — tous les services démarreront dans des conteneurs isolés.

4. Surveillance et journalisation

Dans un environnement de microservices, la surveillance est cruciale. Utilisez des outils comme Prometheus pour les métriques et ELK Stack (Elasticsearch, Logstash, Kibana) pour la journalisation centralisée. Ajoutez une journalisation structurée dans chaque service :

const pino = require('pino');\nconst logger = pino({ level: process.env.LOG_LEVEL || 'info' });\n\napp.get('/users/:id', (req, res) => {\n    logger.info({ userId: req.params.id }, 'Fetching user');\n    // ...\n});

Collectez les journaux via Logstash et visualisez-les dans Kibana.

Conclusion

Les microservices en JavaScript (Node.js) offrent une flexibilité, une évolutivité et une résilience énormes. En utilisant API Gateway, RabbitMQ, Docker et des outils de surveillance, vous pouvez construire des systèmes robustes et faciles à maintenir. Commencez petit, décomposez progressivement votre monolithe et profitez de la puissance de l'architecture microservices !