Sta­te­ful­Set in Ku­ber­ne­tes: creazione e debug

Ciascun pod di uno Sta­te­ful­Set in Ku­ber­ne­tes è dotato di un nome host stabile e univoco e di un’identità DNS completa. Questo ID viene mantenuto anche in caso di riavvio e ri­di­men­sio­na­men­to.

Che cosa sono gli Sta­te­ful­Set in Ku­ber­ne­tes?

Gli Sta­te­ful­Set in Ku­ber­ne­tes sono speciali entità per la gestione di ap­pli­ca­zio­ni che pre­sen­ta­no requisiti par­ti­co­la­ri in termini di dati per­si­sten­ti e identità fisse. Questi set ga­ran­ti­sco­no che i pod con repliche vengano avviati seguendo un ordine specifico. A ciascun pod di Ku­ber­ne­tes assegnano un ID univoco e un accesso alla memoria per­si­sten­te. Tali fun­zio­na­li­tà sono utili per i database che si basano su relazioni stabili tra le istanze e ne­ces­si­ta­no di ar­chi­via­re dati per­si­sten­ti. Gli Sta­te­ful­Set sono quindi una soluzione efficace per or­che­stra­re e gestire ap­pli­ca­zio­ni complesse in Ku­ber­ne­tes.

Come creare uno Sta­te­ful­Set in Ku­ber­ne­tes

In­nan­zi­tut­to partiamo dalla de­fi­ni­zio­ne di un file di con­fi­gu­ra­zio­ne YAML in cui impostare le proprietà de­si­de­ra­te dello Sta­te­ful­Set e creare i pod di Ku­ber­ne­tes. Dopo la con­fi­gu­ra­zio­ne, lo Sta­te­ful­Set esegue un mo­ni­to­rag­gio continuo dello stato del cluster e verifica che il numero di pod pre­de­fi­ni­to sia sempre in ese­cu­zio­ne e di­spo­ni­bi­le. In caso di guasto del pod o di una rimozione del nodo, lo Sta­te­ful­Set rileva au­to­ma­ti­ca­men­te la si­tua­zio­ne. Quindi ini­zia­liz­za la di­stri­bu­zio­ne di un nuovo pod con lo stesso ID univoco. Questo nuovo pod viene connesso alla memoria per­si­sten­te già esistente e riceve la stessa con­fi­gu­ra­zio­ne del pod originale. Questa comprende anche le richieste e i limiti di risorse.

Questa gestione precisa dei pod e delle loro identità è fon­da­men­ta­le affinché sia possibile rein­di­riz­za­re al nuovo pod i client pre­ce­den­te­men­te serviti dal pod non più di­spo­ni­bi­le, senza in­ter­ru­zio­ni. L’accesso alla memoria per­si­sten­te ga­ran­ti­sce un fun­zio­na­men­to continuo dei processi senza in­ter­ru­zio­ni.

A seguire trovi un esempio di file YAML completo che mostra i passaggi necessari per la creazione di uno Sta­te­ful­Set in Ku­ber­ne­tes per 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
    volumeClaimTemplates:
    - metadata:
            name: nginx-config
        spec:
            accessModes: [ "ReadWriteOnce" ]
            resources:
                requests:
                    storage: 1Gi

Questo documento YAML definisce uno Sta­te­ful­Set in Ku­ber­ne­tes per Nginx con tre repliche. Utilizza un oggetto di servizio di nome nginx ed etichette per iden­ti­fi­ca­re cor­ret­ta­men­te i pod. Questi ultimi usano l’immagine Nginx più recente e di­spon­go­no di due volumi per la con­fi­gu­ra­zio­ne e per i file HTML. I Vo­lu­me­Claim­Tem­pla­tes pro­teg­go­no la memoria per­si­sten­te per questi volumi con una di­men­sio­ne di 1 gigabyte e con­sen­to­no l’accesso Read­W­ri­teOn­ce.

Debug di Sta­te­ful­Set

Il debug degli Sta­te­ful­Set in Ku­ber­ne­tes richiede passaggi specifici per ve­ri­fi­ca­re che i pod siano stati ini­zia­liz­za­ti cor­ret­ta­men­te e per iden­ti­fi­ca­re e risolvere gli errori, se ne­ces­sa­rio.

Primo passaggio: elen­ca­zio­ne dei pod

Prima di iniziare il debug degli Sta­te­ful­Set ti con­si­glia­mo di ve­ri­fi­ca­re lo stato dei pod.

Apri la riga di comando e utilizza il comando seguente per elencare tutti i pod nello Sta­te­ful­Set de­si­de­ra­to:

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: a ciascun pod viene assegnato un nome univoco in base allo schema di de­no­mi­na­zio­ne dello Sta­te­ful­Set e un numero pro­gres­si­vo.
• READY: mostra quanti sono i container de­si­de­ra­ti e pronti nel pod. In questo esempio, ogni pod ha un container e 1/1 significa che il container è operativo.
• STATUS: indica lo stato corrente del pod.
• RESTARTS: mostra per quante volte il container nel pod è stato riavviato. Un valore pari a 0 significa che non è stato ancora ef­fet­tua­to nessun riavvio.
• AGE: indica da quanto tempo è in ese­cu­zio­ne il pod.

Messaggi di stato che indicano errori:

• Failed (non riuscito): uno o più container nel pod hanno causato un errore che ha portato al mal­fun­zio­na­men­to del pod. I motivi possono essere diversi, ad esempio di­pen­den­ze mancanti o problemi di con­fi­gu­ra­zio­ne.
• Unknown (sco­no­sciu­to): non è stato possibile de­ter­mi­na­re lo stato del pod. Il problema potrebbe essere nella co­mu­ni­ca­zio­ne tra il cluster Ku­ber­ne­tes e il pod. Ad esempio, si può trattare di problemi di rete, au­to­riz­za­zio­ni mancanti o altri fattori.

In entrambi i casi è im­por­tan­te uti­liz­za­re strumenti dia­gno­sti­ci precisi, come il controllo dei log dei pod o il comando kubectl describe pod per ottenere maggiori dettagli e de­ter­mi­na­re le cause degli errori.

Secondo passaggio: debug dei singoli pod

L’aggiunta di an­no­ta­zio­ni a un pod può essere un utile strumento di debug per influire sul processo di ini­zia­liz­za­zio­ne o per eseguire azioni par­ti­co­la­ri.

Per prima cosa è ne­ces­sa­rio iden­ti­fi­ca­re il nome del pod di cui vuoi eseguire il debug.

kubectl get pods

Prendi nota del nome del pod di cui vuoi eseguire il debug.

Quindi digita il seguente comando nel terminale per definire l’an­no­ta­zio­ne del pod se­le­zio­na­to:

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

So­sti­tui­sci [pod-name] con il nome effettivo del pod. Questa an­no­ta­zio­ne imposta lo stato di ini­zia­liz­za­zio­ne su false, ossia il pod verrà con­tras­se­gna­to come non ini­zia­liz­za­to.

Monitora il pod per vedere come l’an­no­ta­zio­ne influisce sul suo com­por­ta­men­to. In par­ti­co­la­re, puoi con­trol­la­re gli eventi e i log del pod:

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

Vai alla ricerca di eventi o risultati nel registro che po­treb­be­ro causare problemi durante il processo di ini­zia­liz­za­zio­ne. Una volta com­ple­ta­to il debug, se desideri ri­pri­sti­na­re il normale processo di ini­zia­liz­za­zio­ne puoi riportare l’an­no­ta­zio­ne su true.

Terzo passaggio: ini­zia­liz­za­zio­ne graduale

Se il debug del pod con le tecniche descritte in pre­ce­den­za non ha dato esito positivo, po­treb­be­ro essere presenti delle con­di­zio­ni di corsa durante il processo di bootstrap dello Sta­te­ful­Set. Per risolvere questo problema puoi spe­ci­fi­ca­re initialized="false" nel manifest dello Sta­te­ful­Set di Ku­ber­ne­tes e crearlo quindi all’interno del cluster con questa an­no­ta­zio­ne.

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

Applica il manifest ag­gior­na­to al tuo cluster Ku­ber­ne­tes:

kubectl apply -f statefulset.yaml

Ispeziona i pod e iden­ti­fi­ca eventuali po­ten­zia­li fonti di errore. Esegui le azioni di debug ne­ces­sa­rie in base agli eventi e ai registri osservati. Se ne­ces­sa­rio, elimina i pod per mezzo di kubectl delete statefulsets o kubectl delete service.

Dopo aver com­ple­ta­to il debug puoi rimuovere l’an­no­ta­zio­ne ini­zia­liz­za­ta e ag­gior­na­re lo Sta­te­ful­Set di Ku­ber­ne­tes nel cluster:

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

Il comando imposta l’an­no­ta­zio­ne ini­zia­liz­za­ta di un pod su true, ga­ran­ten­do che i valori esistenti vengano so­vra­scrit­ti. Dopo aver con­trol­la­to il primo pod, lo Sta­te­ful­Set in Ku­ber­ne­tes ini­zia­liz­za au­to­ma­ti­ca­men­te il pod suc­ces­si­vo. Suc­ces­si­va­men­te puoi ripetere i passaggi di debug per ogni altro pod nello Sta­te­ful­Set.

Nel tutorial di Ku­ber­ne­tes trovi in­for­ma­zio­ni pratiche e det­ta­glia­te per la con­fi­gu­ra­zio­ne di un cluster Ku­ber­ne­tes.