It is a basic NodeJS web application exposing REST API that creates and stores user parameters in Redis database
Cette application est écris en NodeJS et utilise Redis comme base de donnée
Pour le projet, on utilise l'API utilisateur présenté ici Userapi in Corrections.
Allez dans le répertoire racine de l'application (ici userapi/, où le fichier package.json
est localisé) et lancer:
npm install
- Démarrer le serveur web
Dans le répertoire racine de l'application, lancer:
npm start
Cela démarre un serveur web disponible dans votre navigateur à l'adresse http://localhost:3000. Voici la page web obtenu :
- Créer un utilisateur
Envoyer une requête POST (REST protocol) en utilsant le terminal:
curl --header "Content-Type: application/json" \
--request POST \
--data '{"username":"alexcmr","firstname":"Alexandre","lastname":"Correia"}' \
http://localhost:3000/user
Il affichera:
{"status":"success","msg":"OK"}
Dans le répertoire racine de l'application, lancer:
npm test
Voici le résultat obtenu des 12 tests:
- Configurer et appliquer CI/CD pipeline
On va dans un premier temps créer un flux de travail (CI workflow) pour notre application à l'aide d'un fichier yaml dans .github/workflows
que 'on configurera grace a GithubActions. Ce flux de travail devra permettre a notre application en Node JS de se connecter au serveur Redis pour pouvoir effectuer les tests avant cahque déploiment de notre application, dans le but de garantir son intégrité. Voici le fichier de flux de travail:
A chaque push de nouveau code dans notre repository, voici ce qui apparaît dans notre repository au niveau de Github Actions:
On voit bien que le statut du jobs est Succed
, donc les tâches se sont exécutés correctement, notre application est bien opérationelle et prête a être déployé.
Nous avons utilisé Vagrant pour configurer et gérer notre machine virtuelle, puis Ansible pour provisionner la machine virtuelle
- Installer VirtualBox (ou un autre hyperviseur)
- Installer Vagrant
Ouvrir le terminal puis acceder au fichier IaC/ puis lancer la comande:
vagrant up
NB: Cette commande
- Initialise et lance la machine virtuelle
- Télécharge Ansible et le provisionnement mis en place par le playbook Anssible.
Nous utilisons le système d'exploitation hashicorp/bionic64 : une version de base de très optimisée d'ubuntu
Apres le téléchargement lancez la commande:
vagrant ssh nodejs_server
Ici, notre VM est liée au fichier userapi/ grâce à la propriété "synced_older" qui est dans le Vagrantfile
Une fois connecté, vous pouvez parcourir le répertoire avec les commandes ci-dessous:
$ cd ../..
$ cd /home/userapi
$ ls
Avec la dernière commande vous verrez les fichiers composants de notre dossier userapi.
Docker permet d'automatiser le déploiement des applications au sein d'un environnement de conteneurs, environnement que nous définissons.
-
Installez Docker Desktop en suivant les instructions en fonction de votre système d'exploitation.
-
Assurez-vous que votre installation Docker fonctionne correctement en exécutant la commande suivante dans un terminal :
docker run hello-world
- Configurer l'image docker
Créer un Dockerfile dans le répertoire racine du projet.
- Construire l'image docker de notre application. Pour cela il faut lancer la commande suivante dnas le répertoire racine de notre projet
docker build -t devops-user-api .
Voici ce qu'on obtient :
- Vous pouvez vérifier s'il l'image de votre application apparaît dans vos images Docker locales :
docker images
- Executer l'image de votre application dans un container Docker avec la commande suivante :
docker run -p 3001:3000 -d devops-user-api
- On peut vérifier que le container s'éxécute bien grace a la commande suivante :
docker ps
- Voici ce qu'on obtient dans le terminal :
- On push notre image Docker sur DockerHub à l'aide de la commande suivante (sans oublier le .dockerignore:
docker push alexcmr27/userapi
- Voici ce que l'on obtient dans le terminal:
- On stoppe le container avce la commande suivante:
docker stop <CONTAINER_ID>
- Voici ce que l'on obtient dans le terminal:
- Si vous vous rendez sur https://localhost:3001, vous pourrez obtenir la page d'accueil :
- Si vous rendez sur notre compte DockerHub, vous pourrez accèder à l'image docker de notre apllication que vous pourrez alors pull:
L'image de notre apllication que l'on a obtenus a partir du Dockerfile execute un container de notre application mais sans la connexion à notre base de donnée Redis. C'est la que Dockercompose et le principe de multi-containers intervient.
Procéder à l'installation de Docker Desktop
- A partir du fichier de configuration docker-compose.yaml, executer la commande docker-compose suivante qui démarrera les service Redis à partir d'un container contenant une image de Redis et fera la connexion avec l'autre container qui contient l'image de notre application :
docker compose up
- Voici ce que l'on obtient dans le terminal:
- Pour stopper les containers (serveur Redis et notre application), il suffit d'éxécuter la commande suivante:
docker compose down
- Si vous vous rendez sur https://localhost:3001, vous pourrez obtenir la page d'accueil :
- Si vous voulez retrouver les informations d'un utilsateur à partir de cette requête exécuter dans le containr de notre application
curl --header "Content-Type: application/json" \
--request POST \
--data '{"username":"alexcmr","firstname":"Alexandre","lastname":"Correia"}' \
http://localhost:3000/user
Il affichera:
Kubernetes est un système open source qui permet a ces utilisateurs d'automatiser le déploiement, la montée en charge et la mise en œuvre de conteneurs d'application sur des clusters de serveurs. La différence avec docker est que kubernetes propose plus de fonctionnalité que docker, comme l'auto-discovery
Vous devez installer Minikube: il s'agit d'un outil facilitant l'éxécution locale de Kubernetes.
- Voici la commande pour démarrer minikube:
minikube start
- Voici la commande pour vérifier que le cluster kubernetes en utilsant Minikube fonctionne bien :
minikube status
Pour appliquer le deployment, les servives et les volumes Kubernetes; il faut se placer dans le répertoire /k8s et exécuter la commande suivante
kubectl apply -f <filename.yaml>
Voici les différents fichier qui faut exécuter:
- deployment.yaml qui décrit un état souhaité de notre API et notre base de donnée Redis.
- service.yaml qui permet d'exposer notre API et notre serveur Redis s'éxécutant sur un ensemble de pods en tant que service réseau.
- persistentvolume.yaml est un élément de stockage dans le cluster qui a été provisionné par un administrateur.
- persistentvolumeclaim.yaml est une demande de stockage fait par l'utilisateur pour notre API.
Ensuite, il suffit de vérifier que toutes les entités sont bien en cours d'éxécution
- Pour les déployement:
kubectl get deployment
On obtient:
- Pour les services:
kubectl get service
On obtient:
- Pour le PersistentVolume:
kubectl get pv
On obtient:
- Pour le PersistentVolumeClaim:
kubectl get pvc
On obtient:
- Dans un premier temps, on peut tester si tout fonctionne correctement grâce a cette commande :
minikube dashboard
On obtient :
- Ensuite, on vérifie que les pods s'éxécute bien gràce a la commande suivante:
kubectl get pods
On obtient:
- Pour finir, on exécute une commande qui nous permet de redirger le flux d'information de nos pods vers un port souhaité:
kubectl port-forward deployment/user-api 3000:3000
Voici ce que l'on obtient sur l'adresse https://localhost:3000:
Istio est une plateforme Open Source de Service Mesh qui permet de contrôler la manière dont les données sont partagées entre les microservices. Cela permettra de faire un maillage de service entre notre API et la base de donnée Redis.
- Tout d'abord il faut vérifié que kubernetes s'éxécute correctement grâce aux comandes suivantes :
minikube start
minikube status
Tout d'abord, il faut modifier le fichier deployment.yaml. Maintenant on crée 4 déploiment: deux déploiment concerne une premiere version de notre code (v1) et les deux autres uen deuxième version (v2); chaque version comporte un déploiment de notre API et une autre du serveur Redis. Voici la commande que l'on eéxécute dans le répertoire /istio:
kubectl apply -f deployment.yaml
Ensuite, on crée un fichier routerequest.yaml qui permet de créer une configuration pour router les requêtes entre 2 versions différentes de votre application.
-
Grafana est une plateforme gratuite et ouverte qui permet de concevoir et de partager des tableaux de bord et des graphiques. Elle peut être utilisée pour se connecter à différentes sources de données, y compris Prometheus, et offre une interface conviviale pour créer et visualiser des graphiques et des diagrammes.
-
Prometheus est une collection d'outils open source destinés à surveiller et à alerter sur les systèmes. Son fonctionnement consiste à récupérer des mesures provenant de multiples sources et à les stocker dans une base de données de séries chronologiques.
Prometheus et Grafana sont deux outils qui, lorsqu'ils sont utilisés ensemble, fournissent une solution robuste pour surveiller et visualiser les performances du système et des applications. Ils sont généralement déployés avec des applications conteneurisées qui s'exécutent sur Kubernetes.
- Nous avons utilisé la prom-clientbibliothèque pour exposer plusieurs points de terminaison de métrique à partir de notre application API utilisateur.
- Ensuite, nous utilisons les deux services Prometheus et Grafana dans le localhost en utilisant ces commandes:
kubectl port-forward svc/prometheus -n istio-system 9090
kubectl port-forward svc/grafana -n istio-system 3000
Alexandre CORREIA & Christ ABESSOLO