DevOps Kubernetes

Kubernetes tutorial da zero, con Minikube: Guida completa passo passo

Kubernetes da zero con Minikube: 49 lezioni pratiche su pod, deployment, autoscaling, Ingress e Helm Charts.

Descrizione del corso

Kubernetes da zero con Minikube: 44 lezioni core + 5 su 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.

Cosa imparerai nelle 49 lezioni

  • Architettura Kubernetes: Master Node, Worker Node e Desired State
  • Pod, Deployment e ReplicaSet: le basi con manifest YAML reali e kubectl
  • ConfigMap e Secret: separare configurazione e credenziali dal codice
  • Networking: Service NodePort, ClusterIP e Ingress con host-based routing
  • Health monitoring: ReadinessProbe, LivenessProbe e StartupProbe
  • Volumi e storage: emptyDir, Sidecar Pattern, PersistentVolume e PVC
  • Autoscaling con HPA: Horizontal Pod Autoscaler in azione sotto carico reale
  • Progetto completo: deploy di una REST API Java con MySQL su Kubernetes
  • Helm Charts: installare, creare e deployare un'API con il tuo Chart personalizzato

Perché Minikube

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.

Per chi è

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.

Elenco delle lezioni

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione

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.

Guarda lezione
Giovanni Pace

Giovanni Pace

Ingegnere Informatico · Pratola Peligna

  • 107 Corsi
Mi presento brevemente

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.

Questo corso include

  • Lezioni 49
  • Durata 9h 41m
  • Difficoltà intermedio
  • Lingua it
  • Certificato No

Visti di recente