Di­stri­bu­zio­ne di Ku­ber­ne­tes

Creare cor­ret­ta­men­te una di­stri­bu­zio­ne di Ku­ber­ne­tes è fon­da­men­ta­le per gestire in modo ef­fi­cien­te le ap­pli­ca­zio­ni con­tai­ne­riz­za­te. In questo tutorial troverai in­for­ma­zio­ni det­ta­glia­te sui passaggi più im­por­tan­ti e sulle migliori prassi per rea­liz­za­re una di­stri­bu­zio­ne af­fi­da­bi­le in un ambiente Ku­ber­ne­tes.

Che cos’è una di­stri­bu­zio­ne di Ku­ber­ne­tes?

Una di­stri­bu­zio­ne di Ku­ber­ne­tes è un concetto fon­da­men­ta­le della piat­ta­for­ma che sem­pli­fi­ca il pro­vi­sio­ning e la gestione delle ap­pli­ca­zio­ni nei container. Questo mec­ca­ni­smo di controllo funge da in­ter­me­dia­rio tra la con­fi­gu­ra­zio­ne e la sua effettiva ese­cu­zio­ne nel cluster Ku­ber­ne­tes. In questo modo puoi stabilire le con­di­zio­ni che desideri per le tue ap­pli­ca­zio­ni, compresi i dettagli per le repliche, le immagini dei container e le im­po­sta­zio­ni di con­fi­gu­ra­zio­ne.

La di­stri­bu­zio­ne di Ku­ber­ne­tes penserà suc­ces­si­va­men­te ad au­to­ma­tiz­za­re il pro­vi­sio­ning, or­ga­niz­za­re i container in pod di Ku­ber­ne­tes e di­stri­buir­li fra le risorse di­spo­ni­bi­li nel cluster. Inoltre, consente i rolling update, ossia ag­gior­na­men­ti in sequenza eseguiti gra­dual­men­te che riducono al minimo i tempi di inat­ti­vi­tà. Le fun­zio­na­li­tà di sca­la­bi­li­tà au­to­ma­ti­ca ga­ran­ti­sco­no inoltre un adat­ta­men­to dinamico del numero di istanze in ese­cu­zio­ne in base al carico corrente.

La creazione di una di­stri­bu­zio­ne di Ku­ber­ne­tes può basarsi su due metodi prin­ci­pa­li:

• Metodo im­pe­ra­ti­vo
• Metodo di­chia­ra­ti­vo

Creazione di una di­stri­bu­zio­ne di Ku­ber­ne­tes: metodo im­pe­ra­ti­vo

Con il metodo im­pe­ra­ti­vo devi fornire comandi specifici per eseguire di­ret­ta­men­te le azioni de­si­de­ra­te. Queste possono essere la creazione di risorse, come pod e servizi, oppure l’ag­gior­na­men­to delle con­fi­gu­ra­zio­ni. La con­fi­gu­ra­zio­ne im­pe­ra­ti­va è adatta per requisiti si­tua­zio­na­li o spe­ri­men­ta­li.

Il comando seguente crea una di­stri­bu­zio­ne di Ku­ber­ne­tes de­no­mi­na­ta nginx-deployment e la configura in modo da im­ple­men­ta­re un server web Nginx in un container a partire dall’immagine Nginx ufficiale sulla porta 80.

$ kubectl create deployment nginx-deployment --image nginx --port=80

L’approccio im­pe­ra­ti­vo è im­ple­men­ta­bi­le ra­pi­da­men­te, ma presenta anche alcuni svantaggi. I passaggi del metodo im­pe­ra­ti­vo sono di­ret­ta­men­te legati alla si­tua­zio­ne effettiva, il che può com­pli­ca­re la ri­pe­ti­bi­li­tà delle azioni. In pratica, ripetere l’ese­cu­zio­ne dello stesso comando potrebbe non portare sempre allo stesso stato come risultato, so­prat­tut­to se la si­tua­zio­ne iniziale è cambiata.

Guida sul metodo di­chia­ra­ti­vo

Rispetto alla con­fi­gu­ra­zio­ne di tipo im­pe­ra­ti­vo, il metodo di­chia­ra­ti­vo segue un approccio più astratto. È ne­ces­sa­rio definire lo stato de­si­de­ra­to per l’ap­pli­ca­zio­ne in un file di con­fi­gu­ra­zio­ne e sarà poi Ku­ber­ne­tes a fare in modo che il cluster sia conforme allo stato previsto. Il tuo compito, in questo caso, è de­scri­ve­re cosa vuoi ottenere, mentre Ku­ber­ne­tes penserà all’im­ple­men­ta­zio­ne e al man­te­ni­men­to di tale stato.

Primo passaggio: creazione del file di con­fi­gu­ra­zio­ne YAML

Per iniziare, apriamo un editor di testo e creiamo il file YAML nginx-deployment.yaml per definire la con­fi­gu­ra­zio­ne per la di­stri­bu­zio­ne di Ku­ber­ne­tes:

apiVersion: apps/v1
kind: Deployment
metadata:
    name: nginx-deployment
spec:
    replicas: 3
    selector:
        matchLabels:
            app: nginx
    template:
        metadata:
            labels:
                app: nginx
        spec:
            containers:
            - name: nginx-container
                image: nginx
                ports:
                - containerPort: 80

Nella sezione spec spe­ci­fi­chia­mo la con­fi­gu­ra­zio­ne de­si­de­ra­ta. Con replicas: 3 in­di­chia­mo che la di­stri­bu­zio­ne dovrà creare tre repliche (pod) dell’ap­pli­ca­zio­ne. La sezione selector definisce come se­le­zio­na­re i pod, dove app=nginx funge da criterio di selezione. Il template è il modello dei pod da creare, comprese le etichette. Tra i containers viene con­fi­gu­ra­to il container nginx-container, che utilizza l’immagine Nginx e rimane in ascolto sulla porta 80.

Secondo passaggio: ap­pli­ca­zio­ne della con­fi­gu­ra­zio­ne

Esegui il comando seguente dalla riga di comando per applicare la con­fi­gu­ra­zio­ne al cluster:

kubectl apply -f nginx-deployment.yaml

L’opzione -f indica il percorso del file YAML o JSON che contiene la con­fi­gu­ra­zio­ne per le risorse Ku­ber­ne­tes.

Terzo passaggio: controllo dello stato della di­stri­bu­zio­ne

Questo passaggio permette di ve­ri­fi­ca­re se la di­stri­bu­zio­ne di Ku­ber­ne­tes è stata creata cor­ret­ta­men­te e quanti pod sono at­tual­men­te di­spo­ni­bi­li.

kubectl get deployments nginx-deployment

Otteniamo questo output:

NAME                   READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment         3/3            3           3    2m

• READY: indica il numero di pod at­tual­men­te in ese­cu­zio­ne rispetto al numero de­si­de­ra­to.
• UP-TO-DATE: indica il numero di pod ag­gior­na­ti alla con­fi­gu­ra­zio­ne più recente.
• AVAILABLE: mostra il numero di pod di­spo­ni­bi­li e in grado di accettare richieste.
• AGE: indica da quanto tempo è in ese­cu­zio­ne la di­stri­bu­zio­ne.

Quarto passaggio: vi­sua­liz­za­zio­ne di in­for­ma­zio­ni ag­giun­ti­ve

Il comando seguente ti fornisce in­for­ma­zio­ni det­ta­glia­te sulla di­stri­bu­zio­ne di Ku­ber­ne­tes, sulle strategie uti­liz­za­te, sulle repliche attuali e de­si­de­ra­te e sulle etichette dei selettori.

kubectl describe deployment nginx-deployment

Il risultato è il seguente:

Name:                               nginx-deployment
Namespace:                    default
CreationTimestamp:      Thu, 22 Feb 2024 12:34:56 +0000
Labels:                              <none>
Annotations:                   deployment.kubernetes.io/revision: 1
Selector:                           app=nginx
Replicas:                           3 desired | 3 updated | 3 total | 3 available | 0 unavailable
StrategyType:                  RollingUpdate
MinReadySeconds:         0
RollingUpdateStrategy:  25% max unavailable, 25% max surge

La strategia di ag­gior­na­men­to è con­fi­gu­ra­ta come rolling update, con un’in­di­spo­ni­bi­li­tà massima del 25% e un aumento fino al 25% di pod ag­giun­ti­vi durante un ag­gior­na­men­to.

Quinto passaggio: sca­la­bi­li­tà della di­stri­bu­zio­ne

Per adeguare il numero di pod di una di­stri­bu­zio­ne di Ku­ber­ne­tes, utilizza il comando kubectl scale.

kubectl scale deployment nginx-deployment --replicas=2

Dopo aver eseguito questo comando, Ku­ber­ne­tes aggiorna la di­stri­bu­zio­ne e ga­ran­ti­sce che sia presente il numero de­si­de­ra­to di repliche. Nel nostro esempio, riduciamo il numero di pod in ese­cu­zio­ne a 2.

Strategie di di­stri­bu­zio­ne di Ku­ber­ne­tes

Le strategie di di­stri­bu­zio­ne di Ku­ber­ne­tes de­fi­ni­sco­no il modo in cui le modifiche in un’ap­pli­ca­zio­ne vengono im­ple­men­ta­te in un cluster.

• Rolling De­ploy­ment (Standard): la strategia di di­stri­bu­zio­ne in sequenza è il metodo standard per le di­stri­bu­zio­ni di Ku­ber­ne­tes. In questo caso, i nuovi pod vengono di­stri­bui­ti gra­dual­men­te, mentre i vecchi pod vengono rimossi a poco a poco. Questa strategia offre una di­spo­ni­bi­li­tà continua durante il processo di ag­gior­na­men­to.
• Recreate De­ploy­ment: questa strategia rimuove in­nan­zi­tut­to tutti i pod esistenti e quindi avvia i pod ag­gior­na­ti. Questo metodo può causare un’in­ter­ru­zio­ne tem­po­ra­nea del servizio perché i pod non sono di­spo­ni­bi­li durante il processo di ri­crea­zio­ne.
• Blue/Green De­ploy­ment: in questo caso vengono creati due set di pod (Blue e Green), uno che rap­pre­sen­ta la versione corrente dell’ap­pli­ca­zio­ne e l’altro la nuova versione. As­se­gnan­do etichette spe­ci­fi­che a questi pod, è possibile rein­di­riz­za­re il traffico senza intoppi tra le due versioni. Questa soluzione consente di passare ra­pi­da­men­te da una versione all’altra ed eseguire fa­cil­men­te un ri­pri­sti­no a una versione pre­ce­den­te.

Ri­pri­sti­no della di­stri­bu­zio­ne di Ku­ber­ne­tes

Se si verifica un errore nella versione più recente della tua ap­pli­ca­zio­ne, è fon­da­men­ta­le eseguire un ri­pri­sti­no (rollback) il più ra­pi­da­men­te possibile. In Ku­ber­ne­tes, puoi avviare il processo di rollback con­trol­lan­do la cro­no­lo­gia delle revisioni della tua di­stri­bu­zio­ne e ri­pri­sti­nan­do una versione pre­ce­den­te, se ne­ces­sa­rio.

Controllo della cro­no­lo­gia delle revisioni

Per vi­sua­liz­za­re la cro­no­lo­gia delle revisioni della tua di­stri­bu­zio­ne, utilizza questo comando:

kubectl rollout history deployment/nginx-deployment

Ri­pri­sti­no della versione pre­ce­den­te

Questo comando ri­pri­sti­na una revisione pre­ce­den­te, con­si­de­ra­ta stabile:

kubectl rollout undo deployment/nginx-deployment

Ri­pri­sti­no a una versione specifica

Se vorresti tornare a una revisione specifica, esegui il comando seguente indicando il numero di revisione de­si­de­ra­to:

kubectl rollout undo deployment/nginx-deployment --to-revision=1