Créer et personnaliser des Charts Helm

Apprenez à créer vos propres Charts Helm pour packager vos applications Kubernetes et à les personnaliser grâce au templating et aux fichiers de valeurs (values.yaml).

Devenir créateur de Charts : Packager vos propres applications

Utiliser des Charts Helm existants est un excellent moyen de déployer rapidement des logiciels tiers. Cependant, la véritable puissance de Helm se révèle lorsque vous commencez à créer vos propres Charts pour packager vos applications développées en interne. Cela vous permet de standardiser vos déploiements, de les rendre configurables pour différents environnements et de faciliter leur partage au sein de votre organisation.

Cette section vous guide à travers le processus de création d'un Chart Helm simple, en expliquant comment structurer votre Chart, comment utiliser le système de templating pour rendre vos manifestes dynamiques, et comment exposer des paramètres de configuration pour la personnalisation.

Démarrer rapidement avec `helm create`

Helm fournit une commande très pratique pour générer une structure de Chart de base, ce qui vous évite de devoir créer tous les fichiers et répertoires manuellement. Pour créer un nouveau Chart nommé `mon-app-chart`, exécutez simplement :

helm create mon-app-chart

Cela créera un répertoire `mon-app-chart/` avec la structure standard que nous avons vue précédemment, incluant :

Chart.yaml : Pré-rempli avec le nom du chart et une version initiale.
values.yaml : Contient des exemples de valeurs de configuration courantes (replicaCount, image.repository, image.tag, service.type, service.port, ingress.enabled, resources, etc.). C'est un excellent point de départ pour comprendre quels paramètres sont typiquement exposés.
templates/ : Contient des modèles de manifestes courants (Deployment, Service, Ingress, ServiceAccount, HorizontalPodAutoscaler, NOTES.txt) qui utilisent déjà les valeurs définies dans values.yaml.
.helmignore : Similaire à .gitignore, spécifie les fichiers à ignorer lors du packaging du Chart.

Même si vous partez de manifestes existants, utiliser helm create puis adapter les modèles générés est souvent plus rapide que de tout recréer.

Le coeur du Chart : les modèles `templates/` et `values.yaml`

La magie de Helm réside dans la combinaison des modèles du répertoire templates/ et des valeurs définies (ou surchargées) dans values.yaml. Les fichiers dans templates/ ne sont pas des fichiers YAML statiques, mais des modèles qui seront traités par le moteur de templating de Helm (basé sur Go templates) avant d'être envoyés à l'API Kubernetes.

Syntaxe de base du templating : Les instructions de templating sont placées entre doubles accolades {{ }}. Pour accéder aux valeurs définies dans values.yaml, vous utilisez la notation .Values suivi du chemin vers la valeur. Par exemple :

# Dans templates/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ .Release.Name }}-{{ .Chart.Name }}
spec:
  replicas: {{ .Values.replicaCount }} # Utilise la valeur de replicaCount définie dans values.yaml
  selector:
    matchLabels:
      app: {{ .Release.Name }}-{{ .Chart.Name }}
  template:
    metadata:
      labels:
        app: {{ .Release.Name }}-{{ .Chart.Name }}
    spec:
      containers:
        - name: {{ .Chart.Name }}
          image: "{{ .Values.image.repository }}:{{ .Values.image.tag | default .Chart.AppVersion }}" # Utilise image.repository et image.tag
          ports:
            - containerPort: {{ .Values.service.internalPort }} # Exemple d'une autre valeur
          resources:
            {{- toYaml .Values.resources | nindent 12 }} # Inclut une section entière de values.yaml

Objets intégrés : Helm fournit plusieurs objets intégrés accessibles dans les templates, comme :

.Values : L'objet contenant toutes les valeurs (par défaut et surchargées).
.Release : Contient des informations sur la Release en cours (.Release.Name, .Release.Namespace, .Release.IsUpgrade, etc.).
.Chart : Contient les informations de Chart.yaml (.Chart.Name, .Chart.Version, .Chart.AppVersion).
.Files : Permet d'accéder au contenu d'autres fichiers dans le Chart.
.Capabilities : Fournit des informations sur les capacités du cluster Kubernetes cible (.Capabilities.KubeVersion.Version, .Capabilities.ApiVersions.Has).

Fonctions et Pipelines : Helm supporte l'utilisation de fonctions (plus de 60 fonctions de Sprig, plus des fonctions spécifiques à Helm comme include, required, toYaml, lookup) et de pipelines (|) pour transformer les valeurs. Par exemple, {{ .Values.image.tag | default .Chart.AppVersion }} utilise la fonction default pour fournir une valeur de repli si .Values.image.tag n'est pas défini.

Structures de contrôle : Vous pouvez utiliser des conditions (if/else), des boucles (range) et définir des variables ({{ $var := .Values.xyz }}) pour créer des modèles plus complexes et conditionnels.

Personnaliser l'installation : Surcharger les valeurs

Le fichier values.yaml contient les valeurs par défaut. C'est la force de Helm : un utilisateur peut facilement personnaliser une installation sans modifier le Chart lui-même. Il existe plusieurs façons de surcharger les valeurs par défaut lors de l'installation (helm install) ou de la mise à niveau (helm upgrade) :

Via un fichier YAML personnalisé (-f ou --values) : C'est la méthode la plus courante et recommandée pour des configurations complexes ou spécifiques à un environnement. Créez un fichier (par exemple, prod-values.yaml) contenant uniquement les valeurs que vous souhaitez surcharger.
```
# prod-values.yaml
replicaCount: 3
image:
  tag: "1.2.3"
resources:
  limits:
    cpu: 500m
    memory: 1Gi
  requests:
    cpu: 250m
    memory: 512Mi
```
```
helm install my-prod-release mon-app-chart -f prod-values.yaml
```
Vous pouvez spécifier plusieurs fichiers -f. Les valeurs sont fusionnées, la dernière l'emportant en cas de conflit.
Via la ligne de commande (--set) : Pour surcharger rapidement des valeurs individuelles. La syntaxe utilise la notation par points.
```
helm install my-dev-release mon-app-chart --set replicaCount=1 --set image.tag=latest
```
Via la ligne de commande pour les chaînes (--set-string) : Utile si vous voulez forcer une valeur à être interprétée comme une chaîne de caractères, même si elle ressemble à un nombre.
```
helm install my-release mon-app-chart --set-string image.tag="12345"
```
Via la ligne de commande pour les fichiers (--set-file) : Permet de charger le contenu d'un fichier comme valeur (par exemple, pour injecter un certificat ou un fichier de configuration volumineux).
```
helm install my-release mon-app-chart --set-file config\.txt=./my-config.txt
```

L'ordre de priorité des valeurs est le suivant (la plus élevée l'emporte) : --set / --set-string / --set-file > Fichiers -f (le dernier spécifié a la priorité la plus haute) > values.yaml du Chart.

Gérer les dépendances (Sous-charts)

Votre application peut dépendre d'autres services (par exemple, une base de données PostgreSQL ou Redis). Au lieu de réinventer la roue, vous pouvez déclarer ces dépendances dans votre fichier Chart.yaml :

# mon-app-chart/Chart.yaml
apiVersion: v2
name: mon-app-chart
version: 0.1.0
appVersion: "1.0"
dependencies:
  - name: redis
    version: "18.x.x" # Version du chart Redis requise
    repository: "https://charts.bitnami.com/bitnami" # URL du repository du chart Redis
    condition: redis.enabled # N'inclut Redis que si redis.enabled est true dans les valeurs

Après avoir déclaré les dépendances, vous devez les télécharger dans le répertoire charts/ de votre Chart en utilisant :

helm dependency update mon-app-chart/

Lors de l'installation de mon-app-chart, Helm installera également le Chart Redis (sauf si redis.enabled est mis à false dans les valeurs). Vous pouvez configurer le sous-chart Redis en utilisant une section dédiée dans le fichier values.yaml de votre Chart principal :

# mon-app-chart/values.yaml
replicaCount: 1
# ... autres valeurs pour mon-app-chart

redis:
  enabled: true
  # Valeurs spécifiques pour surcharger le chart Redis
  architecture: standalone
  auth:
    enabled: false
  # ...

Bonnes pratiques pour la création de Charts

Pour créer des Charts robustes et faciles à utiliser :

Lint et Test : Utilisez helm lint mon-chart/ pour vérifier les erreurs de syntaxe et les bonnes pratiques. Utilisez helm template mon-chart/ --debug pour voir les manifestes générés et déboguer vos modèles sans les appliquer au cluster.
Valeurs explicites : Exposez clairement les paramètres configurables dans values.yaml avec des commentaires explicatifs. Evitez de coder en dur des valeurs dans les modèles si elles sont susceptibles de changer.
Nommage cohérent : Utilisez les objets .Release.Name et .Chart.Name pour préfixer vos ressources afin d'éviter les collisions de noms, surtout si le Chart peut être installé plusieurs fois.
Simplicité : Ne rendez pas vos templates inutilement complexes. Utilisez les fonctions et les structures de contrôle à bon escient.
Gestion des Secrets : Ne mettez jamais de données sensibles directement dans values.yaml. Utilisez des références à des Secrets Kubernetes existants ou des mécanismes comme Helm Secrets (un plugin) ou des solutions externes pour gérer les secrets.
Documentation : Ecrivez un bon README.md et commentez votre values.yaml pour expliquer comment utiliser et configurer votre Chart.

Créer et personnaliser des Charts Helm est une compétence fondamentale pour quiconque travaille sérieusement avec Kubernetes. Cela permet d'adopter une approche Infrastructure as Code pour vos déploiements applicatifs, améliorant la fiabilité, la réutilisabilité et l'efficacité opérationnelle.

◄ Précédent Suivant ►

く