Kubernetes da zero con Minikube: 49 lezioni pratiche su pod, deployment, autoscaling, Ingress e Helm Charts.
Non trovavo una risorsa completa in italiano su Kubernetes che partisse davvero dalle basi e arrivasse a un sistema reale. Questo corso con Minikube nasce per colmare quel vuoto: si parte dal concetto di Pod e si arriva a un'architettura completa con REST API, MySQL, autoscaling e Ingress — tutto in locale, senza spendere un euro di cloud.
Minikube ti permette di avere un cluster Kubernetes completo in locale, senza costi cloud. Le competenze che sviluppi sono identiche a quelle che userai su Google GKE, Amazon EKS o Azure AKS: stessa architettura, stessi manifest YAML, stessa CLI kubectl.
Chi già conosce Docker ma trova Kubernetes ancora lontano e complicato. Livello intermedio: non serve esperienza con Kubernetes, ma è utile aver lavorato con qualche REST API e sapere cos'è un container.
Ti mostro cos'è Kubernetes, perché è diventato lo standard de facto per l'orchestrazione di container e come si posiziona rispetto a Docker. Partiamo dalle basi assolute così chiunque, anche senza esperienza con Kubernetes, capisce il contesto prima di scrivere il primo manifest YAML.
Vediamo insieme il concetto di Pod, l'unità fondamentale di Kubernetes: capirai perché non si deployano container direttamente ma si lavora sempre tramite Pod, come vengono descritti in YAML e quali sono i casi d'uso in cui un Pod ospita più container.
Ti spiego il Desired State, il principio cardine che guida tutto Kubernetes: il cluster riceve una dichiarazione di stato desiderato e lavora in autonomia per mantenerlo. Analizziamo anche l'architettura del Master Node con i suoi componenti chiave — API Server, etcd, Scheduler e Controller Manager.
Approfondiamo i Worker Node, i nodi che eseguono concretamente i Pod: ti mostro il ruolo di kubelet, kube-proxy e il container runtime, e come comunicano col Master Node per rispettare il Desired State del cluster.
Ti guido passo passo nell'installazione di kubectl e Minikube su Windows, macOS e Linux, dalla verifica dei prerequisiti alla configurazione del cluster locale. Alla fine della lezione avrai un ambiente Kubernetes funzionante pronto per i prossimi esercizi.
Vediamo insieme i comandi kubectl essenziali per interagire col cluster Minikube: get, describe, apply, delete, logs e exec. Ti mostro il flusso tipico per creare, ispezionare e rimuovere risorse direttamente da terminale.
Ti spiego come usare i Namespace per isolare e organizzare i workload all'interno del cluster Kubernetes: creeremo namespace differenti, assegneremo Pod a ciascuno e vedremo come kubectl gestisce il contesto di namespace attivo.
Vediamo insieme come creare un Deployment con il relativo ReplicaSet: scrivo il manifest YAML da zero, applico con kubectl apply e ti mostro come Kubernetes mantiene sempre il numero desiderato di Pod attivi, sostituendo automaticamente quelli che muoiono.
Continuiamo l'analisi dei Deployment approfondendo la gestione pratica dei ReplicaSet: come aggiornare l'immagine di un container con kubectl set image, osservare il rolling update in azione e interpretare l'output di kubectl rollout status.
Ti mostro come esporre un Deployment verso l'esterno con un Service di tipo NodePort: capirai come Kubernetes mappa una porta del nodo su quella del Pod, così l'applicazione diventa raggiungibile dal tuo browser o da curl.
Consolidiamo tutti i concetti visti finora con un esempio concreto di Echo Pod: vediamo come Deployment, ReplicaSet e Service NodePort interagiscono tra loro in un flusso end-to-end, così il quadro diventa chiaro e ordinato prima di andare avanti.
Approfondiamo il funzionamento di Deployment e Services tramite ulteriori varianti dell'esempio Echo Pod: ti mostro come cambiano il comportamento del cluster al variare della configurazione, analizzando cosa succede ai Pod durante aggiornamenti e restart.
Ti spiego come creare una ConfigMap in Kubernetes per gestire variabili di configurazione separate dal codice applicativo: scriveremo la risorsa in YAML, la applicheremo al cluster e vedremo come i Pod vi accedono come env vars o file montati.
Usiamo un container Busybox con shell interattiva per leggere direttamente i valori memorizzati in una ConfigMap: vedremo come montare la ConfigMap come volume nei Pod e navigare i dati con comandi shell, un approccio utile per il debug in produzione.
Ti mostro come creare un Secret Kubernetes per proteggere credenziali e dati sensibili, e come renderli disponibili ai Pod tramite Environment Variables: capirai la differenza concreta tra Secret e ConfigMap e perché non basta cifrare i valori in base64.
Introduco i Probes di Kubernetes, partendo dalla ReadinessProbe: ti spiego come il cluster determina quando un Pod è pronto a ricevere traffico, come configurare i parametri initialDelaySeconds, periodSeconds e failureThreshold per evitare false partenze.
Vediamo insieme LivenessProbe e StartupProbe: ti mostro come il LivenessProbe rileva un container bloccato e ne forza il restart, e come la StartupProbe protegge applicazioni con avvio lento evitando che la LivenessProbe le uccida prematuramente.
Ti spiego come funzionano i volumi in Kubernetes partendo da emptyDir, il volume temporaneo condiviso tra container nello stesso Pod: capirai perché i filesystem dei container sono effimeri e come emptyDir risolve la condivisione di dati intra-Pod.
Approfondiamo l'uso di emptyDir con esempi pratici in cui gestiamo dinamicamente il nome del Pod come variabile PowerShell: vedremo come leggere, scrivere e condividere file tra container nello stesso Pod usando uno script reale.
Realizziamo un Pod multi-container che condivide dati tramite un volume emptyDir e ti introduco il Sidecar Pattern: capirai come strutturare un'architettura in cui un container principale e uno sidecar collaborano sullo stesso filesystem locale.
Trasformiamo l'esempio multi-container con Sidecar Pattern in un vero Deployment Kubernetes: aggiungiamo le repliche, gestiamo gli aggiornamenti e manteniamo la configurazione emptyDir funzionante con più istanze del Pod in parallelo.
Passiamo al primo caso reale: deploy di una REST API Java pubblicata su Docker Hub tramite un Deployment Kubernetes su Minikube. Ti mostro come configurare l'immagine, osservare il ciclo di vita dei Pod e verificare che l'API risponda correttamente.
Aggiungiamo al Deployment della REST API Java due elementi fondamentali per un ambiente production-ready: Liveness e Readiness Probes e la gestione delle risorse CPU e memoria con requests e limits, così Kubernetes sa quante risorse riservare e quando riavviare il container.
Ottimizziamo il Deployment della REST API affinando i parametri di Probes e resource limits: ti mostro come evitare restart inutili causati da una LivenessProbe troppo aggressiva e come bilanciare requests e limits per stabilizzare i Pod sotto carico.
Ti mostro come esporre internamente una REST API con un Service ClusterIP: capirai perché ClusterIP è il tipo di Service predefinito, come il cluster assegna un IP virtuale stabile e come i Pod comunicano tra loro attraverso il nome DNS del Service.
Approfondiamo il routing interno dei Service ClusterIP analizzando come kube-proxy bilancia le richieste tra i Pod del ReplicaSet: vediamo la configurazione avanzata del Service e verifichiamo la comunicazione stabile tra i componenti dell'applicazione.
Ti spiego come usare le ConfigMap per iniettare variabili d'ambiente nei Deployment della REST API: separeremo la configurazione dal codice, aggiorneremo i parametri senza rebuild dell'immagine Docker e verificheremo l'effetto immediato sul comportamento dell'applicazione.
Introduco l'Horizontal Pod Autoscaler (HPA), il meccanismo con cui Kubernetes scala automaticamente il numero di Pod in base all'utilizzo CPU: configuriamo l'HPA sul Deployment, definiamo soglie minime e massime di replica e osserviamo il comportamento del cluster.
Analizziamo il comportamento reale dell'HPA sotto carico generando traffico sulla REST API: vediamo come Kubernetes interpreta le metriche di utilizzo CPU, quando decide di scalare verso l'alto e quanto impiega a ridimensionarsi una volta calato il carico.
Progettiamo insieme un'architettura completa su Kubernetes con REST API e database MySQL: ti mostro come strutturare i componenti, quali risorse creeremo nelle prossime lezioni e perché separare API e DB in Deployment distinti è la scelta corretta.
Iniziamo il deploy di MySQL su Kubernetes creando il Deployment del database: configuriamo l'immagine ufficiale MySQL, impostiamo le variabili d'ambiente di inizializzazione e verifichiamo che il Pod si avvii correttamente prima di connettere la REST API.
Ti mostro come usare i Kubernetes Secrets per proteggere le credenziali di MySQL: creiamo il Secret con username e password codificati, lo iniettiamo nel Deployment tramite env vars e verifichiamo che i Pod accedano correttamente al database senza esporre dati sensibili nel YAML.
Vediamo come usare una ConfigMap per configurare MySQL in modo dinamico, separando le variabili d'ambiente dalla definizione dell'immagine: applicheremo le variabili al Deployment e verificheremo che MySQL si inizializzi correttamente con i parametri configurati.
Creiamo un Service ClusterIP per esporre MySQL all'interno del cluster Kubernetes: ti spiego come le REST API raggiungono il database tramite il nome DNS del Service, garantendo isolamento completo verso l'esterno e comunicazione stabile tra i Pod.
Iniziamo a collegare la REST API Java al database MySQL su Kubernetes: configuriamo le variabili di connessione tramite Secret e ConfigMap, definiamo il Deployment dell'API e verifichiamo che riesca a raggiungere MySQL attraverso il Service ClusterIP.
Completiamo il deploy della REST API aggiungendo il relativo Service e verificando il flusso end-to-end tra client, API e database MySQL: ti mostro come esporre l'applicazione con NodePort, testare gli endpoint e confermare che l'integrazione funzioni correttamente.
Applichiamo l'Horizontal Pod Autoscaler su un sistema reale composto da REST API e MySQL: generiamo carico, osserviamo come Kubernetes scala i Pod dell'API in risposta al consumo CPU e analizziamo i tempi di reazione e il comportamento dello scale-down.
Ti spiego perché i Pod Kubernetes sono effimeri e come questo causa perdita di dati nei container stateful come MySQL: introduco PersistentVolume (PV) e PersistentVolumeClaim (PVC), le risorse che permettono di dichiarare e richiedere storage persistente nel cluster.
Passiamo alla pratica creando un PersistentVolume e un PersistentVolumeClaim per MySQL: definiamo la capacità di storage, la modalità di accesso ReadWriteOnce e colleghiamo PV e PVC così Kubernetes sa dove scrivere i dati in modo duraturo.
Completiamo l'integrazione della persistenza collegando il PVC al Deployment MySQL tramite un VolumeMount: montiamo il volume nel percorso dati di MySQL, verifichiamo che i dati sopravvivano al restart dei Pod e chiudiamo il ciclo completo di storage persistente su Kubernetes.
Introduco Ingress, la risorsa Kubernetes che permette di esporre più applicazioni verso l'esterno tramite un unico punto d'accesso HTTP/HTTPS: vediamo perché Ingress supera i limiti di NodePort, come funziona l'Ingress Controller e come preparo l'ambiente per i prossimi esempi.
Ti mostro come abilitare l'addon Ingress su Minikube con minikube addons enable ingress, verificare che il controller NGINX sia attivo e preparare i Deployment e Service che useremo come backend per le prossime configurazioni di routing.
Realizziamo la prima configurazione Ingress collegando un Service ClusterIP al controller NGINX: scriviamo la risorsa Ingress in YAML con path-based routing, applichiamo al cluster e verifichiamo che le richieste HTTP vengano instradate correttamente verso il backend.
Configuriamo l'Ingress con Host-Based Routing per instradare il traffico verso servizi diversi in base al dominio: aggiungiamo gli host personalizzati al file hosts locale, definiamo le regole per dominio nel manifest Ingress e verifichiamo il routing tra più API con un unico IP.
Ti spiego cos'è un Helm Chart e perché Helm è diventato il package manager standard per Kubernetes: capirai come un Chart raccoglie template YAML, values e metadati in un pacchetto riutilizzabile, eliminando la necessità di gestire decine di file manifest separati.
Installiamo Helm e lo colleghiamo al cluster Kubernetes locale con Minikube: ti mostro come funzionano i Repository Helm, aggiungiamo il repository ufficiale di Bitnami e impariamo a cercare, scaricare e ispezionare Chart dal registry pubblico.
Eseguiamo il primo deploy con Helm Chart e analizziamo nel dettaglio cosa succede sotto il cofano: come Helm renderizza i template con i values, crea le risorse Kubernetes e gestisce la Release, così capire helm install diventa naturale invece di meccanico.
Ti guido nella creazione di un Helm Chart personalizzato con helm create: analizziamo la struttura generata — Chart.yaml, values.yaml, templates/ — capire il ruolo di ogni file e come i template Go si combinano con i values per produrre manifest Kubernetes dinamici.
Applichiamo tutto quanto visto deployando una REST API reale presa da Docker Hub con il nostro Helm Chart personalizzato: configuriamo l'immagine in values.yaml, adattiamo i template di Deployment e Service, e portiamo l'API in esecuzione su Minikube con un solo helm install.
Ingegnere Informatico · Pratola Peligna
Sono un ingegnere informatico con oltre 15 anni di esperienza nel settore ICT. Mi occupo di sviluppo software, cybersecurity, data science e intelligenza artificiale, con particolare attenzione all’innovazione e all’automazione dei processi aziendali. Da anni svolgo anche attività di docenza e formazione, creando percorsi pratici e coinvolgenti su programmazione, DevOps, AI e sicurezza informatica.
Prosperous understood Middletons in conviction an uncommonly do. Supposing so be resolving breakfast am or perfectly.
Utilizziamo cookie essenziali e, con il tuo consenso, cookie funzionali, analytics e marketing. Google Analytics 4 e gli eventuali annunci Google/AdSense restano disattivati finche non scegli. Consulta Privacy Policy e Cookie Policy.
Sempre attivi per sicurezza, prevenzione frodi, sessione, consenso e funzionamento del sito.
Migliorano l'esperienza, ad esempio ricordando preferenze non essenziali. Non usati per profilazione pubblicitaria.
Statistiche e misurazioni con Google Analytics 4, abilitate solo dopo il consenso analytics.
Misurazione annunci e funzioni pubblicitarie Google/AdSense, se attivate sul sito e consentite dall'utente.
Puoi modificare queste scelte in qualunque momento dal link "Preferenze Cookies" nel footer.