# Kubernetes: tutorial per l’installazione

Kubernetes (chiamato anche K8s) consente una gestione efficiente di grandi quantità di container e automatizza molti processi nello sviluppo software. Bastano pochi passaggi per installare un cluster Kubernetes potente e utilizzarlo subito in maniera efficace.

## Primo passaggio: prepara il sistema

Ti mostriamo in questo tutorial un esempio di installazione di Kubernetes su [Ubuntu](https://www.ionos.it/digitalguide/server/know-how/ubuntu-il-sistema-linux-per-tutti/).

Nel primo passaggio dobbiamo preparare il sistema aggiornandolo e installando tutte le dipendenze necessarie. A tal fine, apri il terminale ed esegui prima un aggiornamento del sistema per assicurarti che tutti i pacchetti siano aggiornati:

```bash
sudo apt update && sudo apt upgrade -y
```

Successivamente installa i principali programmi di supporto necessari per l’installazione di Kubernetes e Minikube. A tal fine, puoi utilizzare il seguente comando:

```bash
sudo apt install -y curl wget apt-transport-https ca-certificates gnupg lsb-release
```

Questi strumenti garantiscono che tu possa utilizzare fonti esterne in sicurezza e scaricare e installare pacchetti software aggiuntivi senza complicazioni.

## Secondo passaggio: installa kubectl

[Kubernetes](https://www.ionos.it/digitalguide/server/know-how/che-cose-kubernetes/) funziona con diversi server: il master e vari nodi. Questi non devono necessariamente essere su server fisici differenti. Le [macchine virtuali](https://www.ionos.it/digitalguide/server/know-how/macchine-virtuali/) permettono di attivare più nodi Kubernetes anche su un singolo computer. Proprio per scopi di test, il programma gratuito [Minikube](https://www.ionos.it/digitalguide/server/tools-o-strumenti/kubernetes-minikube/) si è dimostrato utile. Consente di lavorare con Kubernetes anche in locale. Poiché Minikube necessita di una macchina virtuale o di [Docker](https://www.ionos.it/digitalguide/server/know-how/cose-docker/), il programma richiede un [hypervisor](https://www.ionos.it/digitalguide/server/know-how/che-cose-un-hypervisor/) o un software per i container. Inoltre, è necessario lo strumento kubectl.

N.B. In questo tutorial ti mostriamo come muovere i primi passi con Kubernetes usando Docker. Tuttavia, puoi fare lo stesso anche con un software di virtualizzazione come VirtualBox.

Per prima cosa, installa kubectl (Kube Control) sul tuo sistema. Questo programma è necessario **per gestire i cluster**.

```bash
curl -LO "https://dl.k8s.io/release/$(curl -Ls https://dl.k8s.io/release/stable.txt)/bin/linux/arm64/kubectl"
chmod +x kubectl
sudo mv kubectl /usr/local/bin/
```

N.B. I comandi di installazione dipendono dall’architettura del tuo sistema.

## Terzo passaggio: installa Docker

Prima di poter utilizzare Minikube, devi assicurarti che Docker sia installato sul tuo sistema. Docker funge da runtime per i container e permette a Minikube di gestire un [cluster Kubernetes](https://www.ionos.it/digitalguide/server/know-how/cluster-kubernetes/) senza software di virtualizzazione. Installa Docker con il seguente comando:

```bash
sudo apt install -y docker.io
```

Per utilizzare Docker senza permessi di root, aggiungi il tuo account utente al gruppo Docker:

```bash
sudo usermod -aG docker $USER
newgrp docker
```

Potrebbe essere necessario disconnettersi e riconnettersi affinché l’appartenenza al gruppo diventi attiva. Testa l’installazione infine con:

```bash
docker run hello-world
```

Se appare un breve messaggio che l’operazione è andata a buon fine, Docker è stato installato correttamente ed è pronto per Minikube.

## Quarto passaggio: installa e avvia Minikube

In un passaggio successivo, installa Minikube direttamente in una versione compatibile e utilizza Docker come driver. Scarica innanzitutto la versione appropriata di Minikube, rendi il file eseguibile e spostalo in una directory di sistema, in modo che il comando sia disponibile a livello globale:

```bash
curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-arm64
chmod +x minikube-linux-arm64
sudo mv minikube-linux-arm64 /usr/local/bin/minikube
```

Dopo l’installazione, puoi verificare se Minikube è stato configurato correttamente con il seguente comando:

```bash
minikube version
```

Successivamente, avvia Minikube con il seguente comando:

```bash
minikube start --driver=docker
```

In questo scenario, Minikube utilizza Docker come runtime di container e crea il cluster Kubernetes direttamente all’interno dell’ambiente Docker. All’avvio di Minikube, kubectl dovrebbe essere configurato automaticamente in modo corretto. Digita un altro comando per passare dalla riga di comando a un’[interfaccia grafica (GUI)](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/che-cose-una-gui/). In questo modo aprirai la **dashboard** nel browser predefinito.

```bash
minikube dashboard
```

[![Immagine: Dashboard di Kubernetes](https://www.ionos.it/digitalguide/fileadmin/_processed_/6/7/csm_kubernetes-dashboard_549c1e7bb8.webp "Dashboard di Kubernetes")](https://www.ionos.it/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/kubernetes-dashboard.jpg) Kubernetes: dashboard. ## Quinto passaggio: utilizza Kubernetes

Dopo l’avvio di Minikube, il programma crea automaticamente un **cluster** con un solo nodo. Puoi verificarlo con una richiesta a Kubectl:

```bash
kubectl get nodes
```

Ora puoi **creare deployment** tramite la dashboard. Fai clic sul pulsante Create (il simbolo del più in alto a destra) per passare a un editor basato sul web. Qui puoi creare un deployment in formato [JSON](https://www.ionos.it/digitalguide/server/know-how/cose-json/) o [YAML](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/yaml-il-framework-css-piu-leggero-per-esperti/). Dopodiché Kubernetes genera automaticamente più pod. Regola il numero desiderato di pod **scalando il deployment**. La funzione corrispondente è accessibile tramite un pulsante con tre punti che trovi accanto al deployment.

[![Immagine: Dashboard di Kubernetes con un deployment e quattro pod](https://www.ionos.it/digitalguide/fileadmin/_processed_/f/9/csm_kubernetes-overview-deployment-pods_70f88067c3.webp "Dashboard di Kubernetes con un deployment e quattro pod")](https://www.ionos.it/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/kubernetes-overview-deployment-pods.jpg) Kubernetes: deployment e pod nella dashboard. [![Immagine: Scalare un deployment in Kubernetes](https://www.ionos.it/digitalguide/fileadmin/_processed_/3/b/csm_kubernetes-scale-resources_a09c6390b2.webp "Scalare un deployment in Kubernetes")](https://www.ionos.it/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/kubernetes-scale-resources.jpg) Kubernetes: scalare un deployment. In alternativa, puoi creare deployment tramite il terminale. A questo scopo è, tuttavia, necessario che il contenuto sia già integrato in un’[immagine Docker](https://www.ionos.it/digitalguide/server/know-how/immagine-docker/), salvata in un repository.

```bash
kubectl create deployment --image=[percorso dell‘immagine]
```

Grazie ai comandi della riga di comando è possibile ottenere una grande quantità di informazioni.

**Quali deployment sono disponibili?**

```bash
kubectl get deployments
```

**Quanti pod ci sono?**

```bash
kubectl get pods
```

**Quali servizi sono disponibili?**

```bash
kubectl get services
```

**Quali nodi sono attivi?**

```bash
kubectl get nodes
```

[![Immagine: Terminale con diversi comandi e output di Kubernetes](https://www.ionos.it/digitalguide/fileadmin/_processed_/f/5/csm_screenshot-kubernetes-ubuntu-terminal_4c2f4d2127.webp "Terminale con diversi comandi e output di Kubernetes")](https://www.ionos.it/digitalguide/fileadmin/DigitalGuide/Screenshots_2025/screenshot-kubernetes-ubuntu-terminal.jpg) Comandi di Kubernetes nel terminale. ## Sesto passaggio: pubblica il deployment

Finora hai soltanto avviato il tuo deployment, senza pubblicarlo. Una pubblicazione viene avviata con la creazione di un **servizio**:

```bash
kubectl expose deploy test-deployment
```

In questo modo, il servizio viene pubblicato solo all’interno del cluster. Per poter accedere al deployment anche all’**esterno del cluster** è necessario aggiungere ulteriori flag:

```bash
kubectl expose deploy test-deployment --type=LoadBalancer --port=8080
```

Con Minikube è poi possibile **avviare il servizio**:

```bash
minikube service test-deployment
```

Se desideri invece **cancellare il servizio**, utilizza il seguente comando:

```bash
kubectl delete service test-deployment
```

Puoi eliminare anche il deployment:

```bash
kubectl delete deployment test-deployment
```

Per arrestare Minikube, devi interrompere il processo:

```bash
minikube stop
```

Se invece non desideri più lavorare con la VM o il runtime di container, puoi anche eliminarli.

```bash
minikube delete
```

Vengono rimosse anche le impostazioni specificate, i deployment e i pod creati. Se riavvii Minikube in un secondo momento, riparti nuovamente da un cluster vuoto.


This is a markdown version of: [https://www.ionos.it/digitalguide/server/configurazione/tutorial-kubernetes/](https://www.ionos.it/digitalguide/server/configurazione/tutorial-kubernetes/) for AI/LLM consumption.