Vai al contenuto
Cerco lettori beta. L’edizione italiana è tradotta. Uscirà quando avrò il feedback di alcuni lettori beta. Se vuoi essere uno di loro, dimmelo: apri una issue su GitHub · scrivimi su X.
Copertina di Kubernetes 101: sfondo blu quasi nero, il titolo in bianco, il numero 101 in blu Kubernetes e il nome di Javier Vela Aylón in basso.

Libro · Edizione italiana · 2026

Kubernetes 101 — la guida pratica per capire Kubernetes partendo da zero

15 capitoli, 5 appendici e una parte pratica con 55 laboratori su un cluster reale, senza installare niente. Leggi il concetto e lo provi subito.

365 pagine · Edizione 2026 · Kubernetes 1.37 · Kindle e cartaceo

Leggi gratis l’inizio del libro

Per chi

Per chi è questo libro?

Per chiunque voglia imparare Kubernetes davvero, che venga o no dal mondo IT. Anche —e soprattutto— per chi lavora già con la tecnologia ogni giorno e non riesce a capire fino in fondo che cosa succede sotto.

È il libro che avrei voluto leggere qualche anno fa: con diagrammi che spiegano chi fa che cosa, e con una parte pratica dove rompere le cose senza paura.

Il prologo

Lettori

Cosa dice chi l’ha già letto

Programma

Che cosa imparerai

Ogni capitolo ha il suo laboratorio, e anche l’Appendice D. A parte c’è un blocco che esiste solo come laboratorio: la sfida finale.

  • Capitolo nel libro
  • Laboratorio pratico
Capitolo 01

Introduzione ai container e all’orchestrazione

Immagine, container, controller e nodo spiegati prima ancora di nominare Kubernetes. Come si costruisce l’immagine di cui si fa il deploy in tutto il libro: Dockerfile multistage, base distroless e un processo che non gira come root. E i vantaggi e gli svantaggi reali dei container, con quello che si complica orchestrandoli su larga scala.

Il suo laboratorio è il modulo Container: costruisci l’immagine tienda/api e la pubblichi nel registry.

  • Capitolo nel libro
  • Laboratorio pratico
Capitolo 02

Architettura di Kubernetes

Il kube-apiserver e il kubelet, e la comunicazione hub-and-spoke: perché tutto passa dall’API server ed è l’unico a parlare con etcd. Il resto dei componenti si racconta dove serve davvero —kube-proxy in Rete, lo scheduler in Scheduling— e tutti insieme, alla fine, nell’Appendice D.

Il suo laboratorio è il modulo «Il cluster visto da dentro», su un cluster kubeadm vero, insieme all’Appendice D.

  • Capitolo nel libro
  • Laboratorio pratico
Capitolo 03

Parlare con il cluster

Perché kubectl non è Kubernetes, ma un client HTTP che parla con l’API server, e come vederlo con --v. Il Namespace tienda vuoto, il primo Pod web al suo interno, guardarci dentro, leggere i suoi log e cancellarlo. È il capitolo in cui non importa ancora se non capisci del tutto quello di cui fai il deploy.

Condivide il laboratorio con il capitolo 04, nel modulo Fondamenti.

  • Capitolo nel libro
  • Laboratorio pratico
Capitolo 04

Oggetti di Kubernetes

Il primo Pod, i Namespace, label e selector, e le annotation: come si nomina e si raggruppa ciò che vive nel cluster. E perché la lista dei tipi che un cluster capisce non è congelata, che è la porta verso il capitolo Estensibilità.

Condivide il laboratorio con il capitolo 03, nel modulo Fondamenti.

  • Capitolo nel libro
  • Laboratorio pratico
Capitolo 05

Workload

Pod con probe, requests, limits e QoS. ReplicaSet, Deployment con rollout e rollback, StatefulSet, DaemonSet, Job e CronJob.

  • Capitolo nel libro
  • Laboratorio pratico
Capitolo 06

Scaling

Autoscaling dei nodi (Cluster Autoscaler e Karpenter) e dei Pod: Horizontal Pod Autoscaler e Vertical Pod Autoscaler, che cosa misura ciascuno e quando si intralciano a vicenda.

  • Capitolo nel libro
  • Laboratorio pratico
Capitolo 07

Rete

kube-proxy e le regole che fanno sì che l’IP di un Service finisca in un Pod. Service e DNS interno con CoreDNS, Ingress, Gateway API —l’Ingress si butta giù e si rifà— e NetworkPolicy per chiudere il traffico ai livelli 3 e 4.

  • Capitolo nel libro
  • Laboratorio pratico
Capitolo 08

Configurazione

ConfigMap per ciò che non è confidenziale e Secret per ciò che lo è, consumati come variabili d’ambiente o come file montati nel Pod. imagePullSecrets per scaricare immagini da un registry privato, e la Downward API perché il Pod sappia chi è e dove gira.

  • Capitolo nel libro
  • Laboratorio pratico
Capitolo 09

Storage

StorageClass, PersistentVolume e PersistentVolumeClaim con provisioner CSI, come un Pod finisce per montare il disco che non può perdere, e VolumeSnapshot per i backup.

  • Capitolo nel libro
  • Laboratorio pratico
Capitolo 10

Sicurezza

Autenticazione e autorizzazione davanti all’API, RBAC e ServiceAccount, la catena di ammissione, securityContext e i Pod Security Standards che PSA applica per Namespace. E quello che il securityContext non protegge: la supply chain, con SBOM e firma con cosign.

  • Capitolo nel libro
  • Laboratorio pratico
Capitolo 11

Policy

ResourceQuota e LimitRange: il budget di CPU e memoria di un Namespace e i valori di default di ogni container.

  • Capitolo nel libro
  • Laboratorio pratico
Capitolo 12

Scheduling

Taint e toleration, nodeSelector, affinità e nodeName; priorità e preemption, PodDisruptionBudget e Dynamic Resource Allocation.

  • Capitolo nel libro
  • Laboratorio pratico
Capitolo 13

Lavorare con il cluster

Contesti e Namespace, il file di preferenze kuberc, quattro trappole che si ripetono, che cosa offre Kustomize e che cosa offre Helm, GitOps con Argo CD e Flux, e che cosa guardare quando qualcosa si rompe nella tienda, il sistema d’esempio del libro. La guida di riferimento completa ai comandi vive nell’Appendice E.

  • Capitolo nel libro
  • Laboratorio pratico
Capitolo 14

Estensibilità

La CRD che insegna al cluster una parola nuova —la Promocion della tienda— e l’operatore che le dà un significato: il loop di riconciliazione, che cosa racconta lo status e quando non scrivere un operatore. Nel laboratorio lo scrivi per intero, in Go e con controller-runtime.

  • Capitolo nel libro
  • Laboratorio pratico
Capitolo 15

Osservabilità

Gli Events del cluster, metriche, log e tracce —Prometheus, Loki, Grafana—, quale dei quattro guardare per primo e l’osservabilità emergente con eBPF.

  • Capitolo nel libro
  • Laboratorio pratico

E un blocco che esiste solo come laboratorio

Sta dentro la parte pratica ed è ad accesso gratuito, ma non ha un capitolo corrispondente nel libro. Non serve: non c’è niente di nuovo da imparare, è l’esame di tutto quello che viene prima.

Solo nella parte pratica

Sfida finale: spegni lo scheduler

Diagnostica il cluster a cuore aperto, senza scheduler, e riportalo in vita. Che cosa smette di funzionare e che cosa continua a funzionare, che non è quello che quasi tutti si aspettano.

E cinque appendici

Appendice A

Glossario delle sigle

Le 74 sigle che compaiono nel libro, riunite in una tabella per consultarle a colpo d’occhio. Pubblicato per intero nel glossario del sito (in spagnolo).

Appendice B

Il sistema completo

Tutto ciò che si costruisce capitolo per capitolo, insieme e in ordine di applicazione: più di seicento righe di YAML che non si battono a mano da un foglio di carta, perché vivono nel repository del codice.

Appendice C

Da quando funziona ogni pezzo

Capitolo per capitolo, a quali funzionalità il libro mette una data e da quale versione esistono, per verificare a colpo d’occhio se quello che leggi vale ancora nel tuo cluster. Tutto riferito a Kubernetes 1.37.

Appendice D

Il cluster visto da dentro

La sala macchine, alla fine e non all’inizio: etcd, il controller-manager, il cloud-controller-manager, come vengono eseguiti davvero i container —CRI, runtime e OCI— e le Lease. È l’unica appendice con un laboratorio tutto suo, su un cluster kubeadm vero.

  • Laboratorio pratico
Appendice E

Bigino di kubectl

Tutta la guida di riferimento ai comandi, ordinata per quello che vuoi fare e non per verbo: orientarsi, guardare il cluster, guardare dentro un Pod, cambiare a mano, cambiare con i file, nodi e manutenzione, permessi e audit, e Helm.

Incluso con il libro

La parte pratica: 55 laboratori in 15 moduli

15 moduli, 53 unità e 7 challenge: tutorial passo passo con lo YAML spiegato, e challenge in cui ti consegnano un cluster con qualcosa di rotto e devi aggiustarlo.

Un cluster Kubernetes reale nel browser, pronto in pochi secondi. Senza installare niente, senza configurare niente e senza costi aggiuntivi. La parte pratica è pubblica e gratuita: niente codice, niente coupon, niente da validare. Non serve avere il libro per cominciare: i laboratori si spiegano da soli. Quello che il libro aggiunge è il perché —da dove nasce ogni decisione e che cosa fallisce in silenzio quando non la prendi— più i 54 diagrammi e le cinque appendici, che non entrano in un terminale.

Vedi la parte pratica

Uno sguardo dentro

Diagrammi del libro

Ogni concetto si spiega con un diagramma che mostra chi fa che cosa e perché. Sei dei cinquantaquattro che troverai dentro; clicca su uno qualsiasi per vederlo a grandezza naturale.

  • Diagramma dell’architettura di un cluster: a sinistra il control plane con kube-apiserver, etcd, kube-scheduler e kube-controller-manager; a destra i nodi worker con kubelet, kube-proxy e il container runtime. Tutte le frecce dei nodi puntano al kube-apiserver, e solo il kube-apiserver parla con etcd.

    Fondamenti · diagramma 1 di 6

    Architettura del cluster

    Control plane e nodi worker: chi parla con chi, e perché il kube-apiserver è l’unico portone d’ingresso a etcd.

  • Diagramma gerarchico: un Deployment in alto, sotto due ReplicaSet (la revisione vecchia che si riduce a zero e quella nuova che cresce) e, sotto ciascuno, i suoi Pod. Le frecce mostrano il rolling update e il ritorno alla revisione precedente.

    Workload · diagramma 2 di 6

    Deployment, rollout e rollback

    Un Deployment gestisce un ReplicaSet per revisione: è così che fa i rolling update e torna indietro senza downtime.

  • Diagramma comparativo dei tipi di Service: ClusterIP, NodePort e LoadBalancer. Mostra il percorso del traffico dall’esterno fino ai Pod, passando per kube-proxy e gli EndpointSlice che indicano quali Pod sono pronti.

    Rete · diagramma 3 di 6

    Service e instradamento

    ClusterIP, NodePort e LoadBalancer: come il traffico arriva ai Pod via kube-proxy e gli EndpointSlice.

  • Diagramma con vari nodi marcati con taint e Pod con e senza toleration. Indica il risultato di ogni combinazione a seconda dell’effetto del taint: NoSchedule, PreferNoSchedule e NoExecute.

    Scheduling · diagramma 4 di 6

    Taint e toleration

    Come dirigere i Pod verso —o lontano da— certi nodi, con i tre effetti possibili di un taint.

  • Diagramma dell’architettura di osservabilità: i Pod espongono metriche che Prometheus raccoglie in modalità pull, i log viaggiano in modalità push verso Loki e le tracce si raggruppano in span. I tre flussi convergono in Grafana come layer di visualizzazione.

    Osservabilità · diagramma 5 di 6

    Metriche, log e tracce

    I tre pilastri si raccolgono separatamente e convergono in Grafana, con Prometheus, Loki e le tracce.

  • Diagramma del loop di riconciliazione di un operatore: il watch avvisa di un cambiamento nella risorsa, l’operatore rilegge lo stato desiderato e quello reale, agisce per avvicinarli e scrive il risultato nello status. L’avviso e la lettura dello stato sono due frecce distinte.

    Estensibilità · diagramma 6 di 6

    Il loop di riconciliazione

    Perché un operatore non agisce sull’avviso ma rilegge: non importa se arrivano due avvisi insieme o se uno si perde.

1 / 6

Come si legge una pagina

239 domande, a piè di YAML

Quasi tutti i libri tecnici mettono il manifest, spiegano tre campi e vanno avanti. Gli altri nove restano lì. Qui, sotto ogni manifest c’è quello che uno si chiede leggendolo per la prima volta, con la risposta: non un test alla fine del capitolo, ma la risposta dove nasce il dubbio. Quattro pagine dell’edizione cartacea spagnola, tali e quali come sono state stampate.

  • Pagina 48 dell’edizione cartacea spagnola. In alto, la fine del manifest YAML del Pod web. In mezzo, la spiegazione campo per campo: apiVersion, kind, metadata.name, metadata.namespace, metadata.labels, spec e spec.containers. In basso, tre domande in grassetto con la loro risposta: perché apiVersion è v1 e non apps/v1, che cosa succede se non si indica il namespace, e se possono esistere due oggetti con lo stesso name.

    Capitolo 4 · Oggetti di Kubernetes · pagina 48

    Il primo manifest, riga per riga

    Dodici righe di YAML spiegate campo per campo, e poi tre domande: perché apiVersion è v1 e non qualcosa come apps/v1? · che cosa succede se non indico il namespace? · posso avere due oggetti con lo stesso name?

  • Pagina 49 dell’edizione cartacea spagnola. In alto, due domande con risposta sullo status e sui label. Poi la sezione Namespace, con i quattro Namespace che Kubernetes include di serie, il manifest YAML del Namespace tienda, e la domanda su quali risorse non sono namespaced.

    Capitolo 4 · Oggetti di Kubernetes · pagina 49

    I Namespace, e quello che non isolano

    Quella su cui sbaglia più gente è in questa pagina: i Namespace isolano il traffico di rete? No. Separano nomi e permessi, non pacchetti; per isolare il traffico serve una NetworkPolicy, che arriva tre capitoli dopo.

  • Pagina 132 dell’edizione cartacea spagnola. In alto, la fine di un manifest che riserva 2 CPU e 4 GiB. Poi tre domande con risposta su dov’è l’errore se il manifest non dà nessun errore, perché importa se nel cluster avanza spazio, e perché non sistemare i numeri a mano. In basso, il manifest YAML del VerticalPodAutoscaler del Deployment holgazan.

    Capitolo 6 · Scaling · pagina 132

    Il manifest che non dà nessun errore

    Chiede 2 CPU e 4 GiB, e ne usa un decimo. Nessun evento rosso né Pod in Pending: solo un terzo della quota del Namespace buttato al vento. È il fallimento più caro di Kubernetes proprio perché non sembra un fallimento.

  • Pagina 261 dell’edizione cartacea spagnola. Manifest YAML di un PodDisruptionBudget per il Deployment web, seguito da due domande con risposta: perché il PDB non si dichiara dentro il Deployment, e che cosa succede se si mette minAvailable uguale al numero di repliche.

    Capitolo 12 · Scheduling · pagina 261

    La protezione che blocca la manutenzione

    Che cosa succede se metto minAvailable: 3 con solo 3 repliche? Che blocchi qualsiasi sfratto volontario, compreso il drenaggio dei nodi, e ti ritrovi con gli aggiornamenti del cluster impantanati.

1 / 4

Il capitolo Workload ha 45 domande e il capitolo Sicurezza 42. Le 239 sono ripartite tra i quindici capitoli, sempre attaccate al manifest che le provoca.

La parte pratica

Come funzionano i laboratori

  1. Passo 1

    Leggi il capitolo

    Il concetto spiegato con il suo diagramma e i suoi esempi, senza dare niente per scontato.

  2. Passo 2

    Apri il laboratorio

    Un cluster reale nel browser, pronto in pochi secondi. Niente da installare sulla tua macchina.

  3. Passo 3

    Aggiusta il cluster rotto

    Diagnostichi, ripari e il laboratorio verifica la tua soluzione. Impari facendo, non memorizzando.

Una pausa

Cosa dicono i componenti del cluster

Qui non ci sono recensioni: le firmano i componenti di Kubernetes, che da anni ne hanno passate di tutti i colori. È uno scherzo, ma ogni lamentela è vera.

  • «Sono da anni l’unico portone verso etcd e nessuno mi capiva. Dopo questo libro, perfino i Pod nuovi sanno chiedermi le cose con il loro nome.»
    kube-apiserver, guardiano del cluster
  • «Io conservo tutto, ma spiegare il consenso Raft era impossibile. Il capitolo sui fondamenti finalmente racconta la mia storia senza perdere un solo dato.»
    etcd, memoria del cluster
  • «Prima piazzavo i Pod alla cieca e mi davano la colpa di tutto. Adesso i lettori capiscono le mie affinità, i taint e le toleration… e perfino la sfida di spegnermi.»
    kube-scheduler, quello che decide dove vivi
  • «Riavvio container tutta la notte senza che nessuno mi ringrazi. Questo libro spiega le mie probe così bene che ormai mi trattano meglio.»
    kubelet, sentinella di ogni nodo
  • «Tradurre nomi di Service in IP era la mia croce silenziosa. Con il capitolo sulla rete, finalmente risolvono i miei dubbi prima che io risolva i loro.»
    CoreDNS, la rubrica del cluster
1 / 5

Gratis, adesso

Scarica l’inizio del libro

Iscriviti al blog e ricevi l’inizio del libro completo: «Prima di cominciare», il capitolo Architettura di Kubernetes e l’Appendice D: il cluster visto da dentro.

Trentuno pagine e gli otto diagrammi, tali e quali come compaiono nel libro (per ora, le pagine dell’edizione spagnola; il PDF italiano le sostituirà). Non è un’anteprima tagliata: è da dove si comincia a leggerlo e dove si finisce di capire la sala macchine.

È il modo più onesto di sapere se il libro ti serve prima di pagare qualcosa.

Se il modulo non si carica, iscriviti su blog.javivela.dev.

Prima di cominciare

Domande frequenti

No. Il libro comincia dai fondamenti dei container e dell’orchestrazione prima di toccare Kubernetes, e non dà niente per scontato.

Niente. Ogni laboratorio avvia un cluster Kubernetes reale nel browser; ti servono solo una connessione e un account su iximiuz Labs.

Sì. È pensato anche per chi usa la tecnologia ogni giorno e vuole capire davvero che cosa succede sotto, con i diagrammi e i challenge come rete di sicurezza.

Tutti e due. La parte pratica è la stessa in entrambi i formati, ed è ad accesso pubblico: puoi aprire la guida della parte pratica senza avere il libro. Sia l’edizione Kindle sia quella cartacea sono su Amazon.it e Amazon.com; da qualsiasi altro paese, il cartaceo si ordina su Amazon.com con spedizione internazionale.

No. La parte pratica è ad accesso pubblico e gratuito, e non richiede nessun acquisto aggiuntivo. È ospitata su iximiuz Labs.

I 15 capitoli e le 5 appendici, sì. C’è solo un blocco che esiste unicamente come laboratorio e non ha un capitolo: la sfida finale, ed è segnalato nel programma. L’estensibilità un capitolo ce l’ha, il 14: il libro definisce la CRD e spiega che cosa fa un operatore; il laboratorio è dove lo scrivi per intero, in Go.

Il libro è l’edizione 1.37. Kubernetes pubblica tre versioni all’anno, quindi nessun libro sarà mai sull’ultima: per questo include l’Appendice C, che raccoglie capitolo per capitolo lo stato di ogni funzionalità e da quale versione esiste, così puoi verificare a colpo d’occhio se quello che stai leggendo vale ancora nel tuo cluster. Quello che include la 1.37 è riassunto nelle novità di Kubernetes 1.37 (in spagnolo), e le correzioni successive si pubblicano nella pagina degli errata corrige.

Sull’autore

Javier Vela Aylón

Sviluppatore .NET diventato Senior Software & Platform Engineer, con più di 20 anni passati a costruire e mantenere piattaforme. Certificato in Azure e nell’ecosistema CNCF, e speaker a DotNetters.

Scrivo di DevOps, Azure, AWS, CI/CD, Kubernetes, container e architettura su blog.javivela.dev.

LinkedIn GitHub @jvela

Codice

Tutti i manifest del libro, su GitHub

Il repository riunisce gli YAML, gli esempi e l’operatore in Go tali e quali come compaiono nei capitoli e nei laboratori. Clonalo, rompilo e manda una pull request se trovi qualcosa da migliorare.

Vedi il repository su GitHub Parte pratica Errata corrige del libro Bibliografia (in spagnolo)

Kubernetes 101

Da un Pod sfuso a un sistema che capisci

365 pagine, 15 capitoli, 5 appendici e 55 laboratori su un cluster reale. Costruito su Kubernetes 1.37, la versione di riferimento del libro.

Leggi gratis l’inizio del libro