Créer et déboguer un StatefulSet Kubernetes

Dans un StatefulSet Kubernetes, chaque pod possède un nom d’hôte unique et stable ainsi qu’une identité DNS complète. Cette ID est conservée au fil des redémarrages et des mises à l’échelle.

Qu’est-ce qu’un StatefulSet Kubernetes ?

Les StatefulSets Kubernetes sont des entités spéciales permettant de gérer des applications qui ont des exigences particulières en matière de données persistantes et d’identités fixes. Ces ensembles garantissent que les pods avec des réplicas sont démarrés dans un ordre précis. Ils attribuent à chaque pod Kubernetes un identifiant unique ainsi qu’un accès au stockage persistant. De telles fonctions sont utiles pour les bases de données qui dépendent de relations stables entre les instances et qui doivent stocker des données durables. Un StatefulSet représente donc une solution efficace pour l’orchestration et l’exploitation d’applications complexes dans Kubernetes.

Créer un StatefulSet Kubernetes

Tout d’abord, nous commençons par définir un fichier de configuration YAML, dans lequel nous définissons les propriétés souhaitées du StatefulSet et créons des pods Kubernetes. Après la configuration, le StatefulSet surveille en permanence l’état du cluster, ainsi que si le nombre prédéfini de pods est toujours en état de marche et disponible. En cas de panne d’un pod ou d’éloignement du nœud, le StatefulSet détecte automatiquement les défaillances et prend les mesures nécessaires : il initie alors le déploiement d’un nouveau pod avec le même identifiant unique. Ce nouveau pod est connecté au stockage persistant déjà existant et reçoit la configuration identique à celle du pod initial. Cela inclut les demandes et les limites de ressources.

Cette gestion précise des pods et de leur identité est essentielle pour que les clients qui étaient auparavant servis par le pod indisponible puissent être redirigés vers le nouveau pod sans interruption. L’accès au stockage persistant garantit que les opérations continuent de fonctionner sans problème.

Voici un fichier YAML complet qui illustre les étapes de la création d’un StatefulSet Kubernetes pour Nginx :

apiVersion: apps/v1
kind: StatefulSet
metadata:
    name: nginx-statefulset
spec:
    serviceName: nginx
    replicas: 3
    selector:
        matchLabels:
            app: nginx
    template:
        metadata:
            labels:
                app: nginx
        spec:
            containers:
            - name: nginx
                image: nginx:latest
                volumeMounts:
                - name: nginx-config
                    mountPath: /etc/nginx/conf.d
                - name: nginx-html
                    mountPath: /usr/share/nginx/html
    volumeClaimTemplates:
    - metadata:
            name: nginx-html
        spec:
            accessModes: [ "ReadWriteOnce" ]
            resources:
                requests:
                    storage: 1Gi
    - metadata:
            name: nginx-config
        spec:
            accessModes: [ "ReadWriteOnce" ]
            resources:
                requests:
                    storage: 1Gi

Ce document YAML définit un StatefulSet Kubernetes pour Nginx avec trois réplicas. Il utilise un objet de service appelé « nginx » et des étiquettes pour identifier correctement les pods. Ces derniers utilisent la dernière image de Nginx et ont deux volumes pour la configuration et les fichiers HTML. Les VolumeClaimTemplates assurent un stockage persistant pour ces volumes d’une taille de 1 Go et permettent l’accès ReadWriteOnce.

Débogage d’un StatefulSet

Le débogage des StatefulSets dans Kubernetes nécessite des étapes spécifiques pour vérifier que les pods sont correctement initialisés et vous permettre d’identifier et de corriger les erreurs si nécessaire.

Étape 1 : lister les pods

Avant de commencer le débogage d’un StatefulSet, vous devez contrôler l’état des pods.

Ouvrez la ligne de commande et utilisez la commande suivante pour lister tous les pods dans le StatefulSet souhaité :

kubectl get pods -l app=statefulset-label

La sortie sera alors :

NAME                         READY      STATUS    RESTARTS   AGE 
nginx-statefulset-0           1/1      Running       0       2m 
nginx-statefulset-1           1/1      Running       0       1m 
nginx-statefulset-2           1/1      Running       0       1m

• NAME : chaque pod reçoit un nom unique, basé sur le schéma de nommage du StatefulSet et un numéro séquentiel.
• READY : indique combien de conteneurs souhaités sont prêts dans le pod. Dans l’exemple, chaque pod a un conteneur, et 1/1 signifie que le conteneur est prêt à être utilisé.
• STATUS : indique l’état actuel du pod.
• RESTARTS : indique combien de fois le conteneur a été redémarré dans le pod. Une valeur de 0 signifie qu’il n’y a pas eu de redémarrage jusqu’à présent.
• AGE : indique depuis combien de temps le pod fonctionne.

Messages d’état indiquant des erreurs :

• Failed (échec) : un ou plusieurs conteneurs dans le pod ont provoqué une erreur qui a entraîné l’échec du pod. Cela peut être dû à différentes raisons, comme des dépendances manquantes ou des problèmes de configuration.
• Unknown (inconnu) : l’état du pod n’a pas pu être déterminé. Cela peut indiquer un problème de communication entre le cluster Kubernetes et le pod ; des problèmes de réseau, un manque de permissions ou d’autres facteurs peuvent en être la cause.

Dans les deux cas, il est important d’utiliser des outils de diagnostic précis comme l’examen des logs du pod ou la commande kubectl describe pod pour obtenir plus de détails et déterminer les causes des erreurs.

Étape 2 : déboguer les pods individuels

Ajouter des annotations à un pod peut être un outil de débogage utile pour influencer le processus d’initialisation ou déclencher des actions spéciales.

Tout d’abord, vous devez identifier le nom du pod que vous souhaitez déboguer.

kubectl get pods

Notez le nom du pod que vous voulez déboguer.

Tapez maintenant la commande suivante dans le terminal pour définir l’annotation du pod sélectionné :

kubectl annotate pods [pod-name] pod.alpha.kubernetes.io/initialized="false" --overwrite

Remplacez [pod-name] par le nom réel du pod. Cette annotation met l’état d’initialisation à false, ce qui signifie que le pod est marqué comme non initialisé.

Surveillez le pod pour voir comment l’annotation affecte son comportement. En particulier, vous pouvez vérifier les événements du pod et les logs :

kubectl describe pod [pod-name]
kubectl logs [pod-name]

Regardez s’il y a des événements ou des sorties de logs qui pourraient déclencher des problèmes pendant le processus d’initialisation. Lorsque le débogage est terminé et que vous souhaitez rétablir le processus d’initialisation normal, remettez l’annotation à true.

Étape 3 : initialisation

Si le débogage du pod avec les techniques décrites précédemment a échoué, cela peut indiquer des conditions de course pendant le processus d’initialisation (bootstrap) du StatefulSet. Pour surmonter ce problème, vous pouvez spécifier initialized="false" dans le manifeste du StatefulSet Kubernetes et le créer ensuite dans le cluster avec cette annotation.

apiVersion: apps/v1
kind: StatefulSet
metadata:
    name: [statefulset-name]
spec:
    template:
        metadata:
            annotations:
                pod.alpha.kubernetes.io/initialized: "false"
        ...

Appliquer le manifeste mis à jour sur votre cluster Kubernetes :

kubectl apply -f statefulset.yaml

Inspectez les pods et identifiez les éventuelles sources d’erreur. Effectuez le débogage nécessaire en vous basant sur les événements et les logs observés. Supprimez éventuellement les pods avec kubectl delete statefulsets ou kubectl delete service.

Une fois le débogage terminé, vous pouvez supprimer l’annotation « initialized » et mettre à jour le Kubernetes StatefulSet dans le cluster :

kubectl annotate pods [pod-name] pod.alpha.kubernetes.io/initialized="true" --overwrite

Cette commande définit l’annotation « initialized » d’un pod à true, tout en s’assurant que les valeurs existantes sont écrasées. Après avoir vérifié le premier pod, le StatefulSet Kubernetes initialisera automatiquement le pod suivant. Vous pouvez alors répéter les étapes de débogage pour chaque autre pod du StatefulSet.

Dans notre tutoriel Kubernetes, vous trouverez des informations détaillées et pratiques sur la mise en place d’un cluster Kubernetes.