Cos'è Kubernetes e a Cosa Serve: Guida Completa per Principianti

Introduzione

Hai imparato a usare Docker e i container, ma ora ti chiedi: “Come gestisco decine o centinaia di container in produzione?”. La risposta è Kubernetes, spesso abbreviato in K8s. In questa guida ti spiegherò cos’è, come funziona e quando ha senso usarlo.

Cos’è Kubernetes?

Kubernetes è una piattaforma open source per l’orchestrazione di container. È stato creato da Google nel 2014 basandosi su 15 anni di esperienza nella gestione di container su larga scala, ed è ora mantenuto dalla Cloud Native Computing Foundation (CNCF).

Ma cosa significa “orchestrazione”? Immagina un’orchestra sinfonica:

• I musicisti sono i tuoi container, ognuno sa suonare il proprio strumento
• Il direttore d’orchestra è Kubernetes, che coordina tutti i musicisti
• La partitura è la configurazione che definisce come devono suonare insieme

Senza un direttore, ogni musicista suonerebbe per conto suo. Con Kubernetes, tutti i container lavorano in armonia per far funzionare la tua applicazione.

Il Nome Kubernetes

Il nome deriva dal greco κυβερνήτης (kybernetes), che significa “timoniere” o “pilota”. Il logo con il timone a sette raggi rappresenta proprio questo concetto. L’abbreviazione K8s nasce dal fatto che ci sono 8 lettere tra la “K” e la “s”.

Perché Serve Kubernetes?

Docker risolve il problema di creare e far girare singoli container. Ma in produzione le cose si complicano:

• Cosa succede se un container crasha alle 3 di notte?
• Come distribuisci il traffico tra 10 istanze della stessa applicazione?
• Come aggiorni l’applicazione senza downtime?
• Come gestisci 50 microservizi che devono comunicare tra loro?

Kubernetes risponde a tutte queste domande.

Docker vs Kubernetes: Non Sono Alternativi

Un malinteso comune è pensare che Kubernetes sostituisca Docker. In realtà lavorano insieme:

Kubernetes può usare Docker (o altri runtime come containerd) per eseguire i container. Non devi scegliere tra uno o l’altro: li usi entrambi.

A Cosa Serve Kubernetes: 6 Problemi che Risolve

1. Self-Healing: Container che Si Riparano da Soli

Se un container crasha, Kubernetes lo rileva e ne avvia automaticamente uno nuovo. Non serve che qualcuno sia sveglio alle 3 di notte per riavviare manualmente i servizi.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

# Kubernetes garantisce sempre 3 repliche attive
apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
spec:
  replicas: 3  # Se una muore, K8s ne crea una nuova
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
      - name: web
        image: nginx:latest

2. Scaling Automatico

Hai un picco di traffico? Kubernetes può aumentare automaticamente il numero di container. Il traffico cala? Li riduce per risparmiare risorse.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

# Scala automaticamente tra 2 e 10 repliche in base alla CPU
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: web-app-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: web-app
  minReplicas: 2
  maxReplicas: 10
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

3. Load Balancing Integrato

Kubernetes distribuisce automaticamente il traffico tra tutti i container disponibili. Se un container è sovraccarico o non risponde, il traffico viene reindirizzato agli altri.

4. Rolling Updates: Aggiornamenti Senza Downtime

Quando deployi una nuova versione, Kubernetes:

1. Avvia i nuovi container con la versione aggiornata
2. Verifica che funzionino correttamente
3. Gradualmente sposta il traffico sui nuovi container
4. Termina i vecchi container

Se qualcosa va storto, può fare rollback automatico alla versione precedente.

5. Service Discovery

In un sistema con molti microservizi, come fa il servizio A a trovare il servizio B? Kubernetes fornisce un sistema DNS interno: ogni servizio ha un nome e Kubernetes si occupa di tradurlo nell’indirizzo corretto.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# Il servizio "database" sarà raggiungibile come "database.default.svc.cluster.local"
apiVersion: v1
kind: Service
metadata:
  name: database
spec:
  selector:
    app: postgres
  ports:
  - port: 5432

6. Gestione dei Secrets e Configurazioni

Password, API key, configurazioni: Kubernetes li gestisce in modo sicuro e li inietta nei container senza hardcodarli nel codice.

1
2
3
4
5
6
7
8
9

# Secret per le credenziali del database
apiVersion: v1
kind: Secret
metadata:
  name: db-credentials
type: Opaque
data:
  username: YWRtaW4=      # base64 encoded
  password: cGFzc3dvcmQ=  # base64 encoded

I Concetti Fondamentali di Kubernetes

Pod

Il Pod è l’unità base di Kubernetes. Contiene uno o più container che condividono rete e storage. Nella maggior parte dei casi, un Pod contiene un solo container.

Node

Un Node è una macchina (fisica o virtuale) che esegue i Pod. Un cluster Kubernetes ha tipicamente più Node per garantire alta disponibilità.

Cluster

Il Cluster è l’insieme di tutti i Node gestiti da Kubernetes. Include:

• Control Plane: il “cervello” che prende decisioni (dove piazzare i Pod, quando scalarli, ecc.)
• Worker Nodes: le macchine che eseguono effettivamente i container

Deployment

Un Deployment descrive lo stato desiderato della tua applicazione: quale immagine usare, quante repliche, come aggiornarla. Kubernetes si assicura che lo stato reale corrisponda sempre a quello desiderato.

Service

Un Service espone i Pod alla rete. Fornisce un indirizzo IP stabile e load balancing, anche se i Pod sottostanti cambiano.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

┌─────────────────────────────────────────────────────────┐
│                      CLUSTER                            │
│  ┌─────────────────────────────────────────────────┐   │
│  │              CONTROL PLANE                       │   │
│  │  • API Server  • Scheduler  • Controller        │   │
│  └─────────────────────────────────────────────────┘   │
│                                                         │
│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐    │
│  │   NODE 1    │  │   NODE 2    │  │   NODE 3    │    │
│  │ ┌─────────┐ │  │ ┌─────────┐ │  │ ┌─────────┐ │    │
│  │ │  Pod A  │ │  │ │  Pod A  │ │  │ │  Pod B  │ │    │
│  │ └─────────┘ │  │ └─────────┘ │  │ └─────────┘ │    │
│  │ ┌─────────┐ │  │ ┌─────────┐ │  │ ┌─────────┐ │    │
│  │ │  Pod B  │ │  │ │  Pod C  │ │  │ │  Pod C  │ │    │
│  │ └─────────┘ │  │ └─────────┘ │  │ └─────────┘ │    │
│  └─────────────┘  └─────────────┘  └─────────────┘    │
└─────────────────────────────────────────────────────────┘

Kubernetes vs Docker Swarm

Docker ha il suo orchestratore integrato: Docker Swarm. Qual è la differenza?

Quando scegliere Docker Swarm:

• Progetti piccoli/medi
• Team con poca esperienza in orchestrazione
• Necessità di partire velocemente

Quando scegliere Kubernetes:

• Progetti enterprise o in crescita
• Necessità di funzionalità avanzate
• Team disposto a investire nell’apprendimento
• Requisiti di scaling importanti

Quando NON Usare Kubernetes

Kubernetes non è sempre la risposta giusta. Evitalo se:

• Hai pochi container: gestire 2-3 container con K8s è come usare un TIR per portare la spesa
• Il team è piccolo: la complessità operativa può superare i benefici
• L’applicazione è monolitica: K8s brilla con i microservizi
• Non hai requisiti di scaling: se il traffico è costante e prevedibile, potresti non averne bisogno
• Budget limitato: i cluster Kubernetes hanno costi operativi significativi

Alternative Più Semplici

Come Iniziare con Kubernetes

Se vuoi esplorare Kubernetes senza impazzire, ecco un percorso graduale:

1. Impara i Fondamenti di Docker

Se non l’hai già fatto, parti da Docker. Kubernetes orchestra container, quindi devi prima saperli creare.

2. Sperimenta in Locale con Minikube

Minikube crea un cluster Kubernetes sul tuo computer. Perfetto per imparare senza costi cloud.

1
2
3
4
5

# Installa Minikube e avvia un cluster locale
minikube start

# Verifica che funzioni
kubectl get nodes

3. Esplora kubectl

kubectl è il comando per interagire con Kubernetes. Impara le operazioni base:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Vedere i Pod in esecuzione
kubectl get pods

# Creare risorse da un file YAML
kubectl apply -f deployment.yaml

# Vedere i log di un Pod
kubectl logs nome-pod

# Entrare in un container
kubectl exec -it nome-pod -- /bin/bash

4. Prova un Cluster Gestito

Quando sei pronto per la produzione, usa un servizio gestito:

• Google Kubernetes Engine (GKE)
• Amazon Elastic Kubernetes Service (EKS)
• Azure Kubernetes Service (AKS)

Questi servizi gestiscono il Control Plane per te, riducendo la complessità operativa.

Conclusioni

Kubernetes è uno strumento potente che risolve problemi reali nella gestione di applicazioni containerizzate su larga scala. Offre self-healing, scaling automatico, deploy senza downtime e molto altro.

Tuttavia, porta con sé una complessità significativa. Prima di adottarlo, chiediti:

• Ho davvero bisogno di orchestrare molti container?
• Il mio team ha le competenze (o il tempo per acquisirle)?
• I benefici giustificano la complessità aggiunta?

Se la risposta è sì, Kubernetes può trasformare il modo in cui gestisci le tue applicazioni. Se no, soluzioni più semplici come Docker Compose o Docker Swarm potrebbero essere la scelta migliore.

Il consiglio è partire in piccolo: sperimenta con Minikube, fai pratica con i concetti base, e scala gradualmente verso cluster più complessi quando ne avrai realmente bisogno.