Créer des microservices

Pour l’architecture monolithique, l’application repose sur une unique base de code. Les modules donc
communiquent avec une seule et même base de données. Ce type d’architecture pose deux problèmes :

• Un seul développeur peut difficilement comprendre l’application dans sa globalité du fait de sa

complexité.
• La modification d’une petite fonctionnalité va nécessiter un redéploiement complet de l’application.
Avec les architectures monolithiques, tous les processus sont étroitement couplés et s'exécutent comme
un système unique. Cela signifie que :

• Si l'un des processus de l'application enregistre un pic de demande, toute l'architecture doit être
mise à l'échelle.
• L'ajout ou l'amélioration de fonctionnalités d'une application monolithique devient plus
complexe à mesure de la croissance de la base de code.
• Cette complexité limite les expérimentations et rend l'implémentation de nouvelles idées
difficile.
• Les architectures monolithiques augmentent les risques en matière de disponibilité des
applications, car de nombreux processus dépendants et étroitement couplés renforcent l'impact
d'un seul échec de processus.
Aussi, le modèle d’application Cloud Native introduit la séparation des applications en fonctionnalités
indépendantes appelées microservices. Les applications gagnent en flexibilité et en modularité.

L’architecture de microservice est généralement couplée à Docker grâce à sa technologie de

conteneurs. Le principe est d’avoir un conteneur par unité de microservice afin que chacun dispose de
son propre environnement d’exécution pour héberger son code. Les conteneurs s’adaptent facilement
aux nombres de microservices. Lorsqu’un service connait une hausse de charge, il peut être hébergé sur
plusieurs conteneurs. Inversement, lorsque la demande diminue, on peut réduire au minimum le nombre
de conteneurs. C’est ce qu’on appelle le principe du scaling.
Ce couplage avec l’utilisation des conteneurs permet au microservice d’être autonome et modifiable
sans impacter les autres si il y a une anomalie, contrairement à une application monolithique ou il aurait
fallu modifier la totalité de l’application.

20/05/2023 1
Concepts de base des microservices

Quelques-uns des concepts de base des microservices :

1. Services autonomes : chaque microservice est un service indépendant qui peut être développé,
déployé, mis à l'échelle et géré séparément des autres microservices.
2. Communication : les microservices communiquent entre eux à l'aide de protocoles légers tels
que REST, HTTP ou AMQP.

REST est un style d'architecture logicielle pour la conception de services web,

HTTP est un protocole de communication utilisé pour transférer des données sur le Web

AMQP est un protocole de messagerie pour l'échange de messages entre des applications. Les
messages échangés entre les microservices sont souvent en format JSON ou XML.

3. Gestion des données : chaque microservice a sa propre base de données, qui peut être une base
de données relationnelle ou une base de données NoSQL. Les microservices peuvent également
partager des données entre eux en utilisant des API.
4. Déploiement continu : les microservices sont déployés de manière continue et indépendante
les uns des autres, ce qui permet de les mettre à jour rapidement et sans interruption de service.
5. Scalabilité : les microservices peuvent être mis à l'échelle horizontalement en ajoutant des
instances de services en fonction de la demande. Cela permet d'optimiser les performances et
de réduire les coûts d'infrastructure.
6. Résilience : les microservices sont conçus pour être résilients, c'est-à-dire qu'ils sont capables
de gérer les erreurs et les pannes de manière autonome, sans affecter les autres microservices.
7. DevOps : les microservices nécessitent une collaboration étroite entre les équipes de
développement et d'exploitation (DevOps) pour assurer un déploiement rapide et une gestion
efficace des microservices.
8. Sécurité : les microservices doivent être sécurisés pour empêcher les attaques malveillantes.
Les mesures de sécurité incluent l'authentification, l'autorisation et la gestion des clés API.

Exemple :

https://openclassrooms.com/fr/courses/4668056-construisez-des-microservices/7651431-apprehendez-
larchitecture-microservices

20/05/2023 2
TP1 : Communication entre deux micro services avec Node.js

Pré requis : Télécharger et installer nodejs : https://nodejs.org/en/download

Étape 1: Initialisation des services

1. Créez un nouveau répertoire pour le projet.

2. Ouvrez une console dans ce répertoire et initialisez deux nouveaux projets Node.js en
exécutant la commande suivante deux fois :

npm init -y

Étape 2: Installation des dépendances

1. Dans la première console, accédez au répertoire du premier service et installez Express et

Axios en exécutant les commandes suivantes :

npm install express axios

Express est un framework pour créer des applications web en Node.js, tandis qu'Axios est une bibliothèque pour
effectuer des requêtes HTTP à partir de n'importe quel environnement JavaScript. Express est principalement
utilisé pour gérer les routes et la logique de l'application web, tandis qu'Axios est utilisé pour communiquer avec
des API ou des serveurs distants.

Résultat :
PS D:\02-DocFormation\cloud\TPS\ServiceA> npm install express axios

added 65 packages, and audited 66 packages in 4s

9 packages are looking for funding

run `npm fund` for details

found 0 vulnerabilities
PS D:\02-DocFormation\cloud\TPS\ServiceA> dir

Répertoire : D:\02-DocFormation\cloud\TPS\ServiceA

Mode LastWriteTime Length Name

---- ------------- ------ ----
d----- 20/05/2023 10:43 node_modules
-a---- 20/05/2023 10:43 24991 package-lock.json
-a---- 20/05/2023 10:43 295 package.json

2. Répétez la même étape dans la deuxième console pour le deuxième service.

Résultat :
PS D:\02-DocFormation\cloud\TPS\ServiceB> npm install express axios
added 65 packages, and audited 66 packages in 5s
9 packages are looking for funding
run `npm fund` for details

found 0 vulnerabilities
PS D:\02-DocFormation\cloud\TPS\ServiceB> dir
Répertoire : D:\02-DocFormation\cloud\TPS\ServiceB
Mode LastWriteTime Length Name
---- ------------- ------ ----
d----- 20/05/2023 10:45 node_modules
-a---- 20/05/2023 10:45 24991 package-lock.json
-a---- 20/05/2023 10:45 295 package.json

20/05/2023 3
Étape 3: Création du premier service

1. Dans la première console, créez un nouveau fichier serviceA.js dans le répertoire du premier
service.
2. Ouvrez le fichier serviceA.js dans un éditeur de code.
3. Ajoutez le code suivant pour créer le premier service :

const express = require('express');

const axios = require('axios');

const app = express();

app.get('/serviceA', (req, res) => {

axios.get('http://localhost:3001/serviceB')
.then(response => {
res.send(`Service A received response from Service B: ${response.data}`);
})
.catch(error => {
res.status(500).send('Error communicating with Service B');
});
});

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

3. Sauvegardez le fichier serviceA.js.

Étape 4: Création du deuxième service

1. Dans la deuxième console, créez un nouveau fichier serviceB.js dans le répertoire du

deuxième service.
2. Ouvrez le fichier serviceB.js dans un éditeur de code.
3. Ajoutez le code suivant pour créer le deuxième service :

const express = require('express');

const app = express();

app.get('/serviceB', (req, res) => {

res.send('Hello from Service B!');
});

app.listen(3001, () => {
console.log('Service B is running on port 3001');
});

3. Sauvegardez le fichier serviceB.js.

20/05/2023 4
Étape 5: Exécution des services

1. Dans la première console, accédez au répertoire du premier service et exécutez le premier

service en utilisant la commande suivante :

node serviceA.js

2. Dans la deuxième console, accédez au répertoire du deuxième service et exécutez le deuxième

service en utilisant la commande suivante :

node serviceB.js

Étape 6: Test de la communication entre les services

1. Ouvrez un navigateur web ou utilisez un outil tel que Postman pour effectuer une requête GET
à l'URL http://localhost:3000/serviceA.
2. Vous devriez recevoir une réponse indiquant que le service A a reçu une réponse du service B.
3. Vérifiez la console de chaque service pour voir les messages de démarrage et les é

20/05/2023 5
TP2 :

Voici un exemple d'utilisation de deux microservices avec MongoDB. Dans cet exemple, nous aurons
un microservice principal qui expose des API CRUD pour interagir avec une base de données
MongoDB, et un microservice secondaire qui consomme ces API.

Microservice principal:

Étape 1: Configuration du projet Créez un nouveau répertoire pour votre microservice principal et
accédez-y. Ouvrez un terminal et exécutez la commande suivante pour initialiser un nouveau projet
Node.js :

npm init -y

Étape 2: Installation des dépendances Dans cet exemple, nous utiliserons Express.js comme
framework web, MongoDB comme base de données, et Mongoose comme bibliothèque d'ODM
(Object Data Modeling) pour interagir avec MongoDB. Installez-les en exécutant la commande
suivante :

npm install express mongoose

Étape 3: Création du microservice principal Créez un nouveau fichier nommé main.js et ajoutez le
code suivant :

const express = require('express');

const mongoose = require('mongoose');

// Connexion à la base de données MongoDB

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

const app = express();

// Définition du schéma de la collection "users"

const userSchema = new mongoose.Schema({
name: String,
email: String,
});

// Définition du modèle "User"

const User = mongoose.model('User', userSchema);

// Endpoint de création d'utilisateur

app.post('/users', async (req, res) => {
try {
const { name, email } = req.body;
const user = new User({ name, email });
await user.save();
res.status(201).json(user);
} catch (error) {
console.error(error);
res.status(500).send('Erreur lors de la création de l\'utilisateur');

20/05/2023 6
 }
});

// Endpoint de récupération de tous les utilisateurs

app.get('/users', async (req, res) => {
try {
const users = await User.find();
res.json(users);
} catch (error) {
console.error(error);
res.status(500).send('Erreur lors de la récupération des utilisateurs');
}
});

// Écoute du serveur
app.listen(3000, () => {
console.log('Le microservice principal est en cours d\'exécution sur le port 3000');
});

Ce code crée une application Express qui définit deux endpoints : un endpoint POST pour créer un
utilisateur et un endpoint GET pour récupérer tous les utilisateurs. Le microservice principal se connecte
à une base de données MongoDB en utilisant Mongoose.

Microservice secondaire:

Le microservice secondaire peut consommer les API exposées par le microservice principal en utilisant
des requêtes HTTP vers les endpoints correspondants. Vous pouvez utiliser n'importe quelle
bibliothèque HTTP pour effectuer ces requêtes, comme Axios, Fetch, ou la bibliothèque intégrée http
de Node.js.

Voici un exemple d'utilisation d'Axios pour consommer les API du microservice principal :

const axios = require('axios');

// Exemple d'appel à l'API POST pour créer un utilisateur

axios.post('http://localhost:3000/users', {
name: 'John Doe',
email: 'john@example.com',
})
.then(response => {
console.log(response.data

Pour créer une base de données MongoDB, vous devez suivre ces étapes :

1. Assurez-vous d'avoir MongoDB installé et en cours d'exécution sur votre système. Si ce n'est
pas le cas, téléchargez MongoDB à partir du site officiel de MongoDB
(https://www.mongodb.com) et suivez les instructions d'installation spécifiques à votre
système d'exploitation.
2. Une fois MongoDB installé, ouvrez une nouvelle fenêtre de terminal ou une interface de ligne
de commande et exécutez la commande suivante pour démarrer le serveur MongoDB :

mongod

Cela lancera le serveur MongoDB et écoutera sur le port par défaut (27017).

20/05/2023 7
 3. Ouvrez une autre fenêtre de terminal ou une interface de ligne de commande pour effectuer les
opérations de gestion de la base de données.
4. Dans cette nouvelle fenêtre de terminal, exécutez la commande suivante pour lancer l'interface
de ligne de commande de MongoDB : mongo

Cela vous connectera à l'instance MongoDB en cours d'exécution.

5. Maintenant, vous pouvez créer une nouvelle base de données en utilisant la commande use
suivie du nom de la base de données que vous souhaitez créer. Par exemple, pour créer une base
de données nommée "microservice-example", vous pouvez exécuter la commande suivante :

use microservice-example

Si la base de données n'existe pas déjà, MongoDB la créera automatiquement lorsque vous y insérerez
des données.

6. Vous pouvez maintenant effectuer des opérations CRUD (Create, Read, Update, Delete) sur
votre base de données. Par exemple, vous pouvez insérer des documents dans une collection
en utilisant la commande insertOne ou insertMany, lire les documents en utilisant la
commande find, mettre à jour les documents en utilisant la commande updateOne ou
updateMany, supprimer des documents en utilisant la commande deleteOne ou deleteMany,
etc.

Voici un exemple d'insertion d'un document dans une collection "users" :

db.users.insertOne({ name: "John Doe", email: "john@example.com" })

Cela insérera un document avec les champs "name" et "email" dans la collection "users".

Ces étapes vous permettent de créer une base de données MongoDB et d'effectuer des opérations de
base sur celle-ci. Vous pouvez ensuite utiliser cette base de données avec votre microservice principal
en ajustant la chaîne de connexion MongoDB dans votre code.

un microservice principal qui expose une API pour gérer des utilisateurs, et un microservice
secondaire qui consomme cette API pour effectuer des opérations.

20/05/2023 8