Tutorial su Kubernetes: guida per principianti al deployment delle applicazioni

Basi di Kubernetes: Pod, Deployment, Service e Namespace

Ora che abbiamo configurato un cluster e verificato che tutto funzioni, è il momento di creare la nostra prima applicazione.

Ma prima di creare la prima applicazione, è fondamentale capire le basi di Kubernetes. Se vuoi un’introduzione più approfondita a Kubernetes, ti consiglio di dare un’occhiata al corso Introduction to Kubernetes.

I concetti più basilari in Kubernetes sono Pod, Deployment e Service. Conoscere questi tre tipi di risorsa può aiutarti a creare applicazioni potenti. Quindi, approfondiamoli.

Cosa sono i Pod?

Un Pod è l’unità distribuibile più piccola in Kubernetes. Esegue uno o più container fortemente accoppiati con lo stesso storage, rete e namespace. Un Pod viene sempre schedulato su un nodo Kubernetes. 

Puoi definire quante risorse dovrebbe ottenere il tuo Pod (ad es., CPU e memoria). 

Un’applicazione di esempio con due container potrebbe essere il container della tua applicazione e un container helper che aggrega i log e li invia da qualche parte. 

Caratteristiche di un Pod:

• Istanza singola: ogni Pod esegue una singola istanza della tua applicazione.
• Natura effimera: i Pod sono progettati per essere temporanei e vengono sostituiti se si guastano o vengono aggiornati.

Esempio YAML per creare un Pod:

apiVersion: v1
kind: Pod
metadata:
  name: my-pod
spec:
  containers:
  - name: nginx-container
    image: nginx:1.21
    ports:
    - containerPort: 80

Puoi poi installare il Pod usando kubectl:

kubectl apply -f pod.yaml

Questo avvierebbe un Pod chiamato my-pod, che esegue per te un webserver nginx.

Cosa sono i Deployment?

Un Deployment è un oggetto Kubernetes di livello superiore usato per gestire il ciclo di vita dei Pod. Garantisce che il numero desiderato di repliche di Pod sia in esecuzione e gestisce aggiornamenti e rollback. 

Caratteristiche di un Deployment:

• Gestione delle repliche: garantisce che il numero desiderato di pod sia sempre in esecuzione.
• Self-healing: sostituisce automaticamente i Pod non sani.
• Aggiornamenti rolling: aggiorna la versione dell’applicazione gradualmente senza downtime (se configurato).

Vediamo come apparirebbe un file YAML di Deployment che crea di nuovo un webserver nginx, ma questa volta con tre repliche:

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
        image: nginx:1.21
        ports:
        - containerPort: 80

Puoi installare questo Deployment con kubectl:

kubectl apply -f deployment.yaml

Quanto sopra creerebbe un Deployment chiamato nginx-deployment che crea tre Pod, ognuno eseguendo il container nginx. 

Cosa sono i Service?

Passiamo ora all’ultima parte: i Service. 

Un Service è un’astrazione che fornisce un accesso di rete stabile ai Pod, anche se i loro indirizzi IP cambiano. Agisce come un ponte tra le tue applicazioni e i client esterni. 

Ma perché è necessario? Ogni Pod ha il suo indirizzo IP. Quindi perché non possiamo usare direttamente quell’IP? 

Possiamo! Ma non dovremmo. Perché? 

Poiché un Pod è effimero, viene terminato dal Deployment e un nuovo Pod viene creato quando il tuo Pod non è sano. Questo nuovo Pod ha poi un indirizzo IP diverso. Ciò significherebbe che il client che vuole usare la tua applicazione dovrebbe cambiare continuamente l’IP ogni volta che un Pod si arresta, cosa che può accadere spesso.

Qui entra in gioco un Service: cerca tutti i Pod che corrispondono a una determinata etichetta e indirizza automaticamente il traffico verso di essi. Se un Pod diventa non sano, il Service smette di inviare traffico a quel Pod. E se ne compare uno nuovo, inizierà a inviare traffico al nuovo Pod. 

Il Service distribuisce anche il traffico tra tutte le repliche del tuo Deployment, il che è fantastico perché significa che puoi creare più istanze della tua applicazione per distribuire il traffico senza doverlo gestire nella logica applicativa.

Tipi di Service:

• ClusterIP (predefinito): espone il Service all’interno del cluster.
• NodePort: espone il Service su una porta accessibile dall’esterno del cluster.
• LoadBalancer: si integra con i provider cloud per esporre il Service tramite un load balancer.

Esempio YAML per esporre il nostro web server nginx all’esterno del cluster:

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: NodePort

Puoi di nuovo creare quel Service usando kubectl:

kubectl apply -f service.yaml

Questo Service ora distribuirebbe il traffico in ingresso a tutti i Pod con l’etichetta app=nginx sulla porta 80. 

Se esegui un comando describe sul tuo Service appena creato, dovresti vedere che ora ci sono tre endpoint, dove ogni endpoint rappresenta l’indirizzo IP del Pod attualmente in esecuzione:

kubectl describe service nginx-service

Il comando sopra dovrebbe restituire qualcosa di simile a: 

Name:                     nginx-service
Namespace:                default
Labels:                   <none>
Annotations:              <none>
Selector:                 app=nginx
Type:                     NodePort
IP Family Policy:         SingleStack
IP Families:              IPv4
IP:                       10.104.53.131
IPs:                      10.104.53.131
Port:                     <unset>  80/TCP
TargetPort:               80/TCP
NodePort:                 <unset>  32256/TCP
Endpoints:                10.244.0.5:80,10.244.0.6:80,10.244.0.7:80
Session Affinity:         None
External Traffic Policy:  Cluster
Events:                   <none>

Relazioni tra Pod, Deployment e Service

Quindi, per riassumere rapidamente:

• Pod: rappresentano singole istanze dell’applicazione.
• Deployment: gestiscono il ciclo di vita dei Pod e garantiscono che siano in salute.
• Service: forniscono accesso stabile ai Pod e abilitano la comunicazione esterna o interna.

Cosa sono i Namespace?

I Namespace in Kubernetes ti consentono di organizzare e isolare le risorse all’interno di un cluster. Puoi pensarli come cluster virtuali all’interno dello stesso cluster fisico. 

Vantaggi dell’uso dei Namespace:

• Separazione delle responsabilità: team o applicazioni diversi possono operare nel proprio namespace senza influenzare gli altri. 
• Gestione delle risorse: puoi impostare quote e limiti di risorse per i diversi namespace.
• Sicurezza e controllo degli accessi: è possibile applicare policy a livello di namespace.

Per impostazione predefinita, Kubernetes include alcuni namespace integrati:

• default: il namespace predefinito in cui vengono create le risorse, a meno che non sia specificato diversamente
• kube-system: usato per i componenti interni di Kubernetes (ad es., API server, scheduler, ecc.).
• kube-public: un namespace leggibile pubblicamente.
• kube-node-lease: usato per tracciare i heartbeat dei nodi.

Puoi creare un namespace usando un file YAML: 

apiVersion: v1
kind: Namespace
metadata:
  name: my-namespace

Salvalo in un file chiamato namespace.yaml e applicalo usando: 

kubectl apply -f namespace.yaml

Eseguendo il comando seguente, dovresti vedere l’elenco di tutti i namespace predefiniti elencati e quello appena creato: 

kubectl get namespaces

Puoi quindi creare risorse in quel namespace semplicemente impostando il namespace nella sezione metadata della tua risorsa. 

Il nostro Deployment nginx apparirebbe come segue se volessimo crearlo nel namespace appena creato:

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

Ora devi specificare esplicitamente che vuoi recuperare le risorse dal namespace appena creato usando l’argomento -n : 

kubectl get deployment -n my-namespace

Gestire la tua prima applicazione con Kubernetes

Ok, ora che conosci i concetti di base di Kubernetes, è il momento di distribuire la nostra prima applicazione web su Kubernetes e provare ad accedervi. 

In questo capitolo, creeremo un web server nginx, esporremo quel web server tramite un Service verso l’esterno, scaleremo l’applicazione per simulare un carico elevato e aggiorneremo l’app con un rolling update a una versione più recente.

Quindi, iniziamo a divertirci!

Creare un semplice deployment dell’applicazione web

Il primo passo è creare un Deployment per il nostro webserver che crea un container usando l’immagine Nginx.

Copia il codice seguente e salvalo in un file chiamato nginx-deployment.yaml.

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

Poi applica quel Deployment al tuo cluster con il seguente comando:

kubectl apply -f nginx-deployment.yaml

Puoi quindi verificare che il Pod sia in esecuzione: 

kubectl get pods

Esporre l’applicazione con un service

Dobbiamo esporre il web server nginx tramite un Service verso l’esterno. Per questo, creiamo un Service di tipo NodePort, dato che vogliamo accedere al webserver nginx dalla nostra macchina locale, al di fuori del cluster Kubernetes.

Quindi crea un file chiamato nginx-service.yaml e aggiungi il seguente contenuto:

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: NodePort

Puoi quindi applicare il Service con il comando seguente:

kubectl apply -f nginx-service.yaml

Infine, puoi usare minikube per ottenere l’URL del tuo web server nginx:

minikube service nginx-service --url

Apri quell’URL nel browser e dovresti vedere la pagina di benvenuto del tuo web server nginx.

Screenshot della pagina di benvenuto di un web server nginx in un browser locale.

Scalare l’applicazione

Abbiamo quindi un Pod attivo. Ma potrebbe esserci un traffico massiccio di utenti che visitano la nostra pagina web. Per questo motivo, in Kubernetes puoi scalare rapidamente la tua applicazione per avere più Pod in esecuzione. 

Il Service rileverà automaticamente tutti i Pod appartenenti a quel Deployment e bilancerà il carico delle richieste in arrivo su tutti i Pod che eseguono il web server nginx. Questo aiuta a migliorare le prestazioni complessive della nostra pagina web in caso di molto traffico in ingresso.

Quindi, scaliamo la nostra applicazione a 3 repliche usando il comando seguente:

kubectl scale deployment nginx-deployment --replicas=3

Ora puoi ottenere di nuovo tutti i Pod in esecuzione, che dovrebbero essere tre:

kubectl get pods

Puoi anche usare il comando qui sotto per ottenere tutti gli endpoint a cui è collegato il nostro nginx-service. Dovrebbe restituire tre endpoint, ognuno con il proprio indirizzo IP interno al cluster:

kubectl get endpoints nginx-service

Rolling update

Ecco ora un altro grande vantaggio di usare Kubernetes: i rolling update.

Un rolling update mira a evitare qualsiasi downtime della tua applicazione web. Immagina le perdite economiche per aziende come Amazon se la loro pagina fosse offline ogni volta che rilasciano una nuova versione.

Con un rolling update, Kubernetes scala un nuovo Pod, verifica che sia sano e poi riduce quello vecchio. 

Per impostazione predefinita, Kubernetes garantisce che almeno il 75% del numero desiderato di Pod sia attivo, con il 25% come massimo non disponibile. Ciò significa che, nel nostro caso con tre repliche attive, Kubernetes aggiungerà solo un nuovo Pod alla volta, controllerà che sia sano e, se lo è, ridurrà un altro Pod. Ripeterà il processo finché tutti i Pod non saranno aggiornati alla nuova versione.

Facciamolo ora cambiando la versione della nostra immagine nginx da latest a 1.23:

kubectl set image deployment/nginx-deployment nginx=nginx:1.23

Puoi poi monitorare lo stato del rollout usando: 

kubectl rollout status deployment/nginx-deployment

L’output dovrebbe essere simile a: 

Waiting for deployment "nginx-deployment" rollout to finish: 1 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 1 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 1 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 2 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 2 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 2 out of 3 new replicas have been updated...
Waiting for deployment "nginx-deployment" rollout to finish: 1 old replicas are pending termination...
Waiting for deployment "nginx-deployment" rollout to finish: 1 old replicas are pending termination...
deployment "nginx-deployment" successfully rolled out

E mentre il rollout è in corso, la tua pagina web è sempre accessibile, senza alcun downtime!

Non è fantastico?

Gestire le risorse di Kubernetes

Kubernetes fornisce strumenti potenti per ispezionare, modificare ed eliminare risorse di ogni tipo. Capire come gestire efficacemente le risorse garantisce un troubleshooting migliore, un’allocazione ottimale e una manutenzione complessiva del cluster. 

In questa sezione, approfondiremo altri comandi essenziali che ti aiutano a gestire efficacemente le risorse e a risolvere problemi in caso di necessità.

Visualizzare le risorse del cluster

Prima di modificare qualsiasi risorsa, è importante visualizzare e ispezionare le risorse attualmente in esecuzione nel tuo cluster.

Puoi, ad esempio, elencare tutti i Pod, i Service e i Deployment in esecuzione per vedere cosa sta succedendo nel cluster: 

# list running Pods
kubectl get pods

# list running Services 
kubectl get services

# list running Deployments
kubectl get deployments

Se vuoi approfondire una risorsa specifica, puoi usare il comando describe :

kubectl describe deployment nginx-deployment

Questo mostrerà più informazioni, inclusi rolling update, scaling o eventi di pull delle immagini. È il primo punto a cui puoi fare riferimento se qualcosa va storto.

Puoi anche controllare i log di un Pod in esecuzione per vedere cosa succede al suo interno usando il comando seguente:

kubectl logs <pod-name>

Eliminare risorse

È anche importante fare pulizia delle risorse quando non sono più usate, per liberare risorse del cluster per nuove applicazioni. 

Puoi eliminare un Pod usando:

kubectl delete pod <pod-name>

Possiamo farlo per uno dei nostri pod nginx. Tuttavia, un nuovo Pod dovrebbe essere creato immediatamente, poiché sono gestiti da un Deployment, che cerca sempre di mantenere tre repliche attive. 

Qui, quindi, dovremmo eliminare il nginx-deployment: 

kubectl delete deployment nginx-deployment

Dopo aver eseguito questo comando, tutti i Pod nginx in esecuzione dovrebbero essere eliminati. 

Possiamo anche eliminare tutte le risorse in un Namespace. Il seguente comando eliminerebbe tutte le nostre risorse, che per impostazione predefinita sono state create nel Namespace default :

kubectl delete all --all

Conclusione

Congratulazioni! Sei arrivato alla fine e hai mosso con successo i primi passi in Kubernetes. 

Seguendo questo tutorial, hai imparato a:

• Configurare un cluster Kubernetes locale usando minikube.
• Lavorare con Pod, Deployment, Service e Namespace (i mattoni fondamentali di Kubernetes).
• Distribuire e gestire una semplice applicazione web in Kubernetes.
• Scalare dinamicamente le applicazioni ed eseguire rolling update senza alcun downtime.
• Gestire le risorse di Kubernetes elencandole, descrivendole ed eliminandole.

Kubernetes può sembrare complesso all’inizio (almeno lo è stato per me). Ma suddividerlo nei concetti fondamentali lo rende più accessibile. 

Continua a sperimentare e distribuisci altre applicazioni. 

Il modo migliore per imparare Kubernetes è farlo, quindi inizia a costruire!

Per migliorare ulteriormente le tue competenze su Kubernetes, valuta di esplorare:

• Lavorare con ConfigMap e Secret: archivia e gestisci in modo sicuro le impostazioni di configurazione.
• Volumi persistenti: impara a memorizzare dati che sopravvivono ai riavvii dei Pod usando volumi persistenti.
• Networking e ingress controller: configura il routing basato su dominio e gestisci il traffico esterno.
• Helm: usa le chart Helm per impacchettare e distribuire in modo efficiente applicazioni complesse.
• Kubernetes nel cloud: sperimenta con servizi Kubernetes gestiti come AWS EKS, Azure AKS o Google GKE.

Infine, il percorso Containerization and Virtualization with Docker and Kubernetes su DataCamp è un’ottima risorsa per fare pratica sia con Docker che con Kubernetes.