Microservices en JavaScript : architecture et pratique pour Node.js

Microservices en JavaScript : architecture et pratique

L'architecture microservices (MSA) est devenue le standard de facto pour la construction d'applications complexes, évolutives et résilientes. Contrairement au monolithe, où tout le code est lié dans un seul processus, les microservices divisent le système en petits services indépendants. JavaScript, et plus particulièrement la plateforme Node.js, grâce à son modèle orienté événements et son vaste écosystème, est un excellent choix pour implémenter des microservices. Dans cet article, nous allons détailler les principes clés de l'architecture, écrire plusieurs services fonctionnels et examiner les aspects pratiques de leur interaction.

Principes fondamentaux de l'architecture microservices

Avant d'écrire du code, il est important de comprendre ce qui fait d'un microservice un "microservice". Les principes de base sont :

• Responsabilité unique (Single Responsibility) : Chaque service résout une tâche métier spécifique (par exemple, uniquement l'authentification ou uniquement la gestion des commandes).
• Indépendance : Les services sont développés, testés et déployés indépendamment les uns des autres.
• Isolation des données : Chaque service possède sa propre base de données. Il n'y a pas de référentiel commun.
• Couplage faible (Loose Coupling) : Les services communiquent via le réseau (API), et non par des appels de fonctions directs.
• Résilience : La défaillance d'un service ne doit pas faire tomber tout le système.

Node.js est idéal pour ces tâches grâce à sa nature non-bloquante et son asynchronisme, ce qui est crucial lorsqu'il y a un grand nombre d'appels réseau entre les services.

Pratique : Création de deux microservices simples

Écrivons deux services simples avec Express.js : User Service (gestion des utilisateurs) et Order Service (gestion des commandes).

1. User Service (service utilisateur)

Créez le fichier user-service/server.js :

const express = require('express');
const app = express();
app.use(express.json());

const users = [{ id: 1, name: 'Alice', email: 'alice@example.com' }];

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

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

2. Order Service (service de commandes)

Créez le fichier order-service/server.js :

const express = require('express');
const app = express();
app.use(express.json());

const orders = [
    { id: 1, userId: 1, product: 'Laptop', amount: 1500 }
];

app.get('/orders/user/:userId', (req, res) => {
    const userOrders = orders.filter(o => o.userId === parseInt(req.params.userId));
    res.json(userOrders);
});

app.listen(3002, () => console.log('Order Service running on port 3002'));

Nous avons maintenant deux services indépendants, fonctionnant sur des ports différents. C'est la base de l'architecture microservices.

Interaction entre les services : REST et Message Broker

Les services doivent communiquer. Examinons deux approches principales.

3.1 Interaction synchrone (API REST)

Un service appelle directement l'API d'un autre. Par exemple, pour obtenir les commandes avec le nom de l'utilisateur, créons une API Gateway ou un service compositeur.

// api-gateway.js
const axios = require('axios');

app.get('/users/:id/orders', async (req, res) => {
    try {
        const userResponse = await axios.get(`http://localhost:3001/users/${req.params.id}`);
        const ordersResponse = await axios.get(`http://localhost:3002/orders/user/${req.params.id}`);
        res.json({
            user: userResponse.data,
            orders: ordersResponse.data
        });
    } catch (error) {
        res.status(500).json({ error: 'Failed to fetch data' });
    }
});

3.2 Interaction asynchrone (Message Broker)

Pour un découplage plus fort, on utilise un courtier de messages (Message Broker) comme RabbitMQ ou Kafka. Les services publient des événements et s'abonnent à ceux des autres, sans se connaître directement.

// Exemple conceptuel avec un Event Bus
// Order Service publie un événement
eventBus.publish('order.created', { orderId: 123, userId: 1 });

// User Service écoute et met à jour ses données
eventBus.subscribe('order.created', (data) => {
    console.log(`Nouvelle commande de l'utilisateur ${data.userId}`);
});

L'interaction asynchrone améliore la résilience et l'évolutivité du système.

Conclusion

Les microservices avec JavaScript et Node.js offrent une flexibilité et une puissance énormes pour les systèmes modernes. Nous avons vu les principes de base, créé deux services simples et exploré les méthodes de communication. La prochaine étape consiste à ajouter la découverte de services, les API Gateways, la gestion des erreurs et le déploiement avec des conteneurs Docker.