Preparazione di un'applicazione per Anthos Service Mesh

Anthos Service Mesh è un potente strumento per la gestione e il monitoraggio delle applicazioni distribuite. Per ottenere il massimo da Anthos Service Mesh, è utile comprendere le astrazioni sottostanti, tra cui container e Kubernetes. Questo tutorial ti porta dal codice sorgente a un container in esecuzione su GKE, fino al momento appena prima di installare Anthos Service Mesh.

Se hai già familiarità con i concetti di base di Kubernetes e del mesh di servizi, puoi saltare questo tutorial e andare direttamente alle guide all'installazione di Anthos Service Mesh.

Obiettivi

In questo tutorial imparerai a:

Esplora una semplice applicazione "Hello World" multiservizio.
Esegui l'applicazione dall'origine
Containerizza l'applicazione.
Creare un cluster Kubernetes.
Eseguire il deployment dei container nel cluster.

Prima di iniziare

Segui questi passaggi per abilitare l'API Anthos Service Mesh:

Visita la pagina Kubernetes Engine nella console Google Cloud.
Crea o seleziona un progetto.
Attendi che l'API e i servizi correlati siano abilitati. Questa operazione può richiedere diversi minuti.

Make sure that billing is enabled for your Google Cloud project.

Puoi seguire questo tutorial utilizzando Cloud Shell, che esegue il provisioning di una macchina virtuale (VM) g1-small Google Compute Engine che esegue un sistema operativo Linux basato su Debian o sul tuo computer che esegue Linux o macOS.

Opzione A: utilizza Cloud Shell

I vantaggi dell'utilizzo di Cloud Shell sono:

Entrambi gli ambienti di sviluppo Python 2 e Python 3 (incluso virtualenv) sono tutti configurati.
Gli strumenti a riga di comando gcloud, docker, git e kubectl utilizzati in questo tutorial sono già installati.
Puoi scegliere di editor di testo:
- Editor di codice, a cui puoi accedere facendo clic su nella parte superiore della finestra di Cloud Shell.
- Emacs, Vim o Nano, a cui puoi accedere dalla riga di comando in Cloud Shell.

Per utilizzare Cloud Shell:

Vai alla console Google Cloud.
Fai clic sul pulsante Attiva Cloud Shell nella parte superiore della finestra della console Google Cloud.

All'interno di un nuovo frame nella parte inferiore della console Google Cloud si apre una sessione di Cloud Shell che mostra un prompt della riga di comando.

Opzione B: utilizza gli strumenti a riga di comando localmente

Se preferisci seguire questo tutorial sul tuo computer Linux o macOS, devi configurare e installare quanto segue:

Configura un ambiente di sviluppo Python 3 e Python 2.
Installa Google Cloud CLI.
Installa kubectl, anche una riga di comando che utilizzi per comunicare con Kubernetes.
```
gcloud components install kubectl
```
Installa Docker Community Edition (CE). Puoi utilizzare lo strumento a riga di comando docker per creare immagini container dell'applicazione di esempio.
Installa lo strumento Controllo origine Git in modo da poter recuperare l'applicazione di esempio da GitHub.

Download del codice campione in corso...

Scarica il codice sorgente helloserver:

git clone https://github.com/GoogleCloudPlatform/istio-samples

Passa alla directory codice campione:

cd istio-samples/sample-apps/helloserver

Esplorazione dell'applicazione multi-servizio

L'applicazione di esempio è scritta in Python e ha due componenti che comunicano tramite REST:

server: un server semplice con un endpoint GET, / , che visualizza "hello world" sulla console.
loadgen: uno script che invia traffico a server, con un numero configurabile di richieste al secondo (RPS).

applicazione di esempio

Esegui l'applicazione dall'origine

Per acquisire familiarità con l'applicazione di esempio, eseguila in Cloud Shell o sul tuo computer.

Dalla directory sample-apps/helloserver, esegui server:
```
python3 server/server.py
```
All'avvio, l'server mostra quanto segue:
```
INFO:root:Starting server...
```
Apri un'altra finestra del terminale per inviare richieste a server. Se utilizzi Cloud Shell, fai clic su per aprire un'altra sessione.
Invia una richiesta a server:
```
curl http://localhost:8080
```
server risponde:
```
Hello World!
```
Dalla directory in cui hai scaricato il codice campione, passa alla directory che contiene loadgen:
```
cd YOUR_WORKING_DIRECTORY/istio-samples/sample-apps/helloserver/loadgen
```

Crea le seguenti variabili di ambiente:

export SERVER_ADDR=http://localhost:8080
export REQUESTS_PER_SECOND=5

Avvia virtualenv:
```
virtualenv --python python3 env
```
Attiva l'ambiente virtuale:
```
source env/bin/activate
```
Installa i requisiti per loadgen:
```
pip3 install -r requirements.txt
```
Esegui loadgen:
```
python3 loadgen.py
```
All'avvio, loadgen restituisce un messaggio simile al seguente:
```
Starting loadgen: 2019-05-20 10:44:12.448415
5 request(s) complete to http://localhost:8080
```
Nell'altra finestra del terminale, server scrive nella console messaggi simili al seguente:
```
127.0.0.1 - - [21/Jun/2019 14:22:01] "GET / HTTP/1.1" 200 -
INFO:root:GET request,
Path: /
Headers:
Host: localhost:8080
User-Agent: python-requests/2.22.0
Accept-Encoding: gzip, deflate
Accept: */*
```
Dal punto di vista del networking, ora l'intera applicazione è in esecuzione sullo stesso host (sul computer locale o sulla VM di Cloud Shell). Per questo motivo, puoi utilizzare localhost per inviare richieste al server.
Per arrestare loadgen e server, inserisci Ctrl-c in ogni finestra del terminale.
Nella finestra del terminale loadgen, disattiva l'ambiente virtuale:
```
deactivate
```

Inserimento dell'applicazione nel container

Per eseguire l'applicazione su GKE, devi pacchettizzare l'applicazione di esempio, sia server sia loadgen, in containers. Un container è un modo per pacchettizzare un'applicazione in modo da essere isolata dall'ambiente sottostante.

Per containerizzare l'applicazione, è necessario un Dockerfile. Un Dockerfile è un file di testo che definisce i comandi necessari per assemblare il codice sorgente dell'applicazione e le sue dipendenze in un'immagine Docker. Dopo aver creato l'immagine, la carica in un Container Registry, come Docker Hub o Container Registry.

Nell'esempio viene fornito con un Dockerfile sia per server sia per loadgen con tutti i comandi necessari per creare le immagini. Di seguito è riportato il Dockerfile per server:

FROM python:3.9-slim as base
FROM base as builder
RUN apt-get -qq update \
    && apt-get install -y --no-install-recommends \
        g++ \
    && rm -rf /var/lib/apt/lists/*

# Enable unbuffered logging
FROM base as final
ENV PYTHONUNBUFFERED=1

RUN apt-get -qq update \
    && apt-get install -y --no-install-recommends \
        wget

WORKDIR /helloserver

# Grab packages from builder
COPY --from=builder /usr/local/lib/python3.9/ /usr/local/lib/python3.9/

# Add the application
COPY . .

EXPOSE 8080
ENTRYPOINT [ "python", "server.py" ]

Il comando FROM python:3-slim as base indica a Docker di utilizzare l'immagine Python 3 più recente come immagine di base.
Il comando COPY . . copia i file di origine presenti nella directory di lavoro corrente (in questo caso, solo server.py) nel file system del container.
ENTRYPOINT definisce il comando utilizzato per eseguire il container. In questo caso, il comando è quasi uguale a quello che hai utilizzato per eseguire server.py dal codice sorgente.
Il comando EXPOSE specifica che server rimane in ascolto sulla porta 8080. Questo comando non espone alcuna porta, ma serve da documentazione necessaria per aprire la porta 8080 quando esegui il container.

Preparati a containerizzare l'applicazione

Imposta le seguenti variabili di ambiente. Sostituisci PROJECT_ID con l'ID del tuo progetto Google Cloud.
```
export PROJECT_ID="PROJECT_ID"
```
```
export GCR_REPO="asm-ready"
```
Utilizza il valore PROJECT_ID e GCR_REPO per taggare l'immagine Docker quando crei e poi ne esegui il push al tuo Container Registry privato.
Imposta il progetto Google Cloud predefinito per Google Cloud CLI.
```
gcloud config set project $PROJECT_ID
```
Imposta la zona predefinita per Google Cloud CLI.
```
gcloud config set compute/zone us-central1-b
```
Assicurati che il servizio Container Registry sia abilitato nel tuo progetto Google Cloud.
```
gcloud services enable containerregistry.googleapis.com
```

Containerizza `server`

Passa alla directory in cui si trova l'esempio server:

cd YOUR_WORKING_DIRECTORY/istio-samples/sample-apps/helloserver/server/

Crea l'immagine utilizzando Dockerfile e le variabili di ambiente che hai definito in precedenza:
```
docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1 .
```
Il flag -t rappresenta il tag Docker. È il nome dell'immagine che utilizzi quando esegui il deployment del container.

Esegui il push dell'immagine a Container Registry:

docker push gcr.io/$PROJECT_ID/$GCR_REPO/helloserver:v0.0.1

Containerizza `loadgen`

Passa alla directory in cui si trova l'esempio loadgen:
```
cd ../loadgen
```

Crea l'immagine:

docker build -t gcr.io/$PROJECT_ID/$GCR_REPO/loadgen:v0.0.1 .

Esegui il push dell'immagine a Container Registry:

docker push gcr.io/$PROJECT_ID/$GCR_REPO/loadgen:v0.0.1

Elenca le immagini

Ottieni un elenco delle immagini nel repository per confermare che sia stato eseguito il push delle immagini:

gcloud container images list --repository gcr.io/$PROJECT_ID/asm-ready

Il comando risponde con i nomi delle immagini di cui hai appena eseguito il push:

NAME
gcr.io/PROJECT_ID/asm-ready/helloserver
gcr.io/PROJECT_ID/asm-ready/loadgen

Crea un cluster GKE

Puoi eseguire questi container sulla VM Cloud Shell o sulla workstation utilizzando il comando docker run. In produzione, però, devi orchestrare i container in modo più unificato. Ad esempio, hai bisogno di un sistema che garantisca che i container siano sempre in esecuzione e di un modo per fare lo scale up e avviare istanze aggiuntive di un container per gestire l'aumento del traffico.

Puoi utilizzare GKE per eseguire applicazioni containerizzate. GKE è una piattaforma di orchestrazione di container che funziona collegando le VM a un cluster. Ogni VM è definita come nodo. I cluster GKE sono basati sul sistema open source di gestione dei cluster Kubernetes. Kubernetes fornisce i meccanismi che consentono di interagire con il cluster.

Per creare un cluster GKE:

Crea il cluster:
```
gcloud container clusters create asm-ready \
  --cluster-version latest \
  --machine-type=n1-standard-4 \
  --num-nodes 4
```
Il comando gcloud crea un cluster nel progetto e nella zona Google Cloud che hai impostato in precedenza. Per eseguire Anthos Service Mesh, consigliamo almeno 4 nodi e il tipo di macchina n1-standard-4.

Il completamento del comando per creare il cluster richiede alcuni minuti. Quando il cluster è pronto, il comando genera un messaggio simile al seguente:
```
NAME        LOCATION       MASTER_VERSION  MASTER_IP      MACHINE_TYPE   NODE_VERSION   NUM_NODES  STATUS
asm-ready  us-central1-b  1.13.5-gke.10   203.0.113.1    n1-standard-2  1.13.5-gke.10  4          RUNNING
```
Fornisci le credenziali allo strumento a riga di comando di kubectl in modo da poterlo utilizzare per gestire il cluster:
```
gcloud container clusters get-credentials asm-ready
```

Ora puoi utilizzare kubectl per comunicare con Kubernetes. Ad esempio, puoi eseguire il seguente comando per ottenere lo stato dei nodi:

kubectl get nodes

Il comando risponde con un elenco di nodi, simile al seguente:

NAME                                       STATUS   ROLES    AGE    VERSION
gke-asm-ready-default-pool-dbeb23dc-1vg0   Ready    <none>   99s    v1.13.6-gke.13
gke-asm-ready-default-pool-dbeb23dc-36z5   Ready    <none>   100s   v1.13.6-gke.13
gke-asm-ready-default-pool-dbeb23dc-fj7s   Ready    <none>   99s    v1.13.6-gke.13
gke-asm-ready-default-pool-dbeb23dc-wbjw   Ready    <none>   99s    v1.13.6-gke.13

Comprendere i concetti chiave di Kubernetes

Il seguente diagramma illustra l'applicazione in esecuzione su GKE:

applicazione containerizzata

Prima di eseguire il deployment dei container in GKE, potresti aver bisogno di rivedere alcuni concetti chiave di Kubernetes. Alla fine di questo tutorial sono presenti dei link per saperne di più su ciascun concetto.

Nodi e cluster: in GKE, un nodo è una VM. Su altre piattaforme Kubernetes, un nodo può essere una macchina fisica o virtuale. Un cluster è un insieme di nodi che possono essere trattati insieme come una singola macchina, sulla quale viene eseguito il deployment di un'applicazione containerizzata.
Pod: in Kubernetes i container vengono eseguiti all'interno di un pod. Un pod è l'unità atomica di Kubernetes. Un pod include uno o più container. Puoi eseguire il deployment dei container server e loadgen ciascuno nel proprio pod. Quando un pod esegue più container (ad esempio un server applicazioni e un server proxy), i container vengono gestiti come una singola entità e condividono le risorse del pod.
Deployment: un deployment è un oggetto Kubernetes che rappresenta un insieme di pod identici. Un deployment esegue più repliche dei pod distribuiti tra i nodi di un cluster. Un oggetto Deployment sostituisce automaticamente tutti i pod che non funzionano o non rispondono.
Servizio Kubernetes: l'esecuzione del codice dell'applicazione in GKE cambia il networking tra loadgen e server. Quando eseguivi i servizi in una VM Cloud Shell o sul tuo computer, potevi inviare richieste a server utilizzando l'indirizzo localhost:8080. Dopo il deployment su GKE, i pod vengono pianificati per l'esecuzione sui nodi disponibili. Per impostazione predefinita, non puoi controllare su quale nodo è in esecuzione il pod, perciò i pod non hanno indirizzi IP stabili.

Per ottenere un indirizzo IP per server, devi definire un'astrazione di networking sopra i pod chiamata servizio Kubernetes. Un servizio Kubernetes fornisce un endpoint di networking stabile per un insieme di pod. Esistono diversi tipi di servizi. server utilizza un LoadBalancer, che espone un indirizzo IP esterno in modo che tu possa raggiungere server dall'esterno del cluster.

Kubernetes dispone inoltre di un sistema DNS integrato che assegna nomi DNS (ad esempio, helloserver.default.cluster.local) ai servizi. In questo modo, i pod all'interno del cluster possono raggiungere altri pod nel cluster con un indirizzo stabile. Non puoi utilizzare questo nome DNS al di fuori del cluster, ad esempio da Cloud Shell o dal tuo computer.

Manifest di Kubernetes

Quando eseguivi l'applicazione dal codice sorgente, utilizzavi un comando imperativo: python3 server.py

Imperativo significa verbo: "fai questo".

Al contrario, Kubernetes opera secondo un modello dichiarativo. Ciò significa che, anziché dire a Kubernetes esattamente cosa fare, fornisci a Kubernetes lo stato desiderato. Ad esempio, Kubernetes avvia e termina i pod a seconda delle esigenze, in modo che lo stato effettivo del sistema corrisponda a quello desiderato.

Puoi specificare lo stato desiderato in un insieme di manifest o file YAML. Un file YAML contiene le specifiche per uno o più oggetti Kubernetes.

L'esempio contiene un file YAML per server e loadgen. Ogni file YAML specifica lo stato desiderato per il servizio e l'oggetto Deployment Kubernetes.

Scalabilità automatica

apiVersion: apps/v1
kind: Deployment
metadata:
  name: helloserver
spec:
  replicas: 1
  selector:
    matchLabels:
      app: helloserver
  template:
    metadata:
      labels:
        app: helloserver
    spec:
      containers:
      - image: gcr.io/google-samples/istio/helloserver:v0.0.1
        imagePullPolicy: Always
        name: main
      restartPolicy: Always
      terminationGracePeriodSeconds: 5

kind indica il tipo di oggetto.
metadata.name specifica il nome del deployment.
Il primo campo spec contiene una descrizione dello stato desiderato.
spec.replicas specifica il numero di pod desiderati.
La sezione spec.template definisce un modello di pod. Nella specifica per i pod è incluso il campo image, che è il nome dell'immagine di cui eseguire il pull da Container Registry.

Il Servizio è definito come segue:

apiVersion: v1
kind: Service
metadata:
  name: hellosvc
spec:
  ports:
  - name: http
    port: 80
    targetPort: 8080
  selector:
    app: helloserver
  type: LoadBalancer

LoadBalancer: i client inviano richieste all'indirizzo IP di un bilanciatore del carico di rete, che ha un indirizzo IP stabile ed è raggiungibile all'esterno del cluster.
targetPort: ricorda che il comando EXPOSE 8080 in Dockerfile in realtà non espone nessuna porta. Esponi la porta 8080 in modo da poter raggiungere il container server all'esterno del cluster. In questo caso, hellosvc.default.cluster.local:80 (shortname: hellosvc) viene mappato alla helloserver porta dell'IP del pod 8080.
port: questo è il numero di porta utilizzato da altri servizi del cluster per inviare le richieste.

Generatore di carico

L'oggetto Deployment in loadgen.yaml è simile a server.yaml. Una nota differenza è che l'oggetto Deployment contiene una sezione denominata env. Questa sezione definisce le variabili di ambiente richieste da loadgen, che hai impostato in precedenza quando eseguivi l'applicazione dall'origine.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: loadgenerator
spec:
  replicas: 1
  selector:
    matchLabels:
      app: loadgenerator
  template:
    metadata:
      labels:
        app: loadgenerator
    spec:
      containers:
      - env:
        - name: SERVER_ADDR
          value: http://hellosvc:80/
        - name: REQUESTS_PER_SECOND
          value: '10'
        image: gcr.io/google-samples/istio/loadgen:v0.0.1
        imagePullPolicy: Always
        name: main
        resources:
          limits:
            cpu: 500m
            memory: 512Mi
          requests:
            cpu: 300m
            memory: 256Mi
      restartPolicy: Always
      terminationGracePeriodSeconds: 5

Poiché loadgen non accetta richieste in entrata, il campo type è impostato su ClusterIP. Questo tipo fornisce un indirizzo IP stabile che può essere utilizzato dai servizi nel cluster, ma l'indirizzo IP non è esposto ai client esterni.

apiVersion: v1
kind: Service
metadata:
  name: loadgensvc
spec:
  ports:
  - name: http
    port: 80
    targetPort: 8080
  selector:
    app: loadgenerator
  type: ClusterIP

Deployment dei container in GKE

Passa alla directory in cui si trova l'esempio server:

cd YOUR_WORKING_DIRECTORY/istio-samples/sample-apps/helloserver/server/

Apri server.yaml in un editor di testo.
Sostituisci il nome nel campo image con il nome della tua immagine Docker.
```
image: gcr.io/PROJECT_ID/asm-ready/helloserver:v0.0.1
```
Sostituisci PROJECT_ID con l'ID progetto Google Cloud.
Salva e chiudi server.yaml.
Esegui il deployment del file YAML su Kubernetes:
```
kubectl apply -f server.yaml
```
Se l'operazione riesce, il comando risponde con quanto segue:
```
deployment.apps/helloserver created
service/hellosvc created
```
Passa alla directory in cui si trova loadgen.
```
cd ../loadgen
```
Apri loadgen.yaml in un editor di testo.
Sostituisci il nome nel campo image con il nome della tua immagine Docker.
```
image: gcr.io/PROJECT_ID/asm-ready/loadgen:v0.0.1
```
Sostituisci PROJECT_ID con l'ID progetto Google Cloud.
Salva e chiudi loadgen.yaml, quindi chiudi l'editor di testo.
Esegui il deployment del file YAML su Kubernetes:
```
kubectl apply -f loadgen.yaml
```
Se l'operazione riesce, il comando risponde con quanto segue:
```
deployment.apps/loadgenerator created
service/loadgensvc created
```

Controlla lo stato dei pod:

kubectl get pods

Il comando risponde con uno stato simile al seguente:

NAME                             READY   STATUS    RESTARTS   AGE
helloserver-69b9576d96-mwtcj     1/1     Running   0          58s
loadgenerator-774dbc46fb-gpbrz   1/1     Running   0          57s

Recupera i log dell'applicazione dal pod loadgen. Sostituisci POD_ID con l'identificatore dell'output precedente.
```
kubectl logs loadgenerator-POD_ID
```

Recupera gli indirizzi IP esterni di hellosvc:

kubectl get service

La risposta del comando è simile alla seguente:

NAME         TYPE           CLUSTER-IP     EXTERNAL-IP     PORT(S)        AGE
hellosvc     LoadBalancer   10.81.15.158   192.0.2.1       80:31127/TCP   33m
kubernetes   ClusterIP      10.81.0.1      <none>          443/TCP        93m
loadgensvc   ClusterIP      10.81.15.155   <none>          80/TCP         4m52s

Invia una richiesta a hellosvc. Sostituisci EXTERNAL_IP con l'indirizzo IP esterno del tuo hellosvc.
```
curl http://EXTERNAL_IP
```

Pronto per Anthos Service Mesh

A questo punto hai eseguito il deployment dell'applicazione in GKE. L'loadgen può utilizzare il DNS di Kubernetes (hellosvc:80) per inviare richieste a server e puoi inviare richieste al server con un indirizzo IP esterno. Sebbene Kubernetes ti offra molte funzionalità, mancano alcune informazioni sui servizi:

Come interagiscono i servizi? Qual è la relazione tra i servizi? Come scorre il traffico tra i servizi? Sai che loadgen invia richieste a server, ma immagina di non conoscere l'applicazione. Non puoi rispondere a queste domande consultando l'elenco dei pod in esecuzione su GKE.
Metriche: quanto tempo impiega server per rispondere alle richieste in arrivo? Quante richieste al secondo (RPS) sono in entrata verso server? Ci sono risposte di errore?
Informazioni di sicurezza: il traffico tra loadgen e server è semplice HTTP o mTLS?

Anthos Service Mesh può fornire risposte a queste domande. Anthos Service Mesh è una versione gestita da Google Cloud del progetto open source Istio. Anthos Service Mesh funziona posizionando un proxy sidecar Envoy in ogni pod. Il proxy Envoy intercetta tutto il traffico in entrata e in uscita verso i container delle applicazioni. Ciò significa che server e loadgen ricevono ciascuno un proxy sidecar Envoy e tutto il traffico da loadgen a server è mediato dai proxy Envoy. Le connessioni tra questi proxy Envoy formano il mesh di servizi. Questa architettura mesh di servizi fornisce un livello di controllo su Kubernetes.

mesh di servizi

Poiché i proxy Envoy vengono eseguiti nei propri container, puoi installare Anthos Service Mesh su un cluster GKE senza modifiche sostanziali al codice dell'applicazione. Tuttavia, esistono alcuni modi chiave in cui hai preparato l'applicazione per essere instrumentata con Anthos Service Mesh:

Servizi per tutti i container: entrambi i deployment server e loadgen hanno un servizio Kubernetes collegato. Anche loadgen, che non riceve richieste in entrata, ha un servizio.
Le porte nei servizi devono essere denominate: sebbene GKE ti consenta di definire porte di servizio senza nome, Anthos Service Mesh richiede che tu fornisca un nome per una porta che corrisponda al protocollo della porta. Nel file YAML, la porta per server è denominata http perché server utilizza il protocollo di comunicazione HTTP. Se service utilizzava gRPC, dovrai chiamare la porta grpc.
I deployment sono etichettati: questo consente di utilizzare le funzionalità di gestione del traffico di Anthos Service Mesh, come la suddivisione del traffico tra le versioni dello stesso servizio.

Installazione di Anthos Service Mesh

Visita le guide all'installazione di Anthos Service Mesh e segui le istruzioni per installare Anthos Service Mesh sul tuo cluster.

Esegui la pulizia

Per evitare che al tuo Account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Per eseguire la pulizia, elimina il cluster GKE. L'eliminazione del cluster elimina tutte le risorse che lo costituiscono, come istanze di calcolo, dischi e risorse di rete.

gcloud container clusters delete asm-ready

Passaggi successivi

Scopri di più sulle tecnologie utilizzate in questo tutorial:
Scopri di più sugli strumenti:
Scopri di più sui concetti di Kubernetes:
- Cluster
- Nodi
- Pod
- Servizi
- Deployment