Orchestrez vos conteneurs avec Kubernetes

Gérez vos paquets avec Kubernetes

Vous arrivez à la dernière étape de ce cours ! Maintenant que vous maîtrisez les principaux concepts de Kubernetes, vous êtes prêt à appliquer ces concepts aux déploiements de vos applications.

Alice vous explique alors que le site web e-commerce de LiveCorp n’est pas la seule application que vous allez gérer, et écrire des manifestes pour chaque application est fastidieux et répétitif. Il serait intéressant d’avoir un système ou les manifestes peuvent être configurés et adapter par rapport à vos besoins. De plus, il serait aussi intéressant de pouvoir avoir une seule commande à taper pour installer les applications, un peu à l’instar de ce que l’on peut retrouver dans les distributions Linux comme apt ou yum.

Il existe dans l'écosystème Kubernetes un gestionnaire de paquet qui permet de réaliser tout cela ! Ce gestionnaire de paquet s’appelle Helm et s’inspire du templating de fichier afin de installer les applications rapidement et facilement.

Helm est un outil essentiel pour les DevOps qui souhaitent gérer efficacement le cycle de vie de leurs applications Kubernetes dans différents environnements.

Helm permet de regrouper toutes les ressources Kubernetes (pods, services, deployments, etc.) nécessaires à une application dans un seul package appelé "chart". Cela facilite le déploiement, la mise à jour et la suppression des applications.

Ces charts Helm peuvent être versionnés et partagés, ce qui garantit des déploiements cohérents et reproductibles dans différents environnements (développement, test, production).

Helm utilise des templates pour rendre les charts plus flexibles et réutilisables. Vous pouvez personnaliser les valeurs de configuration en fonction de l'environnement cible.

Il permet aussi de gérer les dépendances entre les charts, ce qui facilite l'installation et la mise à jour des applications complexes, et s'intègre facilement avec d'autres outils DevOps comme Jenkins, GitLab CI/CD, etc., pour automatiser le déploiement continu (CD).

Les développeurs créent un chart Helm qui décrit toutes les ressources Kubernetes nécessaires à l'application. Les DevOps créent des fichiers de valeurs spécifiques à chaque environnement (dev, test, prod), en ajustant les paramètres de configuration (URL de base de données, niveau de journalisation, etc.). Ils utilisent Helm pour déployer le chart dans l'environnement cible, en spécifiant le fichier de valeurs approprié.

Helm facilite la mise à jour des applications en déployant de nouvelles versions du chart. Il permet également de revenir à une version précédente en cas de problème.

Helm est un outil qui simplifie la gestion des applications Kubernetes et permet aux équipes DevOps de déployer rapidement et de manière fiable des applications dans différents environnements. En adoptant Helm, vous pouvez améliorer la collaboration entre les développeurs et les opérations, accélérer le time-to-market et garantir la cohérence et la qualité de vos déploiements.

Découvrez Chart Helm

Un chart Helm est un package qui contient tous les fichiers de définition de ressources Kubernetes nécessaires pour déployer une application. Il est l'équivalent d'un paquet d'installation pour Kubernetes. Un chart Helm regroupe les différents objets Kubernetes (Deployments, Services, ConfigMaps, Secrets, etc.) dans un format structuré et versionné.

Architecture de Helm dans Kubernetes

Helm se compose de deux principaux composants :

• Client Helm (helm): C'est l'outil en ligne de commande que vous utilisez pour interagir avec Helm. Il vous permet de créer, gérer, installer, mettre à jour et supprimer des charts.

• Tiller (Helm 2) ou Helm Library (Helm 3): Tiller était un composant serveur qui s'exécutait dans votre cluster Kubernetes et gérait les versions et les releases des charts. Dans Helm 3, Tiller a été supprimé et remplacé par la Helm Library, qui est intégrée directement dans le client Helm.

Client Helm

Le client Helm est l'interface principale pour travailler avec Helm. Il fournit des commandes pour :

• Créer des charts: helm create

• Installer des charts: helm install

• Mettre à jour des charts: helm upgrade

• Supprimer des charts: helm uninstall

• Lister les releases: helm list

• Afficher l'historique des releases: helm history

Pour configurer un chart Helm, vous pouvez utiliser un fichiervalues.yaml. Il contient les valeurs par défaut pour les variables de configuration de votre application. Ces valeurs peuvent être modifiées lors de l'installation ou de la mise à jour d'un chart pour personnaliser le déploiement en fonction de votre environnement.

Voici un exemple de fichier values.yaml applicable pour le site e-commerce de LiveCorp afin de paramétrer le déploiement et le service :

image:
repository: site-ecommerce
tag: 1.2.0
service:
type: ClusterIP
port: 8080
replicaCount: 3

Lors de l'installation ou de la mise à jour d'un chart, Helm utilise les valeurs du fichiervalues.yaml  pour générer les fichiers YAML de ressources Kubernetes. Vous pouvez remplacer les valeurs par défaut en fournissant un fichier de valeurs personnalisé ou en utilisant des options en ligne de commande.

Écrivez un fichier Chart Helm

Vous allez pouvoir appliquer tout ce que vous avez vu dans ce cours pour écrire votre premier chart Helm. Ce chart Helm utilisera du templating pour créer un Deployment et un service.

Générez le dossier du chart

Dans un premier temps, il est nécessaire de créer la structure du chart Helm. Pour ce faire, il existe une commande qui permet de créer un dossier contenant tous les fichiers nécessaires à l’installation de l’application.

helm create site-ecommerce

Cette commande va créer un répertoire contenant un certain nombre de fichiers :

site-ecommerce/
├── charts
├── Chart.yaml
├── templates
│   ├── deployment.yaml
│   ├── _helpers.tpl
│   ├── hpa.yaml
│   ├── ingress.yaml
│   ├── NOTES.txt
│   ├── serviceaccount.yaml
│   ├── service.yaml
│   └── tests
│   └── test-connection.yaml
└── values.yaml

Regardons ensemble ce dossier. Le fichier principal est le fichierChart.yaml. Ce fichier va contenir la définition du chart, ainsi que la version de celui-ci. Dans notre cas, le contenu est le suivant :

apiVersion: v2
name: site-ecommerce
description: A Helm chart for Kubernetes
type: application
version: 0.1.0
appVersion: "1.16.0"

Nous retrouvons dans ce fichier la version de l’API de Helm (ici v2), le nom du chart ainsi qu’une petite description.

Ensuite, le champ type indique ce que vous voulez installer. Ici, c’est une application, mais cela pourrait aussi être une bibliothèque.

Le champ version quant à lui indique la version du chart Helm. La version ici est 0.1.0. Le champ appVersion est la version de l’application à installer.

Modifiez légèrement le fichier afin que celui-ci ressemble à cela :

apiVersion: v2
name: site-ecommerce
description: Site web e-commerce de LiveCorp
type: application
version: 0.1.0
appVersion: "1.2.0"

Le second fichier important ici est le fichiervalues.yaml qui va contenir les valeurs à remplacer lors de l’installation de l’application. Ce fichier est très verbeux lors de la création du chart. Vous allez le modifier afin que celui-ci ressemble à cela :

replicaCount: 3
image:
repository: localhost:5000/site-ecommerce
tag: 1.2.0
service:
type: ClusterIP
port: 8080
ingress:
enabled: true
className: "nginx"
hosts:
- host: site-ecommerce.example
paths:
- path: /
pathType: Prefix

Vous pouvez constater que le fichiervalues.yamlregroupe dans un fichier central toutes les valeurs que vous avez renseignées lors de la création des manifestes de Deployment, Service et Ingress.

Le reste des fichiers présents dans le dossier sont des exemples de manifestes autogénérés et templatisés. Voici par exemple un extrait du fichierdeployment.yaml afin de vous expliquer le fonctionnement des templates.

apiVersion: apps/v1
kind: Deployment
metadata:
name: {{ include "site-ecommerce.fullname" . }}
labels:
{{- include "site-ecommerce.labels" . | nindent 4 }}
spec:
{{- if not .Values.autoscaling.enabled }}
replicas: {{ .Values.replicaCount }}
{{- end }}

Les doubles accolades {{ }} sont utilisées pour insérer les valeurs des variables. Dans le cas du réplica, les accolades {{ .Values.replicaCount }} vont être remplacées par la valeur de replicaCount présente dans le fichier values.yaml, c’est-à-dire 3.

Le fichier généré ressemblera alors au manifeste deployment que vous aviez écrit durant la seconde partie du cours.

Déployez le chart sur le cluster

Une fois le fichiervalues.yaml modifié, la prochaine étape est d’appliquer ce chart sur le cluster Kubernetes. La commande à utiliser est :

helm install site-ecommerce ./site-ecommerce
NAME: site-ecommerce
LAST DEPLOYED: Sun Jul 28 14:12:05 2024
NAMESPACE: default
STATUS: deployed
REVISION: 1
NOTES:
Get the application URL by running these commands:
export POD_NAME=$(kubectl get pods --namespace default -l "app.kubernetes.io/name=site-ecommerce,app.kubernetes.io/instance=site-ecommerce" -o jsonpath="{.items[0].metadata.name}")
export CONTAINER_PORT=$(kubectl get pod --namespace default $POD_NAME -o jsonpath="{.spec.containers[0].ports[0].containerPort}")
echo "Visit http://127.0.0.1:8080 to use your application"
kubectl --namespace default port-forward $POD_NAME 8080:$CONTAINER_PORT

Cette commande va alors installer l’application site-ecommerce sur le cluster Kubernetes en respectant les valeurs dans le fichiervalues.yaml

Helm va aussi vous retourner toutes les commandes afin de pouvoir accéder à l’application déployée.

Une fois l’installation terminée, vous pouvez lister les applications installées avec Helm grâce à la commande :

helm ls
NAME        NAMESPACE   REVISION    UPDATED                                                                                          STATUS   CHART               APP VERSION
site-ecommerce  default     1           2024-07-28 14:12:05.349372772 +0000 UTC                                                          deployed site-ecommerce-0.1.0 1.16.0

Packagez et mettez à disposition votre chart

La dernière étape est de générer le package et de l’uploader dans la registry afin de pouvoir partager le chart.

La commande helm package permet de générer un fichier au format .tar.gz facilement transférable dans une registry :

helm package site-ecommerce
Successfully packaged chart and saved it to: /home/openclassrooms/site-ecommerce-0.1.0.tgz

Comme pour une image Docker, avant de pouvoir la pousser vers la registry, il faut d’abord la taguer. C’est exactement le même principe qu’une image, mais avec la commande suivante :

helm tag site-ecommerce-0.1.0 oci://docker.io/monutilisateur/site-ecommerce:0.1.0

Une fois le chart tagué, il est maintenant temps de le pousser

helm push site-ecommerce-0.1.0 oci://docker.io/monutilisateur

Voilà ! Vous avez maintenant stocké votre package Helm dans une registry et pouvez le déployer facilement dans n'importe quel cluster Kubernetes.

À vous de jouer

Contexte

Alice : Bob notre DevOps trouve cela fastidieux de devoir jongler entre les différents environnements et d’appliquer des fichiers différents entre environnements. Il voudrait bien trouver un moyen de configurer l’application facilement en changeant un unique fichier.

Peux-tu packager l’application sous un chart Helm afin que la livraison pour Bob soit plus simple pour lui ?

Consignes

1. Créez un chart Helm pour packager l’application ;

2. Créez un fichiervalues.yaml contenant toutes les configurations de l’application pour la production ;

3. Stockez ce chart dans la registry ;

4. Appliquez ce chart sur le cluster Minikube.

En résumé

• Un chart Helm sert à packager une application.

• Le chart Helm est un moyen simple pour diffuser votre application.

• Le chart peut se configurer grâce à un unique fichier.

• Le chart est stocké dans une registry accessible à tout le monde.

C’était le dernier chapitre ! Félicitations d’avoir fini ce cours OpenClassrooms ! Avant de nous quitter, testez vos connaissances dans le quiz clôturant cette dernière partie.