Aller au contenu principal

Introduction à Helm

Dans le monde des conteneurs et de l'orchestration, Kubernetes s'est imposé comme le standard pour déployer et gérer des applications conteneurisées. Cependant, la gestion des configurations et des déploiements complexes peut rapidement devenir un casse-tête. C'est ici qu'intervient Helm souvent décrit comme le gestionnaire de paquets pour Kubernetes.

Helm simplifie le processus de gestion des applications Kubernetes en permettant de définir, installer et mettre à jour des ensembles de ressources Kubernetes de manière cohérente et reproductible. Avec Helm, vous pouvez empaqueter vos applications et leurs dépendances en charts, déployer ces applications à l'aide de commandes simples et gérer leur cycle de vie avec facilité.

Dans ce guide, je vais vous accompagner pas à pas pour comprendre et utiliser Helm efficacement. Que vous soyez un débutant cherchant à déployer votre première application Kubernetes ou un administrateur système souhaitant rationaliser ses déploiements, ce guide vous fournira les connaissances et les outils nécessaires pour tirer le meilleur parti de Helm.

Historique​

Helm a été développé à l'origine par l'équipe de Deis, une entreprise spécialisée dans les plateformes de conteneurs. Le projet a été lancé en 2015 avec l'objectif de simplifier le déploiement d'applications sur Kubernetes.

Les premières versions de Helm, notamment Helm v1, se concentraient principalement sur la gestion des charts (paquets contenant des définitions Kubernetes). Bien que fonctionnelles, ces versions initiales avaient certaines limitations en termes de gestion des dépendances et de flexibilité dans les déploiements.

En 2016, Helm v2 a été publié, apportant des améliorations significatives. Parmi les nouveautés, on peut citer l'introduction de Tiller, un composant serveur chargé d'installer des charts dans le cluster Kubernetes et de gérer les releases. Cette version a également introduit une meilleure gestion des dépendances et des fonctionnalités avancées comme les hooks.

La popularité croissante de Helm a conduit à son adoption par la Cloud Native Computing Foundation (CNCF) en 2018. Cette intégration a permis de bénéficier d'un soutien communautaire plus large et de garantir l'évolution continue de l'outil.

Helm v3, lancé en décembre 2019, a marqué une étape importante dans l'évolution de l'outil. L'une des principales modifications a été la suppression de Tiller, souvent critiqué pour des problème de sécurité. Désormais, Helm interagit directement avec l'API Kubernetes, ce qui élimine la nécessité d'exécuter un composant supplémentaire dans le cluster.

L'une des forces de Helm réside dans sa communauté active et engagée. Des centaines de contributeurs à travers le monde travaillent continuellement pour améliorer Helm, ajouter de nouvelles fonctionnalités et résoudre les problèmes.

Concepts de base de Helm​

Pour utiliser efficacement Helm, il est important de comprendre ses concepts fondamentaux. Avec la version 3 de Helm, l'outil est devenu plus intuitif et sécurisé, éliminant la nécessité de certains composants comme Tiller. Voici les concepts clés à maîtriser :

Repositories​

Les repositories sont des emplacements où les charts sont stockés et distribués. Helm permet d'ajouter des repositories publics ou privés pour accéder à une multitude de charts préconfigurés. Vous pouvez également héberger vos propres repositories pour partager des charts internes.

Charts​

Les charts sont des ensembles de fichiers qui décrivent un ensemble de ressources Kubernetes. Un chart contient toutes les définitions nécessaires pour déployer une application, y compris les services, les déploiements et les configurations. Les charts peuvent être partagés et réutilisés, ce qui facilite la gestion des applications complexes.

Releases​

Une release est une instance déployée d'un chart. Chaque fois que vous installez un chart avec Helm, une nouvelle release est créée. Les releases permettent de suivre et de gérer les différentes versions déployées de vos applications.

Values​

Le fichier values.yaml contient les valeurs par défaut utilisées par les templates du chart. Ces valeurs peuvent être personnalisées lors de l'installation ou de la mise à jour de la release, permettant une grande flexibilité et une configuration précise des déploiements.

Templates​

Les templates sont des fichiers YAML contenant des définitions de ressources Kubernetes. Ils utilisent le moteur de templates Go pour permettre des configurations dynamiques basées sur les valeurs définies dans le fichier values.yaml.

Helmfile​

Helmfile est un outil complémentaire qui permet de gérer plusieurs charts et releases avec un fichier unique. Il est particulièrement utile pour orchestrer des déploiements complexes et gérer les dépendances entre différents charts.

Helm Hooks​

Les hooks permettent d'exécuter des actions à des moments spécifiques du cycle de vie des releases, comme avant ou après l'installation, la mise à jour ou la suppression d'une release. Ils sont utilisés pour gérer des tâches supplémentaires, telles que les migrations de bases de données ou la configuration préalable de l'environnement.

Fonctionnement général​

Helm V3 est conçu pour simplifier le déploiement, la gestion et la mise à jour des applications sur Kubernetes. Le fonctionnement général de Helm repose sur une série de concepts et de processus bien définis qui facilitent la gestion des configurations complexes.

Le cœur du fonctionnement de Helm repose sur les charts, qui sont des paquets contenant toutes les ressources nécessaires pour déployer une application Kubernetes. Un chart peut inclure des fichiers de configuration, des templates Kubernetes et des fichiers de valeurs par défaut. Les charts permettent de définir des configurations standardisées et réutilisables pour des applications.

Processus de Déploiement​

Lorsqu'un utilisateur souhaite déployer une application, il utilise un chart. Helm package les ressources définies dans le chart et interagit avec l'API Kubernetes pour créer les ressources nécessaires dans le cluster. Chaque déploiement crée une release, qui est une instance spécifique de l'application déployée. Helm suit ces releases pour permettre une gestion facile des mises à jour et des rollbacks.

Helm permet de personnaliser les déploiements grâce aux fichiers values.yaml. Ces fichiers contiennent des valeurs par défaut qui peuvent être surchargées par l'utilisateur au moment du déploiement. Cela permet de configurer les paramètres spécifiques de l'application sans modifier directement les fichiers de templates du chart. Les valeurs peuvent être ajustées pour répondre à différents environnements (développement, test, production).

Mise à Jour et Rollback​

Un des avantages majeurs de Helm est sa capacité à gérer facilement les mises à jour des applications. Lorsqu'une nouvelle version d'un chart est disponible ou que les configurations doivent être modifiées, Helm permet de mettre à jour la release existante. Si un problème survient après une mise à jour, Helm offre également la possibilité de revenir à une version précédente de la release grâce à la fonctionnalité de rollback.

Gestion des Dépendances​

Helm gère également les dépendances entre les charts. Un chart peut déclarer des dépendances vers d'autres charts, qui seront automatiquement installées ou mises à jour lorsque le chart principal est déployé. Cette gestion des dépendances permet de composer des applications complexes à partir de composants réutilisables et indépendants.

Automatisation et CI/CD​

Helm s'intègre bien avec les outils d'automatisation et les pipelines CI/CD. Grâce à des fichiers de configuration déclaratifs et des commandes scriptables, Helm peut être intégré dans des workflows automatisés pour déployer des applications de manière cohérente et fiable à chaque commit ou mise à jour de code. Cela permet d'atteindre des déploiements continus (CD) et d'améliorer l'efficacité des équipes de développement et des opérations.

Installation de Helm​

Pour commencer à utiliser Helm, la première étape consiste à installer la CLI (Command Line Interface) Helm sur votre machine.

Avant d'installer Helm, assurez-vous que vous avez un cluster kubernetes et une version récente de kubectl installée sur votre machine. Helm interagit avec Kubernetes via l'API, donc kubectl est nécessaire pour certaines opérations.

Installation sur Linux​

Pour installer Helm sur Linux, vous pouvez utiliser le script d'installation fourni par l'équipe Helm ou télécharger directement les binaires.

asdf-vm est un gestionnaire de versions qui permet d'installer et de gérer plusieurs versions d'outils de développement, y compris Helm. Voici comment installer Helm avec asdf-vm :

  1. Ajoutez le plugin Helm à asdf : 
    asdf plugin-add helm
  2. Installez Helm en utilisant asdf : 
    asdf install helm latest
  3. Définissez la version installée comme version globale par défaut : 
    asdf global helm latest

Installation sur macOS​

Pour installer Helm sur macOS, vous pouvez utiliser Homebrew, un gestionnaire de paquets populaire pour macOS. Comme pour Linux, vous pouvez également installer Helm manuellement sur macOS en téléchargeant les binaires depuis GitHub et en suivant les mêmes étapes que pour l'installation manuelle sur Linux.

Si Homebrew est déjà installé sur votre machine, exécutez simplement la commande suivante dans votre terminal :

brew install helm

Cette commande télécharge et installe la dernière version de Helm. Vous pouvez vérifier l'installation avec :

helm version

Installation sur Windows​

Pour installer Helm sur Windows, vous pouvez utiliser Chocolately, un gestionnaire de paquets pour Windows, ou installer manuellement les binaires.

Utilisation de Chocolately​

Si Chocolately est installé sur votre machine, exécutez la commande suivante dans votre PowerShell en mode administrateur :

choco install kubernetes-helm

Après l'installation, vérifiez-la avec :

helm version

Installation manuelle​

Pour une installation manuelle :

  1. Téléchargez la dernière version de Helm depuis la page des releases GitHub : Releases Helm
  2. Extrayez le contenu du fichier téléchargé.
  3. Déplacez l'exécutable helm vers un répertoire inclus dans votre PATH.

Vérification de l'installation​

Pour vérifier que Helm est correctement installé et configuré, utilisez la commande suivante :

helm version
version.BuildInfo{Version:"v3.15.1", GitCommit:"e211f2aa62992bd72586b395de50979e31231829", GitTreeState:"clean", GoVersion:"go1.22.3"}

Cette commande doit retourner la version de Helm installée, confirmant que l'installation a été effectuée avec succès.

Configuration de la complétion​

La complétion est une fonctionnalité utile qui permet de compléter automatiquement les commandes et les options dans le terminal. Helm offre la complétion automatique pour Bash, Zsh, Fish et PowerShell. Configurer la complétion automatique vous permet de gagner du temps et de réduire les erreurs de saisie lorsque vous utilisez la CLI Helm.

Configuration pour Bash​

Pour activer la complétion automatique pour Bash, vous devez générer le script de complétion et l'ajouter à votre fichier de configuration de shell (~/.bashrc ou ~/.bash_profile).

Exécutez la commande suivante pour générer le script de complétion pour Helm :

helm completion bash > /etc/bash_completion.d/helm

Si vous n'avez pas les permissions nécessaires pour écrire dans /etc/bash_completion.d/, vous pouvez utiliser un répertoire local :

helm completion bash > ~/.helm-completion.bash

Ajoutez la ligne suivante à votre fichier ~/.bashrc ou ~/.bash_profile pour charger le script de complétion à chaque démarrage de shell :

source ~/.helm-completion.bash

Rechargez votre shell pour appliquer les modifications :

source ~/.bashrc

Configuration pour Zsh​

Pour Zsh, vous devez ajouter le script de complétion à votre fichier de configuration Zsh (~/.zshrc).

Exécutez la commande suivante pour générer le script de complétion pour Helm :

helm completion zsh > "${fpath[1]}/_helm"

Assurez-vous que la complétion automatique est activée dans votre fichier ~/.zshrc en ajoutant ou en vérifiant les lignes suivantes :

autoload -Uz compinit
compinit

Rechargez votre shell pour appliquer les modifications :

source ~/.zshrc

Configuration pour Fish​

Pour Fish, vous devez ajouter le script de complétion dans le répertoire des fonctions de Fish.

Exécutez la commande suivante pour générer et installer le script de complétion pour Helm :

helm completion fish > ~/.config/fish/completions/helm.fish

Configuration pour PowerShell​

Pour PowerShell, vous devez ajouter le script de complétion à votre profil PowerShell.

Exécutez la commande suivante pour générer le script de complétion pour Helm :

helm completion powershell > helm-completion.ps1

Ajoutez la ligne suivante à votre profil PowerShell ($PROFILE) pour charger le script de complétion à chaque démarrage de PowerShell :

. .\helm-completion.ps1

Rechargez votre session PowerShell pour appliquer les modifications :

. $PROFILE

Premier déploiement avec Helm​

Après avoir installé Helm, il est temps de l'utiliser pour déployer votre première application sur Kubernetes. Dans ce chapitre, je vais vous guider à travers les étapes nécessaires pour ajouter un repository de charts, rechercher un chart et déployer une application en utilisant Helm.

Ajouter un Repository de Charts​

Avant de pouvoir déployer une application avec Helm, vous devez ajouter un repository de charts. Les repositories contiennent des collections de charts Helm que vous pouvez utiliser pour déployer des applications. Un des repositories les plus populaires est le repository Bitnami, qui contient de nombreux charts pour des applications couramment utilisées.

Pour ajouter le repository Bitnami, utilisez la commande suivante :

helm repo add bitnami https://charts.bitnami.com/bitnami
helm repo update

Ces commandes ajoutent le repository Bitnami à Helm et mettent à jour la liste des charts disponibles.

Rechercher un Chart​

Une fois le repository ajouté, vous pouvez rechercher un chart spécifique. Par exemple, pour rechercher le chart pour Nginx, utilisez la commande suivante :

helm search repo nginx

Cette commande affiche une liste de tous les charts disponibles contenant "nginx" dans leur nom ou description.

Installer une Version Spécifique d'un Chart​

Dans une approche DevOps, il est recommandé d'installer une version spécifique d'un chart pour garantir la stabilité et la reproductibilité des déploiements. Pour installer une version spécifique, utilisez l'option --version lors de l'installation du chart.

Par exemple, pour installer la version 8.8.0 du chart Nginx à partir du repository Bitnami, utilisez la commande suivante :

helm install my-release bitnami/nginx --version 8.8.0

Cette commande déploie le chart Nginx en version 8.8.0 sur votre cluster Kubernetes en utilisant le chart fourni par Bitnami. my-release est le nom que vous donnez à cette instance déployée de l'application, également appelée une release.

Vérifier le Déploiement​

Après avoir installé le chart, vous pouvez vérifier que l'application a été correctement déployée en utilisant la commande suivante :

kubectl get all -l app.kubernetes.io/instance=my-release

Cette commande affiche toutes les ressources Kubernetes associées à la release my-release, y compris les pods, les services et les déploiements.

Personnaliser l'Installation​

Helm vous permet de personnaliser l'installation d'un chart en passant des valeurs spécifiques. Par exemple, pour changer le nombre de répliques du déploiement Nginx, vous pouvez utiliser un fichier de valeurs personnalisé ou passer les valeurs directement en ligne de commande.

Utilisation d'un fichier de valeurs personnalisé​

Créez un fichier custom-values.yaml avec le contenu suivant :

replicaCount: 3

Ensuite, installez le chart en utilisant ce fichier de valeurs :

helm install my-release bitnami/nginx --version 8.8.0 -f custom-values.yaml

Passer les valeurs en ligne de commande​

Vous pouvez également passer les valeurs directement en ligne de commande :

helm install my-release bitnami/nginx --version 8.8.0 --set replicaCount=3

Création de vos propres Charts​

Créer votre propre chart Helm vous permet de packager vos applications et leurs configurations pour les déployer de manière cohérente et réutilisable sur Kubernetes. Dans ce chapitre, je vais vous montrer comment créer un chart personnalisé, le structurer correctement et définir les fichiers nécessaires pour déployer votre application.

Initialisation d'un nouveau Chart​

Pour créer un nouveau chart, utilisez la commande helm create suivie du nom de votre chart. Par exemple, pour créer un chart nommé mychart, exécutez :

helm create mychart

Cette commande génère une structure de répertoire de base pour votre chart, avec des fichiers de configuration et des templates par défaut.

Structure d'un Chart​

La structure d'un chart Helm généré par la commande helm create ressemble à ceci :

mychart/
  Chart.yaml          # Contient des informations sur le chart (nom, version, description)
  values.yaml         # Contient les valeurs par défaut pour les templates
  charts/             # Répertoire pour les dépendances de chart
  templates/          # Contient les fichiers de templates Kubernetes
    deployment.yaml
    service.yaml
    _helpers.tpl
  .helmignore         # Liste des fichiers à ignorer lors de l'archivage du chart

Fichier Chart.yaml​

Le fichier Chart.yaml contient des informations importantes sur votre chart, telles que le nom, la version et une description. Voici un exemple de Chart.yaml :

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

Fichier values.yaml​

Le fichier values.yaml contient les valeurs par défaut utilisées par les templates. Les utilisateurs peuvent remplacer ces valeurs lors du déploiement pour personnaliser la configuration de l'application. Voici un exemple de values.yaml :

replicaCount: 1

image:
  repository: nginx
  tag: stable
  pullPolicy: IfNotPresent

service:
  type: ClusterIP
  port: 80

resources: {}

Templates Kubernetes​

Les templates dans le répertoire templates/ définissent les ressources Kubernetes nécessaires pour déployer votre application. Ces fichiers utilisent le moteur de templates Go pour générer des manifestes Kubernetes dynamiques en fonction des valeurs spécifiées dans values.yaml.

Exemple de Template de Déploiement (deployment.yaml)​

apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ .Release.Name }}-nginx
  labels:
    app: {{ .Release.Name }}-nginx
spec:
  replicas: {{ .Values.replicaCount }}
  selector:
    matchLabels:
      app: {{ .Release.Name }}-nginx
  template:
    metadata:
      labels:
        app: {{ .Release.Name }}-nginx
    spec:
      containers:
      - name: nginx
        image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
        ports:
        - containerPort: 80

Exemple de Template de Service (service.yaml)​

apiVersion: v1
kind: Service
metadata:
  name: {{ .Release.Name }}-nginx
spec:
  type: {{ .Values.service.type }}
  ports:
  - port: {{ .Values.service.port }}
    targetPort: 80
  selector:
    app: {{ .Release.Name }}-nginx

Utilisation des Helpers​

Le fichier _helpers.tpl est utilisé pour définir des fonctions de template réutilisables, ce qui permet de rendre les templates plus propres et plus maintenables. Voici un exemple de _helpers.tpl :

{{- define "mychart.labels" -}}
app.kubernetes.io/name: {{ .Chart.Name }}
app.kubernetes.io/instance: {{ .Release.Name }}
app.kubernetes.io/version: {{ .Chart.AppVersion }}
app.kubernetes.io/managed-by: {{ .Release.Service }}
{{- end -}}

Packaging et Distribution​

Une fois que votre chart est prêt, vous pouvez le packager pour le distribuer. Utilisez la commande suivante pour créer un paquet .tgz de votre chart :

helm package mychart

Ce paquet peut être stocké dans un repository Helm, partagé avec d'autres utilisateurs ou déployé directement.

Déploiement de votre Chart​

Pour déployer votre chart personnalisé, utilisez la commande helm install :

helm install my-release ./mychart

Gestion des dépendances​

Lors de la création de charts Helm complexes, il est courant d'avoir des dépendances vers d'autres charts. Helm facilite la gestion de ces dépendances grâce à un fichier spécifique nommé Chart.yaml et à des commandes dédiées. Dans ce chapitre, je vais vous montrer comment définir et gérer les dépendances de vos charts Helm.

Définir les dépendances dans Chart.yaml​

Pour définir des dépendances pour votre chart, vous devez les spécifier dans le fichier Chart.yaml. Chaque dépendance est définie avec son nom, sa version et le repository où elle se trouve. Voici un exemple de Chart.yaml avec des dépendances :

apiVersion: v2
name: mychart
description: A Helm chart with dependencies
version: 0.1.0
appVersion: "1.16.0"

dependencies:
  - name: mysql
    version: 8.0.0
    repository: https://charts.bitnami.com/bitnami
  - name: redis
    version: 6.0.0
    repository: https://charts.bitnami.com/bitnami

Dans cet exemple, mychart dépend des charts mysql et redis qui sont hébergés dans le repository Bitnami.

Mise à jour des dépendances​

Après avoir défini les dépendances dans Chart.yaml, vous devez mettre à jour les dépendances pour les télécharger et les ajouter à votre chart. Utilisez la commande suivante pour cela :

helm dependency update

Cette commande télécharge les charts spécifiés et les place dans le répertoire charts/ de votre chart. Le répertoire charts/ contiendra alors les packages des dépendances nécessaires.

Gestion des versions des dépendances​

Spécifier des versions précises pour vos dépendances est important pour garantir la stabilité et la reproductibilité de vos déploiements. Utilisez les versions sémantiques pour définir les versions exactes des charts dont vous dépendez. Cela vous permet de contrôler les mises à jour et d'éviter les incompatibilités.

Installation des charts avec dépendances​

Lorsque vous installez un chart avec des dépendances, Helm gère automatiquement l'installation des dépendances définies. Par exemple, pour installer mychart avec ses dépendances, utilisez la commande suivante :

helm install my-release ./mychart

Helm déploiera d'abord les charts de dépendances (comme mysql et redis), puis déploiera mychart.

Mise à jour des dépendances lors de l'upgrade​

Lorsque vous mettez à jour votre chart ou ses dépendances, assurez-vous de mettre à jour les dépendances avec la commande helm dependency update avant de procéder à l'upgrade de la release. Ensuite, utilisez la commande helm upgrade pour appliquer les mises à jour :

helm upgrade my-release ./mychart

Exemple pratique​

Imaginons que vous ayez un chart nommé myapp qui dépend de postgresql pour la base de données. Voici comment vous pouvez définir et gérer cette dépendance :

  1. Ajoutez la dépendance dans Chart.yaml :

    dependencies:
  - name: postgresql
    version: 10.3.11
    repository: https://charts.bitnami.com/bitnami

  2. Mettez à jour les dépendances :

    helm dependency update

  3. Installez le chart avec ses dépendances :

    helm install myapp-release ./myapp

  4. Pour mettre à jour le chart ou ses dépendances, mettez à jour les dépendances et utilisez helm upgrade :

    helm dependency update
helm upgrade myapp-release ./myapp

Mise à jour et suppression des releases​

Une des forces de Helm est sa capacité à gérer facilement les mises à jour et les suppressions des applications déployées. Dans ce chapitre, je vais vous guider à travers les étapes nécessaires pour mettre à jour une release existante et la supprimer lorsqu'elle n'est plus nécessaire.

Mise à jour d'une release​

Mettre à jour une release Helm est une opération courante, que ce soit pour appliquer des correctifs, mettre à jour des configurations ou déployer de nouvelles versions de l'application.

Pour mettre à jour une release, utilisez la commande helm upgrade. Par exemple, pour mettre à jour une release nommée my-release avec un chart local nommé mychart, exécutez :

helm upgrade my-release ./mychart

Cette commande applique les modifications du chart à la release existante my-release.

Lors de la mise à jour, vous pouvez également passer un fichier de valeurs personnalisé ou des valeurs en ligne de commande pour modifier les configurations spécifiques :

helm upgrade my-release ./mychart -f custom-values.yaml

Ou :

helm upgrade my-release ./mychart --set replicaCount=5

Rollback d'une release​

Helm permet de revenir à une version précédente d'une release si une mise à jour provoque des problèmes. Cette fonctionnalité est essentielle pour maintenir la stabilité des applications en production.

Pour effectuer un rollback, utilisez la commande helm rollback suivie du nom de la release et du numéro de la révision. Par exemple, pour revenir à la révision 1 de my-release, utilisez :

helm rollback my-release 1

Helm restaurera la release à l'état de la révision spécifiée, annulant ainsi les modifications apportées par les mises à jour ultérieures.

Helm conserve un historique des révisions de chaque release, ce qui vous permet de suivre les modifications au fil du temps et d'effectuer des rollbacks en cas de besoin.

Pour afficher l'historique des révisions d'une release, utilisez la commande helm history :

helm history my-release

Cette commande affiche une liste des révisions, avec des informations sur chaque mise à jour, telles que le numéro de révision, la date et l'état.

Suppression d'une release​

Lorsque vous n'avez plus besoin d'une application, vous pouvez supprimer la release associée pour libérer les ressources du cluster Kubernetes.

Pour supprimer une release, utilisez la commande helm uninstall :

helm uninstall my-release

Cette commande supprime toutes les ressources Kubernetes associées à la release my-release.

Dans certains cas, il peut être nécessaire de forcer la suppression d'une release, par exemple si des ressources sont restées bloquées. Utilisez l'option --force pour forcer la suppression :

helm uninstall my-release --force

Nettoyage des ressources​

Après la suppression d'une release, il est recommandé de vérifier que toutes les ressources associées ont bien été supprimées. Utilisez kubectl pour lister et vérifier les ressources restantes :

kubectl get all -l app.kubernetes.io/instance=my-release

Utilisation avancée de Helm​

Helm offre une variété de fonctionnalités avancées qui permettent de gérer les déploiements Kubernetes de manière encore plus flexible et puissante. Dans ce chapitre, nous explorerons les hooks, les tests de charts et les meilleures pratiques de sécurité pour maximiser l'efficacité et la sécurité de vos déploiements Helm.

Helm Hooks​

Les hooks permettent d'exécuter des actions spécifiques à des moments particuliers du cycle de vie d'une release Helm. Ils peuvent être utilisés pour gérer des tâches comme les migrations de bases de données, les pré-requis ou les configurations post-déploiement.

Les hooks Helm :

  • pre-install
  • post-install
  • pre-delete
  • post-delete
  • pre-upgrade
  • post-upgrade

Exemple de hook pre-install​

Voici un exemple de configuration d'un hook qui exécute une tâche avant l'installation de la release :

apiVersion: v1
kind: Pod
metadata:
  name: "{{ .Release.Name }}-pre-install-hook"
  annotations:
    "helm.sh/hook": pre-install
spec:
  containers:
    - name: pre-install-task
      image: alpine
      command: ["/bin/sh", "-c", "echo Pre-install hook executed"]

Tests de Charts​

Helm permet également de définir des tests pour vérifier que les applications déployées fonctionnent correctement. Ces tests sont des pods spéciaux qui s'exécutent après le déploiement pour valider que tout fonctionne comme prévu.

Exemple de test​

Voici un exemple de configuration d'un test Helm :

apiVersion: v1
kind: Pod
metadata:
  name: "{{ .Release.Name }}-test-connection"
  labels:
    helm.sh/hook: test
spec:
  containers:
    - name: curl
      image: busybox
      command: ["curl"]
      args: ["{{ .Release.Name }}-nginx:80"]

Pour exécuter les tests, utilisez la commande suivante :

helm test my-release

Pratiques de Sécurité​

La sécurité est un aspect important de la gestion des déploiements Kubernetes avec Helm. Voici quelques meilleures pratiques pour sécuriser vos déploiements Helm :

Assurez-vous que les utilisateurs qui exécutent les commandes Helm disposent des permissions Kubernetes appropriées. Configurez les RBAC (Role-Based Access Control) pour contrôler l'accès et les actions possibles.

Helm permet de signer les charts pour garantir leur intégrité et leur authenticité. Utilisez les commandes helm package --sign pour signer un chart et helm verify pour vérifier les signatures.

Évitez de stocker des informations sensibles directement dans les fichiers values.yaml. Utilisez des Kubernetes Secrets pour stocker et gérer des informations sensibles de manière sécurisée.

Intégration avec CI/CD​

L'intégration de Helm dans vos pipelines CI/CD permet d'automatiser le déploiement et la gestion des applications. Utilisez des outils comme Jenkins, GitLab CI, ou GitHub Actions pour intégrer Helm dans vos workflows CI/CD.

Voici un exemple de configuration GitLab CI pour déployer une application avec Helm :

stages:
  - deploy

deploy:
  stage: deploy
  script:
    - helm repo add bitnami https://charts.bitnami.com/bitnami
    - helm repo update
    - helm upgrade --install my-release bitnami/nginx --version 8.8.0
  environment:
    name: production
    url: http://my-release.example.com

Utilisation des Environnements​

Helm permet de gérer les déploiements pour différents environnements (développement, test, production) en utilisant des fichiers de valeurs spécifiques à chaque environnement.

Créez des fichiers de valeurs pour chaque environnement, par exemple values-dev.yaml, values-prod.yaml, puis utilisez ces fichiers lors des déploiements :

helm install my-release ./mychart -f values-prod.yaml

Conclusion​

En conclusion, Helm est un outil essentiel pour gérer les déploiements d'applications sur Kubernetes. Il simplifie la gestion des configurations, des déploiements, des mises à jour et des rollbacks, tout en offrant des fonctionnalités avancées pour des environnements de production robustes et sécurisés. Grâce à Helm, vous pouvez définir des configurations standardisées et reproductibles pour vos applications, ce qui facilite leur gestion à grande échelle.

Helm est plus qu'un simple outil de gestion de paquets pour Kubernetes. Il représente une approche systématique et structurée pour gérer les déploiements d'applications conteneurisées, rendant le processus plus cohérent et prévisible. En maîtrisant Helm, vous améliorez non seulement l'efficacité de vos déploiements, mais aussi la résilience et la sécurité de vos applications en production.

En adoptant Helm et en suivant les meilleures pratiques, vous serez bien équipé pour gérer vos déploiements Kubernetes de manière efficace et sécurisée, tout en restant agile face aux évolutions de vos applications et de votre infrastructure.

Plus d'infos​

Pour approfondir vos connaissances sur Helm, voici quelques ressources essentielles :

Ces ressources offrent des guides détaillés, des exemples et des informations à jour pour vous aider à tirer le meilleur parti de Helm.