Exécution de plusieurs commandes et gestion des échecs de démarrage
Dans cette étape, nous allons apprendre à exécuter plusieurs commandes au démarrage d'un Pod et à gérer les échecs de démarrage à l'aide de vérifications de santé.
Exécution de plusieurs commandes
Souvent, vous avez besoin d'exécuter plusieurs commandes lorsque le conteneur démarre. Il existe plusieurs façons de le faire dans Kubernetes :
- Chaîner les commandes à l'aide d'opérateurs shell (
&&, ;, etc.)
- Utiliser un fichier de script
- Utiliser un conteneur d'initialisation
Explorons la première méthode en examinant le fichier multi-command-pod.yaml :
nano multi-command-pod.yaml
Vous verrez :
apiVersion: v1
kind: Pod
metadata:
name: multi-command-pod
spec:
containers:
- name: ubuntu
image: ubuntu:20.04
command: ["/bin/bash", "-c"]
args:
[
"echo 'First command' > /tmp/first.txt && echo 'Second command' > /tmp/second.txt && sleep 3600"
]
Cette configuration chaîne plusieurs commandes à l'aide de l'opérateur &&, qui exécute chaque commande seulement si la précédente a réussi.
Appuyez sur Ctrl+X pour quitter l'éditeur.
Créons ce Pod :
kubectl apply -f multi-command-pod.yaml
Vous devriez voir :
pod/multi-command-pod created
Vérifions maintenant que les deux commandes se sont exécutées en vérifiant les fichiers créés :
kubectl exec multi-command-pod -- cat /tmp/first.txt
Vous devriez voir :
First command
Et pour le deuxième fichier :
kubectl exec multi-command-pod -- cat /tmp/second.txt
Vous devriez voir :
Second command
Gestion des échecs de démarrage avec des vérifications de santé
Kubernetes propose des mécanismes pour détecter et gérer les échecs de démarrage :
- Liveness Probes (Vérifications de vitalité) : Vérifient si le conteneur est en cours d'exécution ; sinon, Kubernetes le redémarre
- Readiness Probes (Vérifications de préparation) : Vérifient si le conteneur est prêt à recevoir le trafic
- Startup Probes (Vérifications de démarrage) : Vérifient si l'application a démarré ; utiles pour les conteneurs qui démarrent lentement
Examinons un Pod qui utilise une vérification de vitalité :
nano liveness-probe-pod.yaml
Vous verrez :
apiVersion: v1
kind: Pod
metadata:
name: liveness-probe-pod
spec:
containers:
- name: ubuntu
image: ubuntu:20.04
command: ["/bin/bash", "-c"]
args: ["touch /tmp/healthy && sleep 3600"]
livenessProbe:
exec:
command: ["cat", "/tmp/healthy"]
initialDelaySeconds: 5
periodSeconds: 5
Dans cette configuration :
- Le conteneur crée un fichier
/tmp/healthy au démarrage
- La vérification de vitalité vérifie la présence de ce fichier toutes les 5 secondes
- Si le fichier est manquant, Kubernetes considère le conteneur comme défaillant et le redémarre
Appuyez sur Ctrl+X pour quitter l'éditeur.
Créons ce Pod :
kubectl apply -f liveness-probe-pod.yaml
Vous devriez voir :
pod/liveness-probe-pod created
Vérifions que le Pod est en cours d'exécution :
kubectl get pods liveness-probe-pod
Vous devriez voir :
NAME READY STATUS RESTARTS AGE
liveness-probe-pod 1/1 Running 0 30s
Voyons maintenant ce qui se passe si nous supprimons le fichier de vérification de santé :
kubectl exec liveness-probe-pod -- rm /tmp/healthy
Attendez environ 10 secondes, puis vérifiez à nouveau l'état du Pod :
kubectl get pods liveness-probe-pod
Vous devriez voir que le conteneur a été redémarré :
NAME READY STATUS RESTARTS AGE
liveness-probe-pod 1/1 Running 1 60s
Le nombre de redémarrages (RESTARTS) est passé à 1, ce qui indique que Kubernetes a détecté l'état défaillant et a redémarré le conteneur.
Vérifions que le fichier de vérification de santé existe à nouveau (il devrait avoir été recréé par la commande de démarrage lors du redémarrage du conteneur) :
kubectl exec liveness-probe-pod -- ls -la /tmp/healthy
Vous devriez voir que le fichier existe à nouveau :
-rw-r--r-- 1 root root 0 Sep 21 10:30 /tmp/healthy
Cela montre comment Kubernetes peut se rétablir automatiquement des échecs de démarrage et maintenir l'état souhaité de vos applications.
Création d'un script de démarrage personnalisé
Pour des initialisations plus complexes, vous pouvez vouloir utiliser un script de démarrage personnalisé. Créons un Pod qui utilise un script shell pour le démarrage :
nano script-pod.yaml
Ajoutez le contenu suivant :
apiVersion: v1
kind: Pod
metadata:
name: script-pod
spec:
containers:
- name: ubuntu
image: ubuntu:20.04
command: ["/bin/bash", "-c"]
args:
- |
cat > /tmp/startup.sh << 'EOF'
#!/bin/bash
echo "Script started at $(date)" > /tmp/script-log.txt
echo "Creating configuration files..." >> /tmp/script-log.txt
mkdir -p /tmp/config
echo "app_name=MyApp" > /tmp/config/app.conf
echo "version=1.0" >> /tmp/config/app.conf
echo "Script completed successfully" >> /tmp/script-log.txt
EOF
chmod +x /tmp/startup.sh
/tmp/startup.sh
sleep 3600
Cette configuration :
- Crée un script de démarrage dans le conteneur
- Le rend exécutable
- Exécute le script
- Maintient le conteneur en cours d'exécution avec la commande
sleep
Enregistrez et quittez avec Ctrl+X, puis Y et Entrée.
Créons ce Pod :
kubectl apply -f script-pod.yaml
Vous devriez voir :
pod/script-pod created
Attendez un moment que le Pod démarre, puis vérifiez son état :
kubectl get pods script-pod
Vous devriez voir :
NAME READY STATUS RESTARTS AGE
script-pod 1/1 Running 0 30s
Vérifions maintenant la sortie de notre script :
kubectl exec script-pod -- cat /tmp/script-log.txt
Vous devriez voir quelque chose comme :
Script started at Tue Sep 21 10:35:42 UTC 2023
Creating configuration files...
Script completed successfully
Et vérifions que le fichier de configuration a été créé :
kubectl exec script-pod -- cat /tmp/config/app.conf
Vous devriez voir :
app_name=MyApp
version=1.0
Cela montre comment utiliser des scripts de démarrage complexes pour initialiser vos conteneurs dans Kubernetes.
