Ku­ber­netes Sta­teful­Set erstellen und debuggen

Jeder Pod in einem Ku­ber­netes Sta­teful­Set besitzt einen ein­deu­ti­gen und stabilen Hostnamen sowie eine voll­stän­di­ge DNS-Identität. Diese ID bleibt über Neustarts und Ska­lie­run­gen hinweg erhalten.

Was sind Ku­ber­netes Sta­teful­Sets?

Ku­ber­netes Sta­teful­Sets sind spezielle Entitäten, um An­wen­dun­gen zu managen, die besondere An­for­de­run­gen an per­sis­ten­te Daten und feste Iden­ti­tä­ten haben. Diese Sets stellen sicher, dass Pods mit Re­pli­ka­ten in einer be­stimm­ten Rei­hen­fol­ge gestartet werden. Sie weisen jedem Ku­ber­netes Pod eine ein­deu­ti­ge ID sowie Zugriff auf per­sis­ten­ten Speicher zu. Solche Funk­tio­nen sind nützlich für Da­ten­ban­ken, die auf stabile Be­zie­hun­gen zwischen Instanzen an­ge­wie­sen sind und dau­er­haf­te Daten speichern müssen. Sta­teful­Sets re­prä­sen­tie­ren somit eine effektive Lösung für die Or­ches­trie­rung und den Betrieb von komplexen An­wen­dun­gen in Ku­ber­netes.

So erstellen Sie ein Ku­ber­netes Sta­teful­Set

Zuerst beginnen wir mit der De­fi­ni­ti­on einer YAML-Kon­fi­gu­ra­ti­ons­da­tei, in der wir die ge­wünsch­ten Ei­gen­schaf­ten des Sta­teful­Sets festlegen und Ku­ber­netes Pods erstellen. Nach der Kon­fi­gu­ra­ti­on überwacht das Sta­teful­Set kon­ti­nu­ier­lich den Cluster-Status und ob die vor­de­fi­nier­te Anzahl von Pods stets lauffähig und verfügbar ist. Im Falle eines Pod-Ausfalls oder einer Ent­fer­nung vom Node erkennt das Sta­teful­Set die Situation au­to­ma­tisch. Es initiiert die Be­reit­stel­lung eines neuen Pods mit derselben ein­deu­ti­gen ID. Dieser neue Pod wird mit dem bereits vor­han­de­nen per­sis­ten­ten Speicher verbunden und erhält die iden­ti­sche Kon­fi­gu­ra­ti­on wie der ur­sprüng­li­che Pod. Dazu gehören auch Res­sour­cen­an­fra­gen und -limits.

Diese präzise Hand­ha­bung von Pods und deren Identität ist ent­schei­dend, damit Clients, die zuvor von dem nicht ver­füg­ba­ren Pod bedient wurden, ohne Un­ter­bre­chun­gen auf den neuen Pod um­ge­lei­tet werden können. Der Zugriff auf den per­sis­ten­ten Speicher ge­währ­leis­tet, dass Vorgänge weiterhin rei­bungs­los funk­tio­nie­ren.

Hier ist eine voll­stän­di­ge YAML-Datei, die die Schritte für die Er­stel­lung eines Ku­ber­netes Sta­teful­Sets für Nginx ver­an­schau­licht:

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 Ku­ber­netes Sta­teful­Set für Nginx mit drei Re­pli­ka­ten. Es setzt ein Service-Objekt namens nginx und Labels ein, um die Pods korrekt zu iden­ti­fi­zie­ren. Letztere verwenden das neueste Nginx-Image und haben zwei Volumen für die Kon­fi­gu­ra­ti­on und HTML-Dateien. Die Vo­lu­meClaim­Tem­pla­tes sichern per­sis­ten­ten Speicher für diese Volumen mit einer Größe von 1 Gigabyte und erlauben den Zugriff Re­ad­Wri­te­On­ce.

Debugging von Sta­teful­Sets

Das Debugging von Sta­teful­Sets in Ku­ber­netes erfordert spe­zi­fi­sche Schritte, um zu über­prü­fen, ob die Pods korrekt in­itia­li­siert werden und Sie bei Bedarf Fehler iden­ti­fi­zie­ren und beheben können.

Schritt 1: Pods auflisten

Bevor Sie mit dem Debugging von Sta­teful­Sets beginnen, sollten Sie den Status der Pods kon­trol­lie­ren.

Öffnen Sie die Kom­man­do­zei­le und verwenden Sie den folgenden Befehl, um alle Pods im ge­wünsch­ten Sta­teful­Set auf­zu­lis­ten:

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 ein­deu­ti­gen Namen, basierend auf dem Na­mens­sche­ma des Sta­teful­Sets und einer fort­lau­fen­den Nummer.
• READY: Zeigt an, wie viele der ge­wünsch­ten Container im Pod bereit sind. Im Beispiel hat jeder Pod einen Container, und 1/1 bedeutet, dass der Container ein­satz­fä­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.

Sta­tus­mel­dun­gen, die auf Fehler deuten:

• Failed (Fehl­ge­schla­gen): Ein oder mehrere Container im Pod haben einen Fehler ver­ur­sacht, der dazu führte, dass der Pod fehl­ge­schla­gen ist. Das kann ver­schie­de­ne Gründe haben, wie fehlende Ab­hän­gig­kei­ten oder Kon­fi­gu­ra­ti­ons­pro­ble­me.
• Unknown (Unbekannt): Der Zustand des Pods konnte nicht fest­ge­stellt werden. Es könnte auf ein Problem mit der Kom­mu­ni­ka­ti­on zwischen dem Ku­ber­netes-Cluster und dem Pod hinweisen. Darunter zählen Netz­werk­pro­ble­me, fehlende Be­rech­ti­gun­gen oder andere Faktoren.

In beiden Fällen ist es wichtig, genaue Dia­gno­se­werk­zeu­ge wie das Über­prü­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: In­di­vi­du­el­le Pods debuggen

Das Hin­zu­fü­gen von An­no­ta­tio­nen zu einem Pod kann ein nütz­li­ches Debugging-Tool sein, um den In­itia­li­sie­rungs­pro­zess zu be­ein­flus­sen oder spezielle Aktionen aus­zu­lö­sen.

Zuerst müssen Sie den Namen des Pods iden­ti­fi­zie­ren, den Sie debuggen möchten.

kubectl get pods

Notieren Sie sich den Namen des zu de­bug­gen­den Pods.

Geben Sie nun folgendes Kommando in das Terminal ein, um die An­no­ta­ti­on für den aus­ge­wähl­ten Pod zu de­fi­nie­ren:

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

Ersetzen Sie [pod-name] durch den tat­säch­li­chen Namen des Pods. Diese An­no­ta­ti­on setzt den In­itia­li­sie­rungs­sta­tus auf false, was bedeutet, dass der Pod als nicht in­itia­li­siert markiert wird.

Über­wa­chen Sie den Pod, um zu sehen, wie sich die An­no­ta­ti­on auf sein Verhalten auswirkt. Ins­be­son­de­re können Sie die Pod-Er­eig­nis­se und Logs über­prü­fen:

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

Schauen Sie nach Er­eig­nis­sen oder Log-Ausgaben, die Probleme während des In­itia­li­sie­rungs­pro­zes­ses auslösen könnten. Wenn das Debugging ab­ge­schlos­sen ist und Sie den normalen In­itia­li­sie­rungs­pro­zess wie­der­her­stel­len möchten, setzen Sie die An­no­ta­ti­on zurück auf true.

Schritt 3: Schritt­wei­se In­itia­li­sie­rung

Falls das Debuggen des Pods mit den zuvor be­schrie­be­nen Techniken nicht er­folg­reich war, könnte dies auf Wett­lauf­be­din­gun­gen während des Bootstrap-Vorgangs des Sta­teful­Sets hinweisen. Um dieses Problem zu über­win­den, können Sie initialized="false" im Manifest des Ku­ber­netes Sta­teful­Sets angeben und es dann mit dieser An­no­ta­ti­on 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 ak­tua­li­sier­te Manifest auf Ihrem Ku­ber­netes-Cluster an:

kubectl apply -f statefulset.yaml

In­spi­zie­ren Sie die Pods und iden­ti­fi­zie­ren Sie even­tu­el­le Feh­ler­quel­len. Führen Sie die not­wen­di­gen Debugging-Maßnahmen durch, basierend auf den be­ob­ach­te­ten Er­eig­nis­sen und Logs. Löschen Sie ge­ge­be­nen­falls Pods mit kubectl delete statefulsets oder kubectl delete service.

Nachdem Sie das Debugging ab­ge­schlos­sen haben, können Sie die in­itia­li­zed-An­no­ta­ti­on entfernen und das Ku­ber­netes Sta­teful­Set im Cluster ak­tua­li­sie­ren:

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

Der Befehl setzt die in­itia­li­zed-An­no­ta­ti­on eines Pods auf true und stellt dabei sicher, dass vor­han­de­ne Werte über­schrie­ben werden. Nachdem Sie den ersten Pod überprüft haben, wird das Ku­ber­netes Sta­teful­Set au­to­ma­tisch den nächsten Pod in­itia­li­sie­ren. Sie können dann die Schritte zum Debugging für jeden weiteren Pod im Sta­teful­Set wie­der­ho­len.

Im Ku­ber­netes-Tutorial finden Sie aus­führ­li­che und prak­ti­sche In­for­ma­ti­on zur Ein­rich­tung eines Ku­ber­netes-Clusters.