Compte rendu TP3:

Kubernetes dans le contexte du DevOps

Réalisé par :
Nour Kalai
Heni Loukil
Hamdi Guedhami

Année universitaire:2023/2024
Filière : RT5
Introduction
Kubernetes est un système open-source de gestion d'orchestration de conteneurs. Il
fournit une plateforme pour automatiser le déploiement, la mise à l'échelle et la
gestion des applications conteneurisées. Les conteneurs permettent d'encapsuler
une application et ses dépendances dans un environnement isolé, facilitant ainsi le
déploiement cohérent et la gestion des applications à travers différentes
infrastructures.

Déploiement d’une application Node.js

complète dans Kubernetes
Créer une application Node.js

Lorsqu’on démarre l’application on peut l’accéder via l’adresse localhost:8081

Créer un fichier Docker:

Voici le contenue du fichier Dockerfile que j’ai créé à la racine du projet
Le fichier Dockerfile est utilisé pour construire une image Docker à partir de
laquelle vous pouvez exécuter des conteneurs Docker. Voici une explication
des différentes parties de ce Dockerfile :

FROM node:16 : Cela définit l'image de base à partir de laquelle vous

construirez votre image Docker. Dans ce cas, vous utilisez l'image officielle
Node.js version 16 comme point de départ.

WORKDIR /usr/src/app : Cela définit le répertoire de travail (working

directory) à l'intérieur du conteneur où votre application sera installée et
exécutée. Le répertoire /usr/src/app est créé, et tous les commandes
suivantes seront exécutées dans ce répertoire.

COPY package*.json ./ : Cette commande copie les fichiers package.json et

package-lock.json de votre répertoire local (celui où se trouve le Dockerfile)
vers le répertoire de travail du conteneur. Cela est généralement fait en
premier lieu pour installer les dépendances de l'application.

RUN npm install : Cette commande exécute la commande npm install à

l'intérieur du conteneur. Elle installe les dépendances de l'application Node.js
en se basant sur les fichiers package.json et package-lock.json copiés
précédemment.

COPY . . : Cette commande copie l'ensemble des fichiers de votre répertoire

local (y compris le code source de l'application) vers le répertoire de travail du
conteneur. Cela permet d'ajouter le code source de votre application à l'image
Docker.
EXPOSE 8080 : Cette instruction expose le port 8080 à l'extérieur du
conteneur, indiquant que l'application à l'intérieur du conteneur écoutera sur le
port 8080. Cependant, cela ne signifie pas que le port est automatiquement
exposé à l'extérieur du conteneur, vous devrez le faire lors de l'exécution du
conteneur.

CMD [ "node", "index.js" ] : Cette instruction spécifie la commande par

défaut à exécuter lorsque le conteneur démarre. Dans ce cas, il exécute node
index.js, ce qui démarre votre application Node.js.

En résumé, ce Dockerfile définit comment construire une image Docker qui

inclut Node.js, installe les dépendances de votre application, copie le code
source de l'application, expose un port, et définit la commande par défaut pour
exécuter l'application lorsque le conteneur est démarré. Une fois que vous
avez construit cette image Docker, vous pouvez l'utiliser pour créer et
exécuter des conteneurs Docker qui exécutent votre application Node.js.

Construire une image Docker

On se place dans le répertoire où se trouve notre Dockerfile et en exécutant la
commande:

On peut vérifier la création de l’image

Une fois l'image créée, publiez-la sur un registre Docker public ou privé pour que
Kubernetes puisse y accéder.

Se Connecter au registre Docker :

Tagger votre image Docker :

Avant de publier l'image, on doit la taguer avec le nom du registre.

Publier l'image Docker sur le registre :
docker push nour941/myimage:latest

Cette commande envoie l’image vers le registre Docker

Une fois que votre image est publiée sur le registre Docker, on peut l’accéder et la
référencer en utilisant le nom de l'image avec la version appropriée dans vos fichiers
de configuration Kubernetes .

Kubernetes peut ensuite tirer cette image à partir du registre lorsqu’on déploie
l’application.

Installer Minikube
Minikube offre une solution pratique et simple pour les développeurs qui souhaitent
expérimenter, développer et tester des applications sur Kubernetes sans avoir besoin
d'un cluster distribué complet. Il est particulièrement adapté à un usage en
environnement de développement local.
Créer un fichier de configuration :
Le fichier YAML est un manifeste de déploiement Kubernetes
(node-app-deployment.yaml) qui décrit comment déployer et gérer un ensemble de
pods pour notre application nommée "node-app". Voici une description des éléments
clés du fichier node-app-deployment.yaml :
apiVersion : Spécifie la version de l'API Kubernetes à utiliser, dans ce cas, apps/v1
pour les déploiements.

- kind : Définit le type de ressource, qui est un déploiement dans ce cas.

- metadata : Contient des métadonnées sur le déploiement, y compris son nom

et ses libellés.
- spec : Décrit l'état souhaité du déploiement.

- replicas : Spécifie que vous souhaitez exécuter 1 répliques (pods) de votre

application.
- selector : Définit comment le déploiement sélectionne les pods à gérer. Il
utilise des libellés pour faire correspondre les pods portant l'étiquette app:
node-app.
- template : Décrit le modèle de pod que le déploiement devrait créer et gérer.

- metadata : Contient des libellés pour les pods, et dans ce cas, il applique
l'étiquette app: node-app aux pods.

- spec : Décrit la spécification des pods gérés par le déploiement.

- containers : Spécifie le(s) conteneur(s) à exécuter dans les pods.

 - name : Donne le nom du conteneur en tant que "node-app".

- image : Spécifie l'image Docker à utiliser pour le conteneur. Dans ce cas, il

utilise l'image nour941/myimage.

- ports : Spécifie que le conteneur écoute sur le port 8081.

En résumé, cette configuration de déploiement crée et gère une réplique d'un pod,
exécutant un conteneur avec l'image Docker spécifiée (nour941/myimage) qui
écoute sur le port 8081. Le déploiement garantit que le nombre souhaité de pods est
maintenu (1 seul) et peut gérer la mise à l'échelle et les mises à jour progressives.

La commande kubectl apply -f node-app-deployment.yaml permet de créer, mettre

à jour ou supprimer des ressources Kubernetes en se basant sur le contenu du
fichier YAML (node-app-deployment.yaml). Elle assure que l'état du cluster
correspond à la définition déclarée dans le fichier YAML. Elle crée des ressources si
elles n'existent pas, met à jour les ressources existantes en fonction des
modifications spécifiées dans le fichier, et supprime les ressources qui ne sont plus
déclarées dans le fichier. C'est un outil essentiel pour gérer les ressources
Kubernetes de manière déclarative.

Créer un service et l’appliquer:

Le contenu du fichier:

Le fichier yaml fournit décrit un service Kubernetes (node-app-service) qui expose les
pods de votre application "node-app" vers l'extérieur du cluster. Voici une explication
des éléments clés du fichier :
- apiVersion: Spécifie la version de l'API Kubernetes, ici, c'est v1, qui est la
version de base pour les ressources Kubernetes.

- kind: Définit le type de ressource, qui est un Service dans ce cas.

- metadata: Contient des métadonnées sur le service, notamment son nom.

- spec: Définit la spécification du service.
 - selector: Spécifie un ensemble de libellés qui sont utilisés pour sélectionner
les pods auxquels ce service doit router le trafic. Ici, le service sélectionne
tous les pods qui ont l'étiquette app: node-app. Cela signifie que le service
dirigera le trafic vers les pods qui portent cette étiquette.

- type: Indique le type de service. Dans ce cas, le service est de type

LoadBalancer. Cela signifie que, si le cluster Kubernetes est configuré pour le
support des services LoadBalancer, un équilibreur de charge sera provisionné
pour acheminer le trafic externe vers ce service.

- ports: Spécifie la configuration des ports pour le service.

- protocol: Indique le protocole du port, ici, c'est TCP.

- port: Spécifie le port sur lequel le service écoute pour le trafic entrant (port
externe).

- targetPort: Indique le port sur lequel les pods cibles écoutent (port interne).
Dans ce cas, le trafic entrant sur le port 5000 du service sera redirigé vers le
port 8081 des pods portant l'étiquette app: node-app.

- nodePort: Spécifie le port sur lequel le service sera accessible depuis

l'extérieur du cluster (si le type de service est NodePort). Ici, le service sera
accessible sur le port 32006 du nœud.

En résumé, ce fichier YAML décrit un service Kubernetes de type LoadBalancer qui

dirige le trafic entrant sur le port 5000 vers les pods de l'application "node-app" via le
port 8081, et il est accessible depuis l'extérieur du cluster sur le port 32006 (si le
type de service est NodePort).

Lister tous les services Kubernetes déployés dans votre cluster

Remarque:
Ici, EXTERNAL-IP est toujours en attente pour le service. Mais en utilisant
Minikube, On peut obtenir un External-IP.
On exécute la commande ci-dessous pour activer l’External-IP pour notre
application: minikube service <service_name>

Accéder à l'application exposée par le service "node-app-service"

Ouverture de l’application Node.js dans le navigateur

La commande ci-dessus ouvrira automatiquement votre application Node.js dans le
navigateur et vous verrez l’URL comme dans la capture d’écran ci-dessus.

Gestion des mises à jour :

On change le nombre de réplicats de 1 à 2
Lorsque le nombre de réplicat est 1:
Lorsqu’on change le nombre à 2
Cette commande permet de lister tous les déploiements (Deployments) dans le
cluster Kubernetes.

On obtient la liste des pods actuellement déployés dans notre cluster

Kubernetes. On voit des informations telles que le nom du pod, l'état
actuel du pod, le nombre de répliques, l'état de la création du pod, et
d'autres détails pertinents.
Surveillance et journalisation :
Télécharger Prometheus: