Cloud Native Mon Cours v7

Créer une application cloud
native
Proposé par : M.CHAKOUJ
Application cloud native M.CHAKOUJ ISTA INEZGANE 1

Sommaire
Chapitre 1: Introduire le cloud native
Chapitre 2: API REST avec node js
Chapitre 3: Manipuler les conteneurs
Chapitre 4: Conteneuriser l’application node js
Chapitre 5: Interaction entre un conteneur docker et une base de donnees MySql en localhost
Chapitre 6:Système multi-conteneurs: Docker-compose
Chapitre 7:Créer des microservices
Chapitre 8:Serverless App : FaaS
Chapitre 9: Déploiement Application cloud native M.CHAKOUJ 2
Chapitre 1:
Introduire le cloud computing et
l’approche cloud native
Source : Documentation Microsoft

Lien 1: https://learn.microsoft.com/fr-fr/azure/architecture/microservices/
Lien 2: https://azure.microsoft.com/fr-fr/resources/cloud-computing-dictionary/what-is-cloud-computing
Lien 3 : https://learn.microsoft.com/en-us/dotnet/architecture/cloud-native/definition
Application cloud native M.CHAKOUJ 3

Definition
Pour simplifier, le cloud computing est la
fourniture de services informatiques
(notamment les serveurs, le stockage, les
bases de données, la gestion réseau, les
logiciels, les outils d’analyse et la veille) via
Internet (le cloud) dans le but d’accélérer
l’innovation, d’offrir des ressources flexibles et
de profiter d’économies d’échelle. En règle
générale, vous payez uniquement les services
cloud que vous utilisez (réduisant ainsi vos
coûts d’exploitation), gérez votre
infrastructure plus efficacement et adaptez
l’échelle des services en fonction des besoins
de votre entreprise.
https://azure.microsoft.com/fr-
fr/resources/cloud-computing-
dictionary/what-is-cloud-computing

Avantages du cloud computing
Vitesse
Coût
Les services de cloud computing
La migration vers le cloud permet
aux entreprises de réduire leurs sont disponibles en libre-service
coûts informatiques en éliminant et à la demande, ce qui permet
la nécessité d'investir dans du aux entreprises d'accéder
matériel, des logiciels et la gestion rapidement à d'importantes
d'infrastructures sur site. En
ressources de calcul et de
optant pour le cloud computing,
les entreprises peuvent éviter les bénéficier d'une grande
dépenses liées aux serveurs, à flexibilité, sans avoir à se soucier
l'alimentation électrique et au de la planification de la capacité.
refroidissement, ainsi qu'à Cela offre aux entreprises une
l'expertise informatique requise.
plus grande liberté et réduit la
Cela permet d'éviter des factures
élevées. pression liée à la gestion des
ressources informatiques.
Productivité
Mise à l’échelle mondiale Le cloud computing permet de
Un avantage clé du cloud computing est décharger les équipes informatiques
sa capacité de mise à l'échelle élastique, des tâches chronophages liées à la
ce qui signifie qu'il est possible d'ajuster gestion du matériel et des logiciels
dynamiquement les ressources sur site, leur permettant ainsi de se
informatiques telles que la puissance de concentrer davantage sur la
calcul, le stockage ou la bande passante réalisation des objectifs de
en fonction des besoins réels, au l'entreprise. En éliminant ces
moment et à l'endroit où ils sont corvées, le cloud offre une plus
nécessaires. Cela permet une allocation grande productivité et un meilleur
efficace des ressources et une alignement avec les priorités de
adaptation rapide aux fluctuations de la l'entreprise.
demande.

Performances
Les services de cloud computing de Fiabilité:
grande envergure sont basés sur des Le cloud computing simplifie la sauvegarde des
réseaux de centres de données données, la reprise d’activité après sinistre et la
sécurisés bénéficiant de mises à niveau continuité des activités. Il rend ces activités
régulières du matériel pour assurer des moins coûteuses, car les données peuvent être
performances optimales. Cela se mises en miroir sur plusieurs sites redondants
traduit par des avantages significatifs au sein du réseau du fournisseur de cloud.
tels qu'une latence réseau réduite pour
les applications et des économies
d'échelle accrues par rapport aux
centres de données traditionnels.

Sécurité
De nombreux fournisseurs de cloud offrent un vaste éventail de
stratégies, technologies et contrôles qui renforcent globalement
votre situation de sécurité, contribuant ainsi à protéger vos
données, vos applications et votre infrastructure contre des
menaces potentielles.

Part de marché des fournisseurs de cloud

Modèles de déploiement du cloud
Il existe trois modes de déploiement de services cloud : le cloud public, le
cloud privé et le cloud hybride.
Les clouds publics : sont des déploiements de cloud computing largement
répandus, où les ressources cloud sont détenues et gérées par un
fournisseur tiers et accessibles via Internet. Dans ce modèle, l'ensemble de
l'infrastructure, du matériel et des logiciels est la propriété du fournisseur
de cloud, tel que Microsoft Azure,AWS,GCP.
Dans ce type de déploiement les utilisateurs partagent les ressources
matérielles, de stockage et réseau avec d'autres organisations, accédant
aux services et gérant leurs comptes via un navigateur web, ce qui en fait
une option courante pour des services tels que le courrier électronique, les
applications bureautiques, le stockage et les environnements de
développement en ligne.
Un cloud privé : est un ensemble de ressources de cloud computing
utilisées exclusivement par une entreprise ou une organisation, soit dans
son propre centre de données, soit hébergé par un fournisseur de services
tiers. Dans un cloud privé, la maintenance des services et de l'infrastructure
est réalisée sur un réseau privé, et le matériel et les logiciels sont dédiés
uniquement à cette organisation.
Les clouds privés offrent la possibilité de personnaliser les ressources en

fonction des besoins informatiques spécifiques d'une organisation. Ils sont
couramment utilisés par les organismes publics, les institutions financières
et les grandes organisations qui nécessitent un contrôle optimal de leurs
opérations stratégiques.
Un cloud hybride combine une infrastructure locale ou privée avec un
cloud public, permettant ainsi le déplacement des données et des
applications entre les deux environnements.
Les organisations adoptent souvent une approche de cloud hybride pour

répondre à des exigences réglementaires et de souveraineté des données,
ainsi que pour optimiser les investissements technologiques existants ou
résoudre des problèmes de latence.
Le cloud hybride évolue également pour inclure des charges de travail de

périphérie, ce qui permet de rapprocher le traitement des données des
appareils IoT, réduisant ainsi la latence et permettant un fonctionnement
fiable même en cas de déconnexion prolongée.
Types de services cloud : IaaS, PaaS, serverless
et SaaS

et SaaS Platform-as-a-Service (PaaS) est un
Infrastructure as a service (IaaS): service de cloud computing qui
C’est la catégorie la plus basique fournit un environnement
des services de cloud computing. permettant aux développeurs de
Avec l’ IaaS, vous louez une créer, tester, déployer et gérer des
infrastructure informatique applications logicielles. Grâce à
(serveurs, machines virtuelles, l'infrastructure PaaS, les
stockage, réseaux et systèmes développeurs peuvent se
d’exploitation) auprès d’un concentrer sur la création
fournisseur de services cloud, avec d'applications sans se soucier de la
un paiement en fonction de configuration ou de la gestion des
l’utilisation serveurs, du stockage, du réseau et
des bases de données sous-jacents
nécessaires au développement.
et SaaS L'informatique Serverless (Function
Software-as-a-Service (SaaS) est une as a Service(FaaS)) : se concentre
méthode de distribution d'applications sur le développement d'applications
sans la nécessité de gérer en
logicielles via Internet, permettant un accès à permanence les serveurs et
la demande et généralement sur l'infrastructure associée. Le
abonnement. Les fournisseurs de services fournisseur de cloud prend en
cloud hébergent et gèrent les applications charge la configuration, la
ainsi que l'infrastructure sous-jacente, planification de la capacité et
l'administration des serveurs, offrant
s'occupant des tâches de maintenance telles ainsi une architecture hautement
que les mises à jour logicielles et les correctifs évolutive basée sur des événements,
de sécurité, tandis que les utilisateurs se où les ressources ne sont utilisées
connectent à l'application via Internet, en que lorsque des fonctions ou des
utilisant un navigateur web sur leurs appareils déclencheurs spécifiques sont
activés.
tels que téléphones, tablettes ou ordinateurs.
et SaaS
Débat Serverless vs PaaS
Adrian Cockcroft :Vice president of cloud architecture strategy at Amazon Web Services

Utilisations du cloud computing:
Créer des applications natives Cloud Stocker, sauvegarder et récupérer des
Créez, déployez et mettez à l’échelle rapidement des données
applications (web, mobiles et API). Tirez parti des Protégez vos données à moindre coût et à
technologies et approches natives Cloud , telles que grande échelle en les transférant via
les conteneurs, Kubernetes, l’architecture de Internet vers un système de stockage en
microservices, la communication pilotée par des API ligne hors site, accessible à partir de tout
et DevOps. emplacement et appareil.
Analyser des données
Diffuser des logiciels à la demande
Unifiez vos données entre les équipes,
Également appelés logiciel en tant que service (SaaS,
les divisions et les emplacements dans
software as a service), les logiciels à la demande vous
le cloud. Utilisez ensuite des services
permettent d’offrir à vos clients les versions et mises
cloud, par exemple de Machine
à jour les plus récentes des logiciels, à tout moment
Learning et d’intelligence artificielle,
et en tout lieu.
pour extraire des informations
analytiques qui vous permettent de
Application cloud native M.CHAKOUJ prendre des décisions éclairées. 17
Qu’est-ce qu’une architecture Cloud Native ?
Une architecture cloud native repose sur trois piliers fondamentaux :
1. L'utilisation de composants microservices, qui offrent la flexibilité et la
résilience des applications en utilisant des langages de programmation
différents ;
2. L'adoption de conteneurs légers et sécurisés pour encapsuler les
applications et leurs dépendances, offrant une portabilité multi-
plateformes ;
3. L'utilisation de fonctions serverless, telles qu'Azure Function,AWS
Lambda, qui permettent d'exécuter du code sans se préoccuper de
l'infrastructure sous-jacente, simplifiant ainsi le déploiement et la
gestion des applications.
En résumé, une architecture cloud native repose sur des composants
microservices, des conteneurs et des fonctions serverless, offrant ainsi une
approche moderne et agile pour développer, déployer et gérer des
applications dans le cloud.
Application monolithique
• Une application monolithique est une
architecture logicielle dans laquelle
l'ensemble de l'application est conçu,
développé et déployé en tant qu'unité
unique et indivisible. Dans ce modèle,
toutes les fonctionnalités de l'application,
qu'il s'agisse de l'interface utilisateur, de la
logique métier ou de la gestion des
données, sont regroupées et
interconnectées au sein d'un seul et
même code de base.
• Dans une application monolithique, toutes
les parties de l'application s'exécutent
dans un même processus, généralement
sur un serveur unique.

Les microservices vs application monolithique
Les microservices sont une approche
d'architecture logicielle qui consiste à diviser
une application en plusieurs services
indépendants, chacun ayant sa propre
logique métier et communiquant avec les
autres services via des interfaces bien
définies. Les microservices sont conçus pour
être autonomes et sont souvent déployés
dans des conteneurs. Cette approche
permet de faciliter la maintenance et la mise
à l'échelle de l'application, ainsi que de
rendre l'application plus résiliente aux
pannes. Les microservices peuvent être
développés en utilisant différents langages
de programmation et technologie, et
communiquent souvent via des API REST ou
des messages asynchrones.

Conception d’architecture de microservices
Une architecture de microservices se compose d’un ensemble de petits services
autonomes. Chaque service est autonome et doit implémenter une fonctionnalité
unique dans un contexte borné. Un contexte borné est une division naturelle au
sein d’une entreprise qui fournit une délimitation explicite dans laquelle un modèle
de domaine existe.

Gestion/orchestration. Ce composant est chargé de placer les services
sur des nœuds, d’identifier les défaillances, de rééquilibrer les services
entre les nœuds, etc. En général, ce composant est une technologie
prête à l’emploi comme Kubernetes, plutôt qu’un élément
personnalisé.

API Gateway : la passerelle d’API est le point d’entrée des clients. Au lieu d’appeler
directement les services, les clients appellent la passerelle d’API, qui transfère
l’appel aux services appropriés sur le back-end.
L’utilisation de la passerelle d’API offre les avantages suivants :
•Il dissocie les clients des services. Les services peuvent être versionnés ou
refactorisés sans avoir à mettre à jour tous les clients.
•Les services peuvent utiliser des protocoles de messagerie qui ne sont pas
compatibles avec le web, comme AMQP.
•La passerelle d’API peut exécuter d’autres fonctions transversales, telles que
l’authentification, la journalisation, la terminaison SSL et l’équilibrage de charge.
•Stratégies prêtes à l’emploi, telles que la limitation de nombres de requêtes, la
mise en cache, la transformation et l’agrégation des données pour la
construction des réponses ,la validation.

Avantages
Agilité: Les microservices offrent un déploiement indépendant, simplifiant la
gestion des correctifs et des fonctionnalités, sans redéploiement complet,
avec la possibilité de revenir à une version précédente en cas de problème.
Équipes spécialisées de taille restreinte. Un microservice doit être
suffisamment petit pour qu’une seule équipe de fonctionnalité puisse le
générer, le tester et le déployer. Les petites équipes favorisent une plus
grande souplesse.
Pot-pourri de technologies. Les équipes peuvent choisir la technologie qui
convient le mieux à leur service à l’aide de diverses piles technologiques.

Avantages
• Isolation des erreurs : Les microservices permettent une haute
disponibilité en cas de défaillance individuelle grâce à la gestion des
défaillances et à la communication asynchrone entre les services..
• Extensibilité. Les microservices peuvent être mis à l'échelle
indépendamment, optimisant l'utilisation des ressources et évitant un
scale-out complet de l'application. Les orchestrateurs comme
Kubernetes permettent d'emballer davantage de services sur un hôte,
améliorant l'efficacité des ressources.

Avantages
• Isolation des données. Il est beaucoup plus facile d’effectuer des
mises à jour de schéma, car un seul microservice est concerné. Dans
une application monolithique, les mises à jour de schéma peuvent
devenir très difficiles, car les différentes parties de l’application
impliquer les mêmes données, d’où le risque de modifier le schéma.

Défis
• Complexité : une application de microservices possède plus d’éléments mobiles
qu’une application monolithique équivalente. Si chaque service est plus simple, le
système dans son ensemble est plus complexe.
• Développement et test:L'écriture de services dépendants nécessite une
approche différente de celle des applications monolithiques, avec des défis de
refactorisation et de test des dépendances de services.
• Manque de gouvernance : L'approche décentralisée des microservices peut
causer des problèmes de gestion dus à la diversité des langages et frameworks.
L'établissement de normes projet peut aider à maintenir la flexibilité tout en
gérant les fonctionnalités transversales.
• Surcharge du réseau et latence : L'utilisation de nombreux services granulaires
peut augmenter les communications et la latence, nécessitant une conception
prudente des API et l'utilisation de modèles de communication asynchrone.

Défis
• Intégrité des données : chaque microservice étant responsable de la persistance de ses
propres données, la cohérence des données peut être une gageure. Adoptez la
cohérence éventuelle dans la mesure du possible.
• Gestion : une expérience réussie avec les microservices exige une culture DevOps
mature. La mise en place d’une journalisation corrélée entre les services peut poser des
problèmes. En règle générale, la journalisation doit mettre en corrélation plusieurs
appels de services pour une même opération utilisateur.
• Gestion des versions : les mises à jour apportées à un service ne doivent pas perturber
les services qui en dépendent. Plusieurs services pouvant être mis à jour à tout moment,
sans une conception minutieuse, vous risquez de rencontrer des problèmes de
compatibilité descendante ou ascendante.
• Ensemble de compétences : les microservices sont des systèmes hautement distribués.
Évaluez avec soin les chances de réussite en tenant compte des compétences et de
l’expérience de l’équipe.

Processus de génération d’une architecture de microservices
1. Utilisez l’analyse de domaine pour modéliser les microservices.
2. Utilisez la tactique de la conception pilotée par domaine pour
concevoir des microservices.
3. Identifiez les limites des microservices.
Source : Documentation Microsoft
lien: https://learn.microsoft.com/fr-fr/azure/architecture/microservices/

Activité pratique
1. Créer un compte dans la plateforme Azure :
https://azure.microsoft.com/en-us/free/students/
Explorer les services proposés par Azure.
2. Créer un compte dans la plateforme AWS :
https://aws.amazon.com/education/awseducate/
Explorer les services proposés par AWS.

Chapitre 2:
API REST avec node js

Introduction
Node.js est un environnement d'exécution JavaScript open source et

multiplateforme asynchrone piloté par les événements, qui permet
d’exécuter le code javascript en dehors du navigateur.
Installer node js sur votre machine( https://nodejs.org/fr )
Vérifier que node est installé:
>node -v

Les modules
Dans Node.js, les modules sont écrits au format CommonJS,
qui fournit deux objets globaux, require et exports, qui
les développeurs peuvent utiliser pour garder leurs modules encapsulés.
• require est une fonction qui permet au module courant d'importer et
d'utiliser des variables définies dans d'autres modules.
• exports est un objet qui permet à un module de rendre certaines
fonctionnalités, des objets ou des variables accessibles aux autres modules
qui en ont besoin

Les modules
// app.js
const math = require('./math');
// math.js
console.log(math.add(2, 3)); // Affiche : 5
exports.add = function(a, b) { console.log(math.multiply(2, 3)); // Affiche : 6
return a + b;
};
exports.multiply = function(a, b) {
return a * b;
};

Les promises
Les promesses en JavaScript sont un concept qui permet de gérer les
opérations asynchrones de manière plus claire et structurée. Une promesse
représente la valeur future d'une opération qui peut être soit résolue
(succès) soit rejetée (échec).

Promises
Définition de la fonction qui retourne la promesse:
const getData = () => {
return new Promise((resolve, reject) => {
setTimeout(() => {
const data = 'Données récupérées avec succès';
// Simulons une opération asynchrone avec un délai de 2 secondes
if (data) {
resolve(data); // La promesse est résolue avec les données
} else {
reject('Erreur : impossible de récupérer les données'); // La promesse est rejetée avec un message d'erreur
}
}, 2000);
});
}; Application cloud native M.CHAKOUJ 36
Promises
// Utilisation de la promesse
getData()
.then((data) => {
console.log(data); // Les données sont affichées si la promesse est résolue avec succès
})
.catch((error) => {
console.error(error); // L'erreur est affichée si la promesse est rejetée
});
La méthode then :est utilisée pour attacher des gestionnaires de réussite (resolve) à une promesse, c'est-à-dire
pour spécifier le code qui sera exécuté une fois que la pro esse est résolue avec succès:
maPromesse.then(function(resultat) {
// Code à exécuter lorsque la promesse est résolue avec succès
}).catch(function(erreur) {
// Code à exécuter en cas d'erreur lors de la résolution de la promesse
}); Application cloud native M.CHAKOUJ 37
L’utilisation de la syntaxe async-await
const fetchData = async () => {
try {
const data = await getData();
console.log(data);
} catch (error) {
console.error(error);
}
};
fetchData();

REST API avec express js
Dans cet exemple, nous allons créer un exemple d’une API RESTful
demo à l'aide de Express.
1.Créer un dossier de travail students_service
2.Initialiser le projet node js en exécutant la commande ci-dessous
dans le terminal :
> npm init
Cette commande va créer le fichier de dépendances : package.json
3.Créer le fichier serveur server.js dans la racine du projet

Définitions:
• NPM ( node package manager) : est le plus grand registre de logiciels
au monde.Le registre contient plus de 800 000 packages de code.Les
développeurs open source utilisent npm pour partager des
logiciels.De nombreuses organisations utilisent également npm pour
gérer le développement privé. (https://www.npmjs.com/ )
• Express : est un framework web rapide, sans opinion et minimaliste
pour Node.js(package npm).( https://expressjs.com/)

Package.json:

Le fichier principal server.js :
Configuration de l’objet serveur

server.js :Définition de l’API

server.js : Démarrage du serveur HTTP

Tester l’api avec postman

Chapitre 3:
Manipuler les conteneurs
Docker

Définition : Docker
Docker est une plateforme de conteneurisation open-source
qui permet d'encapsuler des applications et leurs
dépendances dans des conteneurs légers et portables.
https://docs.docker.com/get-started/

Installation de Docker (pour windows)
https://docs.docker.com/get-docker/
https://docs.docker.com/desktop/install/windows-install/

Définition : conteneur docker
Un conteneur Docker est un environnement d'exécution isolé qui contient
tout ce dont une application a besoin pour fonctionner, y compris le code
source, les bibliothèques, les dépendances et les variables d'environnement.
Les conteneurs Docker sont conçus pour être exécutés sur n'importe quel
système d'exploitation, ce qui facilite le déploiement et la gestion
d'applications dans des environnements de développement, de test et de
production.
Docker permet de créer, de distribuer et de gérer facilement des conteneurs,
ce qui offre de nombreux avantages pour les développeurs et les
administrateurs système, tels que la portabilité, la flexibilité et la facilité de
déploiement. Il est également largement utilisé dans les environnements de
développement DevOps, où il facilite l'automatisation des processus de
développement et de déploiement d'applications.
Définition : image docker
• Une image Docker est un modèle de base à partir duquel des
conteneurs Docker peuvent être créés.
• Une image Docker est essentiellement une capture d'un
environnement d'exécution, qui peut inclure un système
d'exploitation, des bibliothèques, des dépendances, des fichiers de
configuration, du code source, des fichiers de données, etc. Lorsque
vous créez une image Docker, vous spécifiez les instructions pour la
construction de l'image dans un fichier appelé Dockerfile. Le
Dockerfile contient des commandes pour télécharger et installer les
dépendances, copier les fichiers nécessaires dans l'image, et
configurer l'environnement d'exécution.

créer une image Docker
Pour créer une image Docker, vous devez suivre les étapes suivantes:
• Créer un fichier Dockerfile: Le fichier Dockerfile contient les instructions
nécessaires pour la construction de l'image Docker. Il spécifie le système
d'exploitation, les bibliothèques et les dépendances nécessaires, le code
source, les fichiers de configuration, etc.
• Écrire les instructions dans le Dockerfile: Les instructions dans le Dockerfile
décrivent les étapes pour la création de l'image. Par exemple, vous pouvez
utiliser des instructions pour installer des dépendances, copier des fichiers
dans l'image, configurer l'environnement d'exécution, etc.
• Construire l'image Docker:Executer cette commande dans le terminal:
>docker build -t nom_de_l_image chemin_vers_le_Dockerfile
créer un conteneur Docker
Executer la commande :
>docker run [OPTIONS] IMAGE [COMMAND] [ARG...]
• "OPTIONS" sont des options facultatives que vous pouvez utiliser
pour personnaliser le comportement du conteneur (par exemple, les
ports à exposer, les variables d'environnement à définir, etc.).
• "IMAGE" est le nom de l'image à partir de laquelle vous souhaitez
créer le conteneur.
• "COMMAND" est la commande à exécuter dans le conteneur (par
exemple, la commande d'initialisation de l'application).
• "ARG..." sont des arguments supplémentaires à passer à la
commande.
Exemple :
Créer une image docker de mon app
>docker build -t student_service .
Créer le conteneur
>docker run -d -p 3000:3000 student_service

Exécuter en mode détaché:
Docker peut exécuter votre conteneur en mode détaché ou en arrière-
plan pour ne pas occuper le terminal. Pour ce faire, nous pouvons
utiliser --detach ou -d en abrégé.
Liaison de port:
le conteneur s'exécute de manière isolée, ce qui inclut la mise en
réseau.Donc, si nous voulions exposer le port 8000 à l'intérieur du
conteneur au port 3000 à l'extérieur du conteneur, nous passerions
3000:8000 au drapeau --publish.

Docker Hub
• Docker Hub est un registre d'images Docker hébergé par Docker. C'est
un service cloud qui permet aux utilisateurs de stocker, partager et
gérer des images Docker.
• Il permet aux développeurs de rechercher et de télécharger des
images Docker créées par d'autres utilisateurs pour les utiliser dans
leurs propres projets. Docker Hub propose une grande variété
d'images, y compris des images de base pour les langages de
programmation populaires, des images de base pour les systèmes
d'exploitation, des images de base pour les serveurs d'applications,
des images pour les bases de données, etc.
https://hub.docker.com/

Autres commandes Docker
docker ps: Cette commande affiche la liste des conteneurs Docker en
cours d'exécution sur votre système.
docker stop: Cette commande arrête un conteneur Docker en cours
d'exécution. Elle prend en entrée l'identifiant ou le nom du conteneur à
arrêter.
docker rm: Cette commande supprime un conteneur Docker. Elle prend
en entrée l'identifiant ou le nom du conteneur à supprimer.
docker images: Cette commande affiche la liste des images Docker
disponibles sur votre système.
docker rmi: Cette commande supprime une image Docker de votre
système. Elle prend en entrée le nom ou l'identifiant de l'image à
supprimer.
docker exec: Cette commande permet d'exécuter une commande dans
un conteneur Docker en cours d'exécution. Elle prend en entrée
l'identifiant ou le nom du conteneur, suivi de la commande à exécuter.
Autres commandes Docker
docker pull :est utilisée pour télécharger une image Docker

depuis un registre d'images public ou privé. Elle permet de
récupérer une image existante sur le registre pour pouvoir
ensuite l'utiliser pour créer des conteneurs Docker.
Par exemple, pour télécharger la dernière version de l'image
Docker "ubuntu" depuis le registre Docker Hub, vous pouvez
utiliser la commande suivante :
>docker pull ubuntu

Dockerfile
L’élément Docker de base est un fichier appelé DockerFile, qui contient des instructions pour créer une image Docker
pas à pas. Chaque étape construit une couche de l image , ce qui permet à docker d’optimiser les prochains builds en
se servant du cache des couches qui non pas étaient affectées par des modifications.
Toute image Docker est construite à partir d'une autre image Docker c’est pourquoi un Dockerfile commence par FROM
baseImage.
• FROM : Cette instruction permet de définir l'image de base de notre image,
• COPY et ADD : Ces instructions permettent de copier les fichier de l’app dans l’ image.
L'instruction ADD prend en charge deux fonctionnalités supplémentaires, pour faire référence à une URL (Uniform
Resource Locator) et pour extraire des fichiers compressés.
• RUN et CMD : Ces instructions prennent en paramètre une commande qui sera exécutée lors de la construction de
l'image.
L'instruction RUN crée une couche afin qu'elle puisse être mise en cache et versionnée.
L'instruction CMD définit une commande par défaut à exécuter lors de l'appel pour exécuter l'image. L'instruction
CMD peut être écrasée lors de l'exécution avec un paramètre supplémentaire fourni.
Exemple : RUN apt-get update
CMD "echo docker"
• ENV : cette instruction permet d'instancier des variables d'environnement pouvant être utilisées pour construire une
image. Ces variables d'environnement persisteront tout au long de la vie du conteneur, comme suit : ENV
myvar=mykey
• WORKDIR : cette instruction donne le répertoire d'exécution du conteneur, comme suit : WORKDIR
usr/local/apache2
Exemple Dockerfile
Ce fichier docker a pour objectif de conteneuriser une application node js:
# Utilisez une image Node.js en tant qu'image de base
FROM node:14
# Définir le répertoire de travail dans le conteneur
WORKDIR /app
# Copier le package.json et le package-lock.json dans le conteneur
COPY package*.json ./
# Installer les dépendances du projet
RUN npm install
# Copier le reste des fichiers de l'application dans le conteneur
COPY . .
# Exposer le port sur lequel l'application va écouter
EXPOSE 3000
# Commande pour exécuter l'application lorsque le conteneur démarre
CMD [ "node", "server.js" ]

Chapitre 4:
Conteneuriser l’application node js
source: https://docs.docker.com/language/nodejs/

Conteneurisation de l’API node js : Dockerfile

Conteneurisation de l’API node js :
.dockerignore
Pour améliorer les performances du build créer un
fichier .dockerignore .Ce fichier vous permet de
spécifier les fichiers et répertoires à exclure du contexte
de génération (build).

Conteneuriser l’application
1. Construire l’image:
>docker build -t students_api:1.0 .
2. Lister docker images:
>docker images
3. Construire le conteneur :
>docker run –p 3000:3000 –name student_api_container students_api:1.0
4 .Lister les conteneurs :
> docker ps -a
5. Arrêter le conteneur:
>docker stop student_api_container
6.Supprimer le conteneurs avec ces volumes:
>docker rm --volumes student_api_container

Tester l’api avec postman

Chapitre 5:
Interaction entre un conteneur
docker et une base de donnees
MySql en localhost

Exemple API REST avec une bd mysql
Nous souhaitons créer une api rest pour la gestion des etudiants, un
etudiant est caracterise par : id, nom,
prenom,ville,filiere,total_absences
La structure du projet :

Installer les packages suivant :
>npm i express body-parser sequelize
>npm install --save-dev nodemon

Définitions:
body-parser : est une bibliothèque middleware populaire pour Node.js
utilisée pour analyser les données du corps des requêtes HTTP,
généralement lors de la réception de données de formulaire ou de
données JSON dans une application web.
Nodemon: est un outil qui permet de faciliter le développement des
applications basées sur Node.js en redémarrant automatiquement
l'application lorsque des modifications de fichiers dans le répertoire
sont détectées.
Sequelize est un ORM Node.js facile à utiliser et basé sur des
promesses pour Postgres, MySQL, MariaDB, SQLite, DB2, Microsoft SQL
Server et Snowflake.

Dans le serveur mysql créer une base de données api_students

Fichier de configuration de l’objet Sequelize : qui va être utiliser
comme un mappeur (ORM) entre les models js et les tables de la base
de données.
config.db
NB:
• Dans ma machine j’ai garder le mot de passe par défaut de l’utilisateur root (chaine vide).
• Pour faciliter l'accès aux services de l'hôte Docker à partir des conteneurs, Docker fournit un nom
d'hôte spécial, host.docker.internal, qui résout automatiquement vers l'adresse IP de l'hôte Docker.
Le model student.js:

Le contrôleur studentController.js:





Server.js:

Création de l’image puis le déploiement du conteneur
 docker build -t students_api .

 docker run -p 9000:9000 --name students_api _container students_api

Teste de l’API
NB: L’API seule qui conteneurisée et non pas Mysql, donc assurez vous que Mysql est
démarré sur le port 3306 de votre machine.
Chapitre 6:
Système multi-conteneurs:
Docker-compose
Doc : https://docs.docker.com/compose/

Docker-compose
Docker-compose est un outil de ligne de commande qui permet de gérer et
d'orchestrer plusieurs conteneurs Docker en même temps à l'aide d'un
fichier de configuration docker-compose.yml.
docker-compose est particulièrement utile pour les applications qui
nécessitent plusieurs services, tels qu'une base de données, un serveur
Web et une API. Il permet de gérer facilement les dépendances entre les
conteneurs et de les lancer tous en même temps avec une seule
commande.

Le fichier docker-compose.yml
docker-compose.yml est un fichier de configuration qui permet de définir et de lancer
plusieurs conteneurs Docker en même temps en utilisant le langage YAMAL . Le format
YAML utilise l'indentation pour définir la structure et les niveaux de hiérarchie. Les
valeurs sont souvent spécifiées avec des clés suivies de deux-points (:), puis d'un espace,
et enfin de la valeur réelle.
Le fichier docker-compose.yml contient les informations suivantes :
• Les images Docker à utiliser pour chaque conteneur
• Les volumes à monter dans les conteneurs
• Les variables d'environnement à définir dans les conteneurs
• Les ports à mapper entre les conteneurs et la machine hôte
• Les dépendances entre les conteneurs
En utilisant un fichier docker-compose.yml, vous pouvez facilement lancer et gérer
plusieurs conteneurs en même temps. Vous pouvez également définir des relations entre
les conteneurs, par exemple en spécifiant qu'un conteneur doit être lancé avant un
autre. Cela peut être utile pour les applications qui nécessitent plusieurs services, tels
qu'une base de données, un serveur Web et une API.
Exemple docker-compose.yml
version: '2'
services:
web:
build: .
command: npm run dev
volumes:
- .:/usr/app/
- /usr/app/node_modules
ports:
- "3000:3000"
depends_on:
- postgres
environment:
DATABASE_URL: postgres://todoapp@postgres/todos
postgres:
image: postgres:9.6.2-alpine
environment:
POSTGRES_USER: todoapp
POSTGRES_DB: todos Application cloud native M.CHAKOUJ 83
Application mutiservices (2 conteneurs ):
Au lieu d’utiliser un SGBDR MySql en localhost ,nous allons conteneuriser le

serveur mysql, en se servant de son image officielle sur docker hub comme image
de base dans le dockerfile.
La meilleur approche pour mettre en place une architecture multi-conteneurs et
d’utiliser docker compose.

Application multiservices : structure du projet

Application mutiservices (2 conteneurs ): Le fichier docker-compose.yml

Application mutiservices : fichier docker du service de base de
donnees db

Application mutiservices : init.sql
Ce script d’initialisation change le mot du passe du root avec ‘root’.

Vous pouvez aussi inclure le script de création de la table students dans la base de données.

Application mutiservices : config.db.js
Changer le mot du pass du root avec ‘root’
Process.env.key : accéder aux variables d’environnements définies dans docker-compose.yml

Deploiement:
>docker-compose build
> docker-compose up
Pour supprimer le conteneur définie dans docker-compose ses images et ses volumes:
>docker-compose down --volumes --rmi all
Conteneuriser l’application : Tester votre API

Quelques commandes docker-compose:
• docker-compose up : lance tous les conteneurs définis dans le fichier docker-compose.yml. Si les conteneurs
n'existent pas, docker-compose les construit en premier. Le flag -d peut être ajouté pour lancer les
conteneurs en arrière-plan.
• docker-compose down : arrête et supprime tous les conteneurs, réseaux et volumes créés par docker-
compose up.
• docker-compose build : construit ou reconstruit les images de tous les conteneurs définis dans le fichier
docker-compose.yml.
• docker-compose ps : affiche l'état des conteneurs définis dans le fichier docker-compose.yml.
• docker-compose logs : affiche les logs des conteneurs. Le nom du service peut être spécifié pour afficher
uniquement les logs d'un conteneur spécifique.
• docker-compose exec : permet de se connecter à un conteneur en cours d'exécution. Par exemple, docker-
compose exec service-name sh pour se connecter à un conteneur nommé service-name et exécuter le shell.
> docker-compose exec mysql mysql -u root –p
mysql>show databases;

Chapitre 7:
Créer des microservices

Exemple d’architecture microservices
Service A: Gestion des notes
Service B: Gestion des absences
Service C: Gestion des étudiants

Docker-compose.yml

Docker-compose.yml

Docker-compose.yml

Docker-compose.yml
- `version: '3.9'` indique la version de la syntaxe Docker Compose utilisée dans ce fichier.
- `services:` est la section où les services Docker sont configurés.
- `rabbitmq:` est le nom du service RabbitMQ.
- `container_name: rabbitmq_container` spécifie le nom du conteneur Docker créé pour le service
RabbitMQ.
- `image: rabbitmq:3.9.7` indique l'image Docker utilisée pour ce service, dans ce cas `rabbitmq:3.9.7`.
- `networks:` spécifie le réseau auquel le service RabbitMQ est connecté. Ici, il est connecté au réseau
`bridge`, qui est le réseau par défaut de Docker.
- `mysql_students_db:` est le nom du service de base de données MySQL pour les étudiants.
- `build: ./students_service_mysql_db` indique que le service MySQL sera construit à partir du Dockerfile
situé dans le répertoire `./students_service_mysql_db`.
- `environment:` permet de définir des variables d'environnement pour le service MySQL. Dans cet
exemple, deux variables sont définies : `MYSQL_ROOT_PASSWORD` avec la valeur "root" et
`MYSQL_DATABASE` avec la valeur "api_students".

Docker-compose.yml
- `volumes:` La section volumes spécifie le montage de volumes dans le
conteneur Docker. Les volumes sont utilisés pour stocker et persister des données
entre les redémarrages du conteneur.
Dans ce cas, la ligne - students-mysql-data:/var/lib/mysql configure un volume
nommé students-mysql-data qui sera monté dans le conteneur MySQL à
l'emplacement /var/lib/mysql.
Cela signifie que les données de la base de données MySQL, telles que les fichiers
de données, les journaux, etc., seront stockées dans le volume students-mysql-
data sur l'hôte Docker. Ainsi, même si le conteneur MySQL est arrêté ou
supprimé, les données seront conservées dans le volume et seront disponibles
lors du prochain démarrage du conteneur.

Messagerie asynchrone entres les microservices avec RabbitMQ:
RabbitMQ est un logiciel de messagerie open-source qui implémente le protocol de messagerie
avancée (Advanced Message Queuing Protocol - AMQP). Il fournit une plateforme de messagerie
robuste pour la communication entre les applications, les systèmes distribués et les microservices.
Le principe fondamental de RabbitMQ est basé sur la notion de file d'attente de messages. Les
applications peuvent envoyer des messages à des files d'attente spécifiques(Producer), et d'autres
applications (Consumer) peuvent lire ces messages et les traiter.

Messagerie asynchrone entres les microservices avec RabbitMQ :
RabbitMQ prend en charge plusieurs modes d'échange (exchange) qui déterminent la
façon dont les messages sont routés vers les files d'attente. Voici les modes les plus
couramment utilisés dans RabbitMQ :
Fanout Exchange : Ce mode diffuse les messages à toutes les files d'attente liées à
l'échange, sans tenir compte des clés de routage. C'est un mode de diffusion en
broadcast.
Direct Exchange : Ce mode achemine les messages vers les files d'attente dont la clé de
routage correspond exactement à la clé de routage du message.
Topic Exchange : Ce mode utilise des motifs de clé de routage (wildcards) pour
acheminer les messages vers les files d'attente correspondantes. Les clés de routage
peuvent contenir des caractères de remplacement (*) pour un seul mot et des
caractères de substitution (#) pour plusieurs mots.
Headers Exchange : Ce mode utilise les en-têtes des messages pour les acheminer vers
les files d'attente correspondantes, en évaluant les valeurs des en-têtes.
Messagerie asynchrone entres les microservices avec RabbitMQ :
Dans notre exemple le microservice absences_service est une api qui gère une
ressource absence. Une absence est caractérisé par id,date, studentId,reason.
Lorsque on ajoute un nouveau absence, le champ total absences de l’ étudiant
concerné doit être incrémenter.
Dans ce cas le producer est absences_service et le consumer est students_service.
Pour implémenter cette communication nous allons utiliser la bibliothèque node js
AMQP (Advanced Message Queuing Protocol).
Mode : direct exchange
Doc :
https://amqp-node.github.io/amqplib/channel_api.html

Le microservice: absences_service
Server.js


Fonction de publication des messages :

Fonction de publication des messages :
• la méthode assertQueue vérifier si la file d'attente spécifiée existe déjà dans

RabbitMQ. Si la file d'attente n'existe pas, elle sera créée. Cela garantit que la file
d'attente est prête à recevoir les messages.
• la méthode sendToQueue permet d’envoyer un message à la file d'attente spécifiée.
Le premier argument de cette méthode est le nom de la file d'attente et le deuxième
argument est le message lui-même, qui est généralement une séquence d'octets ou
une chaîne encodée en bytes.

Action createAbsence du controlleur AbsenceController :

Action getStudentsAbsences du controlleur AbsenceController :

consumer.js du students_service

consumer.js du students_service
• channel.ack(message) est utilisée pour envoyer un accusé de réception (acknowledgement) à

RabbitMQ après avoir traité avec succès un message consommé à partir d'une file d'attente. Lorsqu'un
consommateur reçoit un message d'une file d'attente, RabbitMQ attend généralement un accusé de
réception avant de supprimer le message de la file d'attente. Cela permet de garantir que le message a
été traité avec succès par le consommateur.
• channel.consume(queueName, processMessage) est utilisée pour commencer à consommer les
messages à partir d'une file d'attente spécifiée dans RabbitMQ.
La méthode consume prend deux arguments. Le premier argument, queueName, est le nom de la file
d'attente à partir de laquelle vous souhaitez consommer les messages. Le deuxième argument,
processMessage, est une fonction de rappel (callback function) qui sera appelée chaque fois qu'un
nouveau message est reçu.

Le microservice: students_service
Appel de la fonction de consommation des messages dans server.js:

Déploiement en machine local:
>docker-compose up --build

Tester les microservices
NB: Assurer vous que tous les services sont démarrés correctement et ce la en vérifiant le log de chaque
service dans Docker desktop en cliquant sur le service concerné.

Tester votre système: Ajouter un étudiant

Tester votre système : Ajouter une absence

Tester votre système :Vérifier que total absence est mis a jour.

Résistance aux pannes:
La fonction consumeMessages() qui est utilisée pour consommer les messages de la

file d'attente "total_absences_maj" dans RabbitMQ. Lorsqu'un message est reçu, il est
converti en objet JSON absenceData et ensuite utilisé pour récupérer l'étudiant à qui
correspond l'absence et mis a jour son total_absences.Si le microservice
students_service est en arrêt, et qu’on ajoute plusieurs absences du même étudiant,
et lorsque le service devient fonctionnel à nouveau le total_absences est
correctement mis à jour. C’est l’avantage majeur de la messagerie asynchrone.

API Gateway
Dans une architecture de
microservices, l'API Gateway joue
un rôle essentiel en tant que
point d'entrée central pour les
clients et les autres services. Il
agit comme un proxy inversé qui
reçoit les requêtes des clients, les
achemine vers les services
appropriés et agrège les réponses
avant de les renvoyer aux clients.
L'API Gateway offre également
des fonctionnalités telles que
l'authentification, l'autorisation,
la transformation des données et
la mise en cache.

Solutions API Gateway
Amazon API Gateway : C'est un service
entièrement géré proposé par AWS. Il NGINX : Bien qu'il ne s'agisse pas spécifiquement
permet de créer, déployer et gérer des
d'une solution d'API Gateway, NGINX peut être
API RESTful et WebSocket à grande
échelle.
utilisé pour mettre en place un proxy inverse et
Kong : C'est une plateforme open-source gérer le routage des requêtes vers les microservices.
d'API Gateway. Il est largement utilisé pour sa haute performance
Azure API Management : C'est un service et sa flexibilité.
proposé par Microsoft Azure qui permet
de créer, déployer et gérer des API.
Apigee : C'est une plateforme complète
d'API Management proposée par Google
Cloud. Apigee permet de concevoir,
sécuriser et gérer des API à grande
échelle

API Gateway avec node js
Nous allons créer un service avec node js qui va jouer le rôle de
l’API gateway.
Notre api gateway va assurer la fonctionnalité d’authentification
et cela en utilisant JSON Web Token (JWT) qu’ est un format de
token sécurisé utilisé pour représenter des informations sous la
forme de chaînes de caractères. Il est couramment utilisé pour
l'authentification et l'autorisation dans les applications Web et
les services d'API.

Nous allons ajouter deux services à
docker-compose.yml :
L’un pour la base de données de l’api
gateway qui contiendra pour ce
moment la table des utilisateurs, et un
autre service pour conteneuriser le
code de l’api rest.
NB:
Veuillez à affecter des ports différents
de la machine hôtes aux services, pour
éviter les conflits .
Port machine hote:port conteneur docker

Middleware d’authentification:
NB:
secret est la clé utilisée pour
signer/ vérifier le tocken .C’est
une chaine de caractères
aléatoire qui ne doit pas être
exposer dans le code. Vous
devez stocker cette clé dans
un endroit sécurise(variables
d'environnement , système de
gestion des secrets, services
de gestion des clés…).

Le model User:
Dans ce code la méthode

pre de mongoose.Schema
permet de définir un
traitement à exécuter
avant l’exécution de save
sur une instance du
model.

Register de UserController:

login de UserController:

protectedRoute de UserController:

server.js: connexion à la base de donnes

du service.

server.js:
suite

Exposition des ports dans docker-compose.yml
L'exposition des ports des bases de données peut exposer les bases de
données à des accès non autorisés depuis l'extérieur, ce qui peut être un
risque de sécurité. Les bases de données sont généralement destinées à être
accessibles uniquement à partir des services internes de votre architecture
microservices.
Dans cette optiques nous allons réécrire le fichier docker-compose pour
n’exposer à l’extérieur que le port du service api gateway.



> docker-compose up --build

Tester l’API gateway



Exercices:
1. L’ écriture des données sensibles telles que les mots de passe dans le code ou
dans docker-compose.yml n’est pas une bonne pratique=>Utiliser un fichier
.env et déclarer dedans les variables d’environnements.
2. Encapsuler les deux méthodes publish et consumeMessages dans une classe
RabbitMQ.
3 . Refaire le code de l’appel des fonctions asynchrones en utilisant async-await
au lieu du then et catch.
4. Ajouter un microservice gestion des notes developpé avec php-mysql
5. Implémenter une api gateway avec Amazon API Gateway

Montage des volumes
Pour éviter de recréer les conteneurs docker après chaque modification dans le code.
Vous pouvez, dans la phase de développement utiliser le montage de volumes (mount
volumes) pour synchroniser le répertoire du code source dans votre machine et celui
qui se trouve dans le conteneur docker. Puis installer nodemone pour que le serveur
node js redémarre après chaque modification du code.

Chapitre 8:
Serverless App

Serverless computing
Serverless est un modèle de développement cloud natif qui permet aux développeurs de créer et d'exécuter des
applications sans avoir à gérer de serveurs.
‘Sans serveur' ne signifie pas qu'il n'y a pas de serveurs impliqués, mais ils sont séparés du développement
d'applications. Un fournisseur de cloud gère le travail de routine de provisionnement, de maintenance et de
mise à l'échelle de l'infrastructure du serveur. Les développeurs peuvent simplement empaqueter leur code
dans des conteneurs pour le déploiement.
Une fois déployées, les applications sans serveur répondent à la demande et évoluent automatiquement selon
les besoins. Les offres sans serveur des fournisseurs de cloud public sont généralement mesurées à la demande
via un modèle d'exécution piloté par les événements.
https://www.redhat.com/en/topics/cloud-native-apps/what-is-serverless
Function as a Service (FaaS)
FaaS est un modèle de cloud computing spécifique qui s'inscrit dans

le cadre du serverless. FaaS se concentre sur l'exécution de fonctions
individuelles plutôt que sur le déploiement d'applications entières.
Les fonctions sont de petits morceaux de code indépendants et
auto-suffisants qui sont déclenchés par des événements ou des
requêtes. Lorsqu'un événement se produit (par exemple, une
requête HTTP arrive), le fournisseur de services cloud exécute la
fonction associée et gère automatiquement les ressources
nécessaires pour répondre à la demande. Le développeur ne paie
que pour le temps d'exécution de la fonction, ce qui permet une
granularité de facturation fine.

Exemples de solutions FaaS:
AWS Lambda : https://aws.amazon.com/lambda/getting-started/

Azure functions : https://learn.microsoft.com/en-us/azure/azure-functions/

Chapitre 9:
Déploiement

Kubernetes
Kubernetes, également connu sous le nom de K8s, est un système open source
permettant d'automatiser le déploiement, la mise à l'échelle et la gestion des
applications conteneurisées.
Doc : https://kubernetes.io/docs/concepts/
Formations et certifications : https://kubernetes.io/training/

Kubernetes vs Docker compose
Kubernetes et Docker Compose sont des frameworks pour l'orchestration des
conteneurs. Docker Compose déploie des applications Docker multi-conteneurs sur
un seul serveur, tandis que Kubernetes est un orchestrateur de conteneurs de niveau
production qui peut exécuter plusieurs runtimes de conteneurs, y compris Docker,
sur plusieurs machines virtuelles ou physiques.
Kubernetes offre des mécanismes intégrés de découverte de services et
d'équilibrage de charge. Il attribue automatiquement un nom DNS unique à chaque
service et répartit le trafic sur les instances disponibles. Docker Compose s'appuie
sur la pile réseau Docker et ne fournit pas de fonctionnalités natives de découverte
de services ou d'équilibrage de charge. Cependant, vous pouvez intégrer Docker
Compose avec des outils externes ou des modules complémentaires pour obtenir
des fonctionnalités similaires.

Solutions Kubernetes pour déployer en cloud:
Microsoft : Azure Kubernetes Service (AKS)

https://learn.microsoft.com/fr-fr/azure/aks/
AWS :Amazon Elastic Kubernetes Service (EKS)
https://aws.amazon.com/eks/
Google : Google Kubernetes Engine (GKE)
https://cloud.google.com/kubernetes-engine

Cloud Native Mon Cours v7

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cloud Native Mon Cours v7

Transféré par

Droits d'auteur :

Formats disponibles

Créer une application cloud

Application cloud native M.CHAKOUJ ISTA INEZGANE 1

Source : Documentation Microsoft

Application cloud native M.CHAKOUJ 3

Application cloud native M.CHAKOUJ 4

Application cloud native M.CHAKOUJ 6

Application cloud native M.CHAKOUJ 7

Application cloud native M.CHAKOUJ 8

Application cloud native M.CHAKOUJ 9

Les clouds privés offrent la possibilité de personnaliser les ressources en

Les organisations adoptent souvent une approche de cloud hybride pour

Le cloud hybride évolue également pour inclure des charges de travail de

Application cloud native M.CHAKOUJ 13

Application cloud native M.CHAKOUJ 16

Application cloud native M.CHAKOUJ 19

Application cloud native M.CHAKOUJ 20

Application cloud native M.CHAKOUJ 21

Application cloud native M.CHAKOUJ 22

Application cloud native M.CHAKOUJ 23

Application cloud native M.CHAKOUJ 24

Application cloud native M.CHAKOUJ 25

Application cloud native M.CHAKOUJ 26

Application cloud native M.CHAKOUJ 27

Application cloud native M.CHAKOUJ 28

Application cloud native M.CHAKOUJ 29

Application cloud native M.CHAKOUJ 30

Application cloud native M.CHAKOUJ 31

Node.js est un environnement d'exécution JavaScript open source et

Application cloud native M.CHAKOUJ 32

Application cloud native M.CHAKOUJ 33

Application cloud native M.CHAKOUJ 34

Application cloud native M.CHAKOUJ 35

Application cloud native M.CHAKOUJ 38

Application cloud native M.CHAKOUJ 39

Application cloud native M.CHAKOUJ 40

Application cloud native M.CHAKOUJ 41

Application cloud native M.CHAKOUJ 42

Application cloud native M.CHAKOUJ 43

Application cloud native M.CHAKOUJ 44

Application cloud native M.CHAKOUJ 45

Application cloud native M.CHAKOUJ 46

Application cloud native M.CHAKOUJ 47

Application cloud native M.CHAKOUJ 48

Application cloud native M.CHAKOUJ 50

Application cloud native M.CHAKOUJ 53

Application cloud native M.CHAKOUJ 54

Application cloud native M.CHAKOUJ 55

docker pull :est utilisée pour télécharger une image Docker

Application cloud native M.CHAKOUJ 57

Application cloud native M.CHAKOUJ 59

Application cloud native M.CHAKOUJ 60

Application cloud native M.CHAKOUJ 61

Application cloud native M.CHAKOUJ 62

Application cloud native M.CHAKOUJ 63

Application cloud native M.CHAKOUJ 64

Application cloud native M.CHAKOUJ 65

Application cloud native M.CHAKOUJ 66

Application cloud native M.CHAKOUJ 67

Application cloud native M.CHAKOUJ 68

Application cloud native M.CHAKOUJ 69

Application cloud native M.CHAKOUJ 71

Application cloud native M.CHAKOUJ 72

Application cloud native M.CHAKOUJ 73