Introduction
Les précédents laboratoires de déploiement utilisaient directement des manifestes Kubernetes bruts. Helm ajoute une couche de packaging autour de ces manifestes. Un chart Helm regroupe des modèles Kubernetes associés, expose des paramètres réutilisables dans values.yaml et installe les objets générés sous forme de release nommée.
Dans ce laboratoire, vous allez créer un petit chart local au lieu d'en télécharger un depuis un dépôt. Vous rédigerez les métadonnées du chart, les valeurs, le modèle de Deployment et le modèle de Service. Vous générerez le chart avant de l'installer, puis vous mettrez à jour la release en modifiant les valeurs. Cela permet de se concentrer sur la compétence CKAD clé : comprendre comment un chart local se transforme en objets Kubernetes ordinaires.
Préparer un espace de travail Helm
Dans cette étape, vous allez préparer un namespace et confirmer que les outils nécessaires au flux de travail d'un chart Helm local sont présents.
Commencez dans /home/labex/project. Ce laboratoire conserve le répertoire du chart, les manifestes générés et toutes les commandes dans cet espace de travail.
mkdir -p /home/labex/project
cd /home/labex/project
Vérifiez que l'API server de Kubernetes est accessible. Si la machine virtuelle vient de démarrer et que le nœud n'est pas encore prêt, attendez quelques secondes et relancez la commande.
kubectl get nodes --request-timeout=5s
La sortie attendue inclut :
NAME STATUS ROLES AGE VERSION
labex-v135 Ready control-plane ... v1.35...
Attendez que le Pod réseau du cluster soit prêt. Le chart créera un Service, les Pods de l'application ont donc besoin du réseau du cluster pour que les tests de trafic soient pertinents.
kubectl wait --namespace kube-system --for=condition=Ready pod -l k8s-app=calico-node --timeout=120s
Sortie attendue :
pod/calico-node-... condition met
Créez un namespace nommé ckad-prep-helm et définissez-le comme namespace par défaut :
kubectl create namespace ckad-prep-helm
kubectl config set-context --current --namespace=ckad-prep-helm
Confirmez le namespace actuel et la version du client Helm. Helm 3 fonctionne directement avec Kubernetes en utilisant votre kubeconfig actuel ; il n'y a pas de composant Tiller côté serveur.
kubectl config view --minify --output 'jsonpath={..namespace}'; echo
helm version --short
La sortie attendue inclut :
ckad-prep-helm
v...
Créer et générer un chart local
Dans cette étape, vous allez créer un chart Helm local minimal et le générer avant d'installer quoi que ce soit.
Un répertoire de chart comporte quelques parties importantes. Chart.yaml décrit le chart lui-même. values.yaml contient les paramètres par défaut. Les fichiers sous templates/ sont des manifestes Kubernetes contenant des expressions de modèle telles que {{ .Values.replicaCount }}. Helm remplace ces expressions par des valeurs concrètes lors de la génération ou de l'installation du chart.
Créez le répertoire du chart :
mkdir -p local-web-chart/templates
Créez Chart.yaml. Le nom du chart n'est pas le même que le nom de la release ; le nom de la release est choisi ultérieurement lors de l'installation du chart.
cat > local-web-chart/Chart.yaml <<'EOF'
apiVersion: v2
name: local-web
description: A small local chart for CKAD deployment practice
type: application
version: 0.1.0
appVersion: "1.0"
EOF
Créez values.yaml. Ces valeurs par défaut contrôlent le nombre de Pods, l'image du conteneur, les ports du Service et le message servi par l'application.
cat > local-web-chart/values.yaml <<'EOF'
replicaCount: 2
image:
repository: busybox
tag: "1.36"
service:
port: 80
targetPort: 8080
message: helm-v1
EOF
Créez le modèle de Deployment. Le modèle utilise le nom de la release dans les noms d'objets et les labels, afin que le même chart puisse être installé sous différents noms de release.
cat > local-web-chart/templates/deployment.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
name: {{ .Release.Name }}-web
labels:
app.kubernetes.io/name: {{ .Chart.Name }}
app.kubernetes.io/instance: {{ .Release.Name }}
spec:
replicas: {{ .Values.replicaCount }}
selector:
matchLabels:
app.kubernetes.io/name: {{ .Chart.Name }}
app.kubernetes.io/instance: {{ .Release.Name }}
template:
metadata:
labels:
app.kubernetes.io/name: {{ .Chart.Name }}
app.kubernetes.io/instance: {{ .Release.Name }}
spec:
terminationGracePeriodSeconds: 0
containers:
- name: web
image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
imagePullPolicy: IfNotPresent
command:
- /bin/sh
- -c
- |
mkdir -p /www
echo {{ .Values.message | quote }} > /www/index.html
httpd -f -p {{ .Values.service.targetPort }} -h /www
ports:
- containerPort: {{ .Values.service.targetPort }}
readinessProbe:
httpGet:
path: /
port: {{ .Values.service.targetPort }}
initialDelaySeconds: 1
periodSeconds: 2
EOF
Créez le modèle de Service. Notez que le sélecteur du Service utilise les mêmes labels que le modèle de Pod.
cat > local-web-chart/templates/service.yaml <<'EOF'
apiVersion: v1
kind: Service
metadata:
name: {{ .Release.Name }}
labels:
app.kubernetes.io/name: {{ .Chart.Name }}
app.kubernetes.io/instance: {{ .Release.Name }}
spec:
selector:
app.kubernetes.io/name: {{ .Chart.Name }}
app.kubernetes.io/instance: {{ .Release.Name }}
ports:
- port: {{ .Values.service.port }}
targetPort: {{ .Values.service.targetPort }}
EOF
Exécutez helm lint pour détecter les problèmes de structure du chart et de modèles :
helm lint ./local-web-chart
La sortie attendue inclut :
1 chart(s) linted, 0 chart(s) failed
Générez le chart localement. helm template affiche le YAML Kubernetes que Helm enverrait à l'API server, mais ne crée aucun objet.
helm template local-web ./local-web-chart | sed -n '1,120p'
La sortie attendue inclut un Service nommé local-web et un Deployment nommé local-web-web.
Installer le chart en tant que release
Dans cette étape, vous allez installer le chart local dans le namespace ckad-prep-helm.
L'installation d'un chart crée une release Helm. Le nom de la release est local-web dans ce laboratoire. Helm enregistre les métadonnées de la release et Kubernetes reçoit des objets ordinaires tels qu'un Deployment et un Service.
Installez le chart :
helm install local-web ./local-web-chart
La sortie attendue inclut :
NAME: local-web
STATUS: deployed
Attendez le déploiement créé par le chart :
kubectl rollout status deployment/local-web-web --timeout=120s
Sortie attendue :
deployment "local-web-web" successfully rolled out
Inspectez la release et les objets Kubernetes qu'elle a créés :
helm list
kubectl get deployment,service -l app.kubernetes.io/instance=local-web
La sortie attendue inclut :
local-web
deployment.apps/local-web-web
service/local-web
Créez un Pod client et envoyez une requête au Service. Cela confirme que le chart n'a pas seulement créé des objets, mais que l'application installée est réellement accessible.
kubectl run chart-client --image=busybox:1.36 --restart=Never --command -- sleep 3600
kubectl wait --for=condition=Ready pod/chart-client --timeout=120s
kubectl exec chart-client -- wget -qO- http://local-web
Sortie attendue :
helm-v1
Mettre à jour la release avec de nouvelles valeurs
Dans cette étape, vous allez mettre à jour la release existante en remplaçant les valeurs du chart.
Le chart contient déjà des modèles réutilisables. Vous n'avez pas besoin de modifier les fichiers de modèle pour changer le message ou le nombre de réplicas. helm upgrade génère à nouveau le même chart avec de nouvelles valeurs, met à jour les objets Kubernetes et enregistre une nouvelle révision de la release.
Mettez à jour la release pour qu'elle serve helm-v2 avec trois réplicas :
helm upgrade local-web ./local-web-chart --set message=helm-v2 --set replicaCount=3
La sortie attendue inclut :
Release "local-web" has been upgraded.
STATUS: deployed
Attendez le déploiement mis à jour :
kubectl rollout status deployment/local-web-web --timeout=120s
Sortie attendue :
deployment "local-web-web" successfully rolled out
Inspectez l'historique de la release et les valeurs actuellement stockées avec celle-ci :
helm history local-web
helm get values local-web
La sortie attendue inclut deux révisions et les valeurs remplacées :
REVISION
1
2
message: helm-v2
replicaCount: 3
Vérifiez le Deployment en cours d'exécution et la réponse de l'application :
kubectl get deployment local-web-web
kubectl exec chart-client -- wget -qO- http://local-web
La sortie attendue inclut :
3/3
helm-v2
Résumé
Vous avez créé un chart Helm local à partir de métadonnées, de valeurs par défaut et de modèles Kubernetes. Vous avez généré le chart avant de l'installer, vous l'avez installé en tant que release, testé le Service et mis à jour la release en remplaçant les valeurs. L'idée clé est que Helm permet de packager des déploiements d'applications répétables tout en produisant des objets Kubernetes ordinaires que vous pouvez inspecter avec kubectl.
