Introduzione a Kubernetes: L'Orchestratore di Container

Se lavori nel mondo dello sviluppo software, avrai sicuramente sentito parlare di Kubernetes. Ma cos'è esattamente e perché è diventato uno standard de-facto per la gestione di applicazioni containerizzate? Questa guida ti porterà dalle basi ai concetti fondamentali, con esempi pratici e diagrammi per aiutarti a capire.

Prima di Kubernetes: Un Po' di Storia

Per capire perché Kubernetes è così rivoluzionario, facciamo un passo indietro.

1. Deployment Tradizionale: Inizialmente, le applicazioni venivano eseguite su server fisici. Questo approccio era costoso, difficile da scalare e soggetto a conflitti di risorse.
2. Deployment Virtualizzato: Poi sono arrivate le Virtual Machine (VM). Le VM hanno permesso di eseguire più applicazioni isolate sullo stesso hardware, migliorando l'utilizzo delle risorse e la sicurezza. Tuttavia, ogni VM esegue un intero sistema operativo, consumando molte risorse.
3. Deployment Containerizzato: I container (come Docker) sono l'evoluzione successiva. Condividono lo stesso sistema operativo host ma eseguono processi isolati. Sono leggeri, veloci da avviare e portabili.

I container hanno risolto il problema della portabilità, ma ne hanno creato un altro: come gestire centinaia (o migliaia) di container in un ambiente di produzione? Come garantire che siano sempre in esecuzione, che possano comunicare tra loro e che scalino in base al carico?

Qui entra in gioco Kubernetes.

Cos'è Kubernetes?

Kubernetes (spesso abbreviato in K8s) è una piattaforma open-source per l'orchestrazione di container. In parole semplici, automatizza il deployment, la scalabilità e la gestione di applicazioni containerizzate. Creato da Google e ora mantenuto dalla Cloud Native Computing Foundation (CNCF), Kubernetes è diventato lo strumento di riferimento per chiunque lavori con i microservizi su larga scala.

L'Architettura di un Cluster Kubernetes

Un ambiente Kubernetes è chiamato cluster. Un cluster è composto da un insieme di macchine, chiamate nodi, che eseguono le nostre applicazioni. L'architettura si divide in due parti principali: il Control Plane e i Worker Node.

Control Plane

Il Control Plane è il "cervello" del cluster. Prende decisioni globali (come lo scheduling) e rileva e risponde agli eventi del cluster. I suoi componenti principali sono:

• API Server (kube-apiserver): È la porta d'ingresso del cluster. Espone le API di Kubernetes, che vengono utilizzate dagli utenti (tramite kubectl), dai componenti del cluster e da strumenti esterni per comunicare.
• etcd: Un database key-value consistente e altamente disponibile. Memorizza tutti i dati del cluster, rappresentando lo "stato" desiderato e attuale del sistema.
• Scheduler (kube-scheduler): Assegna i Pod appena creati a un Worker Node disponibile, tenendo conto dei requisiti di risorse, delle policy e di altri vincoli.
• Controller Manager (kube-controller-manager): Esegue i controller, che sono cicli di controllo che osservano lo stato del cluster e lavorano per portarlo allo stato desiderato. Ad esempio, il Node Controller gestisce i nodi, mentre il Replication Controller si assicura che il numero corretto di Pod sia in esecuzione.

Worker Node

I Worker Node sono le macchine (fisiche o virtuali) dove le applicazioni vengono effettivamente eseguite. Ogni nodo è gestito dal Control Plane e contiene i seguenti componenti:

• Kubelet: Un agente che viene eseguito su ogni nodo. Si assicura che i container descritti nei Pod siano in esecuzione e in buono stato.
• Kube-proxy: Un proxy di rete che gestisce le regole di rete sui nodi. Permette la comunicazione di rete verso i Pod da sessioni di rete interne o esterne al cluster.
• Container Runtime: Il software responsabile dell'esecuzione dei container. Docker è il più famoso, ma Kubernetes supporta anche altri runtime come containerd e CRI-O.

Oggetti Fondamentali di Kubernetes

In Kubernetes, tutto è rappresentato da oggetti. Questi oggetti sono "intenzioni" (records of intent): una volta creato un oggetto, Kubernetes lavora costantemente per garantire che esista e corrisponda allo stato desiderato.

Ecco i più importanti:

Pod

Il Pod è l'unità di esecuzione più piccola in Kubernetes. Rappresenta uno o più container che vengono eseguiti insieme sullo stesso nodo, condividendo risorse come la rete e lo storage.

Generalmente, si esegue un solo container per Pod, ma in scenari avanzati (come i "sidecar container" per il logging o il monitoring) se ne possono avere di più.

Non si creano quasi mai Pod direttamente. Si usano astrazioni di livello superiore come i Deployment.

Deployment

Un Deployment è l'oggetto che userai più spesso. Descrive lo stato desiderato per un gruppo di Pod identici. Il controller del Deployment si occupa di:

• Creare e gestire un ReplicaSet (un altro oggetto che garantisce che un numero specifico di repliche di un Pod sia sempre in esecuzione).
• Scalare il numero di Pod su o giù.
• Gestire gli aggiornamenti dell'applicazione in modo controllato (es. Rolling Update), senza tempi di inattività.

Ecco un esempio di file YAML per un Deployment che esegue 3 repliche di un server NGINX:

# nginx-deployment.yaml
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.14.2
        ports:
        - containerPort: 80

Service

I Pod in Kubernetes sono effimeri: possono essere creati e distrutti in qualsiasi momento. Ogni Pod ha un proprio indirizzo IP, ma questo IP non è stabile. Come facciamo, quindi, a esporre la nostra applicazione in modo affidabile?

Con un Service. Un Service è un'astrazione che definisce un set logico di Pod e una policy per accedervi. Fornisce un punto di accesso stabile (un indirizzo IP virtuale e un nome DNS) per un gruppo di Pod.

Il Service utilizza un selector basato su etichette (labels) per trovare i Pod a cui deve inoltrare il traffico.

Ecco come creare un Service per il nostro Deployment NGINX:

# nginx-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: ClusterIP # Default - espone il servizio solo all'interno del cluster

Esistono diversi tipi di Service:

• ClusterIP: Espone il servizio su un IP interno al cluster (default).
• NodePort: Espone il servizio su una porta statica su ogni Worker Node.
• LoadBalancer: Crea un load balancer esterno nel cloud provider (es. AWS, GCP) e assegna un IP pubblico al servizio.

Ingress

Un Service di tipo LoadBalancer è ottimo, ma crearne uno per ogni servizio può essere costoso. Per esporre più servizi HTTP/HTTPS al mondo esterno, si usa un Ingress.

Un Ingress funge da "router intelligente" per il traffico esterno. Permette di definire regole di routing basate su host (es. api.miosito.com) o path (es. miosito.com/api).

Ecco un esempio di Ingress:

# example-ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: example-ingress
spec:
  rules:
  - host: miosito.com
    http:
      paths:
      - path: /api
        pathType: Prefix
        backend:
          service:
            name: api-service
            port:
              number: 8080
      - path: /ui
        pathType: Prefix
        backend:
          service:
            name: ui-service
            port:
              number: 3000

Altri Oggetti Utili

• Namespace: Permette di creare "cluster virtuali" all'interno di un cluster fisico. Utile per isolare ambienti (es. development, staging, production) o team.
• ConfigMap e Secret: Per gestire dati di configurazione e segreti (come password o chiavi API) in modo disaccoppiato dall'immagine del container.
• StatefulSet: Simile a un Deployment, ma specifico per applicazioni stateful (come i database) che richiedono identità di rete stabili e storage persistente.
• PersistentVolume (PV) e PersistentVolumeClaim (PVC): Per gestire lo storage persistente nel cluster.

Conclusione

Kubernetes è uno strumento incredibilmente potente, ma la sua curva di apprendimento può essere ripida. Questa guida ha solo scalfito la superficie, ma speriamo ti abbia dato una solida comprensione dei concetti di base.

Cosa fare ora?

• Sperimenta in locale: Installa Minikube o Kind per creare un cluster Kubernetes sul tuo computer.
• Usa kubectl: Familiarizza con il comando kubectl, il tuo strumento principale per interagire con il cluster. Prova a creare il Deployment e il Service NGINX di questo articolo.
• Esplora i tutorial ufficiali: La documentazione di Kubernetes è una risorsa fantastica e piena di esempi.

L'orchestrazione di container è una competenza fondamentale nel mondo cloud-native, e padroneggiare Kubernetes ti aprirà un mondo di possibilità. Buon divertimento!