Microservices avec Node.js

Microservices avec Node.js

Pourquoi Microservices avec Node.js ?

Contexte réel : pourquoi un dev a besoin de ca au quotidien

Les architectures monolithiques ont des avantages, mais elles présentent aussi plusieurs inconvénients. Elles sont difficiles à mettre à l'échelle, à maintenir et à évoluer. Les microservices permettent une architecture plus modulaire et flexible, facilitant ainsi le développement et la gestion de grands systèmes.

Un cas d'usage concret en 2-3 phrases

Imaginez que vous développez un e-commerce. Si tout est dans un seul monolith, chaque modification peut affecter l'ensemble de l'application, ce qui augmente le risque de bugs. Avec des microservices, chaque service (comme la gestion des produits, les paiements et l'authentification) peut être mis à jour indépendamment.

Prerequis

• Connaissance avancée de JavaScript et Node.js
• Familiarité avec les concepts de bases : Asynchronisme, Promises, Async/Await.
• Compréhension des structures de données et algorithmes
• Docker pour le déploiement
• Git pour le contrôle de version

Concepts fondamentaux

1. Architecture Microservices

Les microservices sont des applications distribuées qui s'exécutent indépendamment et communiquent entre eux via une API RESTful ou gRPC.

Schema mental :

+-------------------+
| Service A         |
+---------+---------+
          |
          v
+---------+---------+
| Service B         |
+---------+---------+
          |
          v
+---------+---------+
| Service C         |
+-------------------+

Code fonctionnel :

// app.js
const express = require('express');
const bodyParser = require('body-parser');

const app = express();
app.use(bodyParser.json());

app.get('/api', (req, res) => {
  res.send('Hello from Microservices!');
});

app.listen(3000, () => {
  console.log('Microservice running on port 3000');
});

2. Communication entre Microservices

Les microservices communiquent généralement via des appels HTTP/HTTPS.

Schema mental :

+-------------------+
| Service A         |
+---------+---------+
          | HTTP GET
          v
+---------+---------+
| Service B         |
+---------+---------+

Code fonctionnel :

// serviceA.js
const axios = require('axios');

async function fetchDataFromServiceB() {
  try {
    const response = await axios.get('http://service-b:3001/api');
    console.log(response.data);
  } catch (error) {
    console.error(error);
  }
}

fetchDataFromServiceB();

3. Orchestration

L'orchestration des microservices gère la communication et l'équilibre de charge entre eux.

Schema mental :

+-------------------+
| Service A         |
+---------+---------+
          | HTTP GET
          v
+---------+---------+
| Load Balancer     |
+---------+---------+
          | HTTP GET
          v
+---------+---------+
| Service B         |
+---------+---------+

Code fonctionnel :

// load-balancer.js
const axios = require('axios');

async function routeRequestToServiceB() {
  try {
    const response = await axios.get('http://service-b:3001/api');
    return response.data;
  } catch (error) {
    console.error(error);
  }
}

routeRequestToServiceB();

4. Déploiement

Le déploiement des microservices doit être automatisé et scalable.

Schema mental :

+-------------------+
| CI/CD Pipeline    |
+---------+---------+
          | Docker Build
          v
+---------+---------+
| Kubernetes        |
+---------+---------+
          | Deploy
          v
+---------+---------+
| Service A         |
+---------+---------+
          | HTTP GET
          v
+---------+---------+
| Service B         |
+-------------------+

Code fonctionnel :

## Dockerfile pour un service
FROM node:14

WORKDIR /usr/src/app
COPY package*.json ./
RUN npm install
COPY . .
CMD ["node", "app.js"]

Mise en pratique : projet fil rouge

Construisons UN mini-projet complet et réaliste : Un gestionnaire de tâches

Étape 1 : Création du projet

mkdir todo-app
cd todo-app
npm init -y
npm install express body-parser mongoose

Structure des fichiers :

todo-app/
├── package.json
├── server.js
└── models/
    └── Task.js

Code de server.js :

// server.js
const express = require('express');
const bodyParser = require('body-parser');
const mongoose = require('mongoose');

const app = express();
app.use(bodyParser.json());

// Connexion à la base de données MongoDB
mongoose.connect('mongodb://localhost:27017/todo', {
  useNewUrlParser: true,
  useUnifiedTopology: true
});

// Modèle de tâche
const Task = mongoose.model('Task', new mongoose.Schema({
  title: String,
  completed: Boolean
}));

// Route pour créer une tâche
app.post('/tasks', async (req, res) => {
  const task = new Task(req.body);
  await task.save();
  res.status(201).send(task);
});

// Route pour récupérer toutes les tâches
app.get('/tasks', async (req, res) => {
  const tasks = await Task.find({});
  res.send(tasks);
});

app.listen(3000, () => {
  console.log('Todo App running on port 3000');
});

Code de models/Task.js :

// models/Task.js
const mongoose = require('mongoose');

module.exports = mongoose.model('Task', new mongoose.Schema({
  title: String,
  completed: Boolean
}));

Étape 2 : Lancer le serveur

Commande terminal :

node server.js

Étape 3 : Créer une tâche

Requête HTTP POST :

POST /tasks HTTP/1.1
Host: localhost:3000
Content-Type: application/json

{
  "title": "Faire les courses",
  "completed": false
}

Étape 4 : Récupérer toutes les tâches

Requête HTTP GET :

GET /tasks HTTP/1.1
Host: localhost:3000

Erreurs fréquentes et debugging

Erreur 1 : TypeError: Cannot read property 'save' of undefined

Code incorrect :

app.post('/tasks', async (req, res) => {
  const task = new Task();
  await task.save(); // Erreur ici
  res.status(201).send(task);
});

Code correct :

app.post('/tasks', async (req, res) => {
  const task = new Task(req.body); // Correction ici
  await task.save();
  res.status(201).send(task);
});

Erreur 2 : MongoError: connection closed

Code incorrect :

mongoose.connect('mongodb://localhost:27017/todo', {
  useNewUrlParser: true,
  useUnifiedTopology: true
});

Code correct :

mongoose.connect('mongodb://localhost:27017/todo', {
  useNewUrlParser: true,
  useUnifiedTopology: true
}).catch(err => console.error(err));

Erreur 3 : SyntaxError: Unexpected token 'await' outside async function

Code incorrect :

app.post('/tasks', (req, res) => {
  const task = new Task(req.body);
  await task.save(); // Erreur ici
  res.status(201).send(task);
});

Code correct :

app.post('/tasks', async (req, res) => { // Correction ici
  const task = new Task(req.body);
  await task.save();
  res.status(201).send(task);
});

Pour aller plus loin

1. Sécurité des Microservices

Utilisez les tokens JWT pour sécuriser l'accès aux microservices.

Liens :

• JSON Web Tokens (JWT)
• Passport.js

2. Orchestration avec Kubernetes

Apprenez à déployer et gérer vos microservices en utilisant Kubernetes.

Liens :

• Kubernetes Documentation
• Minikube

3. Patterns de Conception pour Microservices

Explorez des patterns comme le Circuit Breaker, les Bulkheads et le Retry.

Liens :

• Microservices Patterns
• Circuit Breaker Pattern

Défi pratique

Créez un microservice pour une application de stockage de notes. Implémentez les fonctionnalités suivantes :

1. Création d'une note
2. Lecture d'une note
3. Mise à jour d'une note
4. Suppression d'une note

Utilisez Docker pour le déploiement et Kubernetes pour la gestion du déploiement et de l'échelle.

Liens :

• Déploiement avec Docker
• Gestion avec Kubernetes

Ce tutoriel approfondi couvre les concepts de base des microservices avec Node.js, comprend une mise en pratique complète et propose des pistes pour approfondir votre compréhension.