Kubernetes StatefulSet erstellen und debuggen

Jeder Pod in einem Kubernetes StatefulSet besitzt einen eindeutigen und stabilen Hostnamen sowie eine vollständige DNS-Identität. Diese ID bleibt über Neustarts und Skalierungen hinweg erhalten.

Was sind Kubernetes StatefulSets?

Kubernetes StatefulSets sind spezielle Entitäten, um Anwendungen zu managen, die besondere Anforderungen an persistente Daten und feste Identitäten haben. Diese Sets stellen sicher, dass Pods mit Replikaten in einer bestimmten Reihenfolge gestartet werden. Sie weisen jedem Kubernetes Pod eine eindeutige ID sowie Zugriff auf persistenten Speicher zu. Solche Funktionen sind nützlich für Datenbanken, die auf stabile Beziehungen zwischen Instanzen angewiesen sind und dauerhafte Daten speichern müssen. StatefulSets repräsentieren somit eine effektive Lösung für die Orchestrierung und den Betrieb von komplexen Anwendungen in Kubernetes.

So erstellen Sie ein Kubernetes StatefulSet

Zuerst beginnen wir mit der Definition einer YAML-Konfigurationsdatei, in der wir die gewünschten Eigenschaften des StatefulSets festlegen und Kubernetes Pods erstellen. Nach der Konfiguration überwacht das StatefulSet kontinuierlich den Cluster-Status und ob die vordefinierte Anzahl von Pods stets lauffähig und verfügbar ist. Im Falle eines Pod-Ausfalls oder einer Entfernung vom Node erkennt das StatefulSet die Situation automatisch. Es initiiert die Bereitstellung eines neuen Pods mit derselben eindeutigen ID. Dieser neue Pod wird mit dem bereits vorhandenen persistenten Speicher verbunden und erhält die identische Konfiguration wie der ursprüngliche Pod. Dazu gehören auch Ressourcenanfragen und -limits.

Diese präzise Handhabung von Pods und deren Identität ist entscheidend, damit Clients, die zuvor von dem nicht verfügbaren Pod bedient wurden, ohne Unterbrechungen auf den neuen Pod umgeleitet werden können. Der Zugriff auf den persistenten Speicher gewährleistet, dass Vorgänge weiterhin reibungslos funktionieren.

Hier ist eine vollständige YAML-Datei, die die Schritte für die Erstellung eines Kubernetes StatefulSets für Nginx veranschaulicht:

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
    volumeClaimTemplates:
    - metadata:
            name: nginx-config
        spec:
            accessModes: [ "ReadWriteOnce" ]
            resources:
                requests:
                    storage: 1Gi

Dieses YAML-Dokument definiert ein Kubernetes StatefulSet für Nginx mit drei Replikaten. Es setzt ein Service-Objekt namens nginx und Labels ein, um die Pods korrekt zu identifizieren. Letztere verwenden das neueste Nginx-Image und haben zwei Volumen für die Konfiguration und HTML-Dateien. Die VolumeClaimTemplates sichern persistenten Speicher für diese Volumen mit einer Größe von 1 Gigabyte und erlauben den Zugriff ReadWriteOnce.

Debugging von StatefulSets

Das Debugging von StatefulSets in Kubernetes erfordert spezifische Schritte, um zu überprüfen, ob die Pods korrekt initialisiert werden und Sie bei Bedarf Fehler identifizieren und beheben können.

Schritt 1: Pods auflisten

Bevor Sie mit dem Debugging von StatefulSets beginnen, sollten Sie den Status der Pods kontrollieren.

Öffnen Sie die Kommandozeile und verwenden Sie den folgenden Befehl, um alle Pods im gewünschten StatefulSet aufzulisten:

kubectl get pods -l app=statefulset-label

Output:

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: Jeder Pod erhält einen eindeutigen Namen, basierend auf dem Namensschema des StatefulSets und einer fortlaufenden Nummer.
• READY: Zeigt an, wie viele der gewünschten Container im Pod bereit sind. Im Beispiel hat jeder Pod einen Container, und 1/1 bedeutet, dass der Container einsatzfähig ist.
• STATUS: Dies gibt den aktuellen Status des Pods an.
• RESTARTS: Zeigt an, wie oft der Container im Pod neu gestartet wurde. Ein Wert von 0 bedeutet, dass es bisher keine Neustarts gab.
• AGE: Gibt an, wie lange der Pod bereits läuft.

Statusmeldungen, die auf Fehler deuten:

• Failed (Fehlgeschlagen): Ein oder mehrere Container im Pod haben einen Fehler verursacht, der dazu führte, dass der Pod fehlgeschlagen ist. Das kann verschiedene Gründe haben, wie fehlende Abhängigkeiten oder Konfigurationsprobleme.
• Unknown (Unbekannt): Der Zustand des Pods konnte nicht festgestellt werden. Es könnte auf ein Problem mit der Kommunikation zwischen dem Kubernetes-Cluster und dem Pod hinweisen. Darunter zählen Netzwerkprobleme, fehlende Berechtigungen oder andere Faktoren.

In beiden Fällen ist es wichtig, genaue Diagnosewerkzeuge wie das Überprüfen von Pod-Logs oder das Kommando kubectl describe pod zu verwenden, um weitere Details zu erhalten und die Ursachen der Fehler zu ermitteln.

Schritt 2: Individuelle Pods debuggen

Das Hinzufügen von Annotationen zu einem Pod kann ein nützliches Debugging-Tool sein, um den Initialisierungsprozess zu beeinflussen oder spezielle Aktionen auszulösen.

Zuerst müssen Sie den Namen des Pods identifizieren, den Sie debuggen möchten.

kubectl get pods

Notieren Sie sich den Namen des zu debuggenden Pods.

Geben Sie nun folgendes Kommando in das Terminal ein, um die Annotation für den ausgewählten Pod zu definieren:

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

Ersetzen Sie [pod-name] durch den tatsächlichen Namen des Pods. Diese Annotation setzt den Initialisierungsstatus auf false, was bedeutet, dass der Pod als nicht initialisiert markiert wird.

Überwachen Sie den Pod, um zu sehen, wie sich die Annotation auf sein Verhalten auswirkt. Insbesondere können Sie die Pod-Ereignisse und Logs überprüfen:

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

Schauen Sie nach Ereignissen oder Log-Ausgaben, die Probleme während des Initialisierungsprozesses auslösen könnten. Wenn das Debugging abgeschlossen ist und Sie den normalen Initialisierungsprozess wiederherstellen möchten, setzen Sie die Annotation zurück auf true.

Schritt 3: Schrittweise Initialisierung

Falls das Debuggen des Pods mit den zuvor beschriebenen Techniken nicht erfolgreich war, könnte dies auf Wettlaufbedingungen während des Bootstrap-Vorgangs des StatefulSets hinweisen. Um dieses Problem zu überwinden, können Sie initialized="false" im Manifest des Kubernetes StatefulSets angeben und es dann mit dieser Annotation im Cluster erstellen.

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

Wenden Sie das aktualisierte Manifest auf Ihrem Kubernetes-Cluster an:

kubectl apply -f statefulset.yaml

Inspizieren Sie die Pods und identifizieren Sie eventuelle Fehlerquellen. Führen Sie die notwendigen Debugging-Maßnahmen durch, basierend auf den beobachteten Ereignissen und Logs. Löschen Sie gegebenenfalls Pods mit kubectl delete statefulsets oder kubectl delete service.

Nachdem Sie das Debugging abgeschlossen haben, können Sie die initialized-Annotation entfernen und das Kubernetes StatefulSet im Cluster aktualisieren:

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

Der Befehl setzt die initialized-Annotation eines Pods auf true und stellt dabei sicher, dass vorhandene Werte überschrieben werden. Nachdem Sie den ersten Pod überprüft haben, wird das Kubernetes StatefulSet automatisch den nächsten Pod initialisieren. Sie können dann die Schritte zum Debugging für jeden weiteren Pod im StatefulSet wiederholen.

Im Kubernetes-Tutorial finden Sie ausführliche und praktische Information zur Einrichtung eines Kubernetes-Clusters.