Panoramica

In questo lab configurerai un'applicazione in Google Kubernetes Engine (GKE) e utilizzerai un HorizontalPodAutoscaler per scalare automaticamente l'applicazione web. Potrai quindi lavorare con più pool di nodi di tipi diversi e applicare incompatibilità e tolleranze per controllare la pianificazione dei pod in relazione al pool di nodi sottostante.

Obiettivi

In questo lab imparerai a:

• Configurare scalabilità automatica e HorizontalPodAutoscaler
• Aggiungere un pool di nodi e configurare le incompatibilità sui nodi per l'anti-affinità di un pod
• Configurare un'eccezione per l'incompatibilità dei nodi aggiungendo una tolleranza al file manifest di un pod

Configurazione del lab

Accedi a Qwiklabs

Per ciascun lab, riceverai un nuovo progetto Google Cloud e un insieme di risorse per un periodo di tempo limitato senza alcun costo aggiuntivo.

1. Accedi a Qwiklabs utilizzando una finestra di navigazione in incognito.

2. Tieni presente la durata dell'accesso al lab (ad esempio, 1:15:00) e assicurati di finire entro quell'intervallo di tempo.
   Non è disponibile una funzionalità di pausa. Se necessario, puoi riavviare il lab ma dovrai ricominciare dall'inizio.

3. Quando è tutto pronto, fai clic su Inizia lab.

4. Annota le tue credenziali del lab (Nome utente e Password). Le userai per accedere a Google Cloud Console.

5. Fai clic su Apri console Google.

6. Fai clic su Utilizza un altro account e copia/incolla le credenziali per questo lab nei prompt.
   Se utilizzi altre credenziali, compariranno errori oppure ti verranno addebitati dei costi.

7. Accetta i termini e salta la pagina di ripristino delle risorse.

Una volta completati i passaggi di accesso iniziali, viene visualizzata la dashboard del progetto.

Attiva Google Cloud Shell

Google Cloud Shell è una macchina virtuale in cui sono caricati strumenti per sviluppatori. Offre una home directory permanente da 5 GB e viene eseguita su Google Cloud.

Google Cloud Shell fornisce l'accesso da riga di comando alle risorse Google Cloud.

1. Nella barra degli strumenti in alto a destra della console Cloud, fai clic sul pulsante Apri Cloud Shell.

   

2. Fai clic su Continua.

Bastano pochi istanti per eseguire il provisioning e connettersi all'ambiente. Quando la connessione è attiva, l'autenticazione è già avvenuta e il progetto è impostato sul tuo PROJECT_ID. Ad esempio:

gcloud è lo strumento a riga di comando di Google Cloud. È preinstallato su Cloud Shell e supporta il completamento.

• Puoi visualizzare il nome dell'account attivo con questo comando:

gcloud auth list

Output:

Credentialed accounts: - @.com (active)

Output di esempio:

Credentialed accounts: - google1623327_student@qwiklabs.net

• Puoi elencare l'ID progetto con questo comando:

gcloud config list project

Output:

[core] project =

Output di esempio:

[core] project = qwiklabs-gcp-44776a13dea667a6 Nota: la documentazione completa di gcloud è disponibile nella guida Panoramica dell'interfaccia a riga di comando gcloud .

Attività 1 - Connettersi al cluster GKE del lab ed eseguire il deployment di un carico di lavoro di esempio

In questa attività, ti connetterai al cluster GKE del lab e creerai un file manifest di deployment per un set di pod all'interno del cluster.

Connettiti al cluster GKE del lab

1. In Cloud Shell, digita questo comando per impostare la variabile di ambiente per il nome della zona e del cluster:

export my_zone={{{project_0.default_zone|ZONE}}} export my_cluster=standard-cluster-1

2. Configura il completamento per lo strumento a riga di comando kubectl:

source <(kubectl completion bash)

3. Configura l'accesso al tuo cluster per kubectl:

gcloud container clusters get-credentials $my_cluster --zone $my_zone

Esegui il deployment di un'applicazione web di esempio nel tuo cluster GKE

Eseguirai il deployment di un'applicazione di esempio nel cluster utilizzando il file di deployment web.yaml creato per te:

apiVersion: apps/v1 kind: Deployment metadata: name: web spec: replicas: 1 selector: matchLabels: run: web template: metadata: labels: run: web spec: containers: - image: gcr.io/google-samples/hello-app:1.0 name: web ports: - containerPort: 8080 protocol: TCP resources: # You must specify requests for CPU to autoscale # based on CPU utilization requests: cpu: "250m"

Questo file manifest consente di creare un deployment utilizzando un'immagine container di esempio dell'applicazione web che rimane in ascolto su un server HTTP tramite la porta 8080.

1. In Cloud Shell, inserisci il comando seguente per clonare il repository nella sessione di Cloud Shell del lab:

git clone https://github.com/GoogleCloudPlatform/training-data-analyst

2. Crea un soft link da utilizzare come scorciatoia alla directory di lavoro:

ln -s ~/training-data-analyst/courses/ak8s/v1.1 ~/ak8s

3. Passa alla directory che contiene i file di esempio per questo lab:

cd ~/ak8s/Autoscaling/

4. Per creare un deployment da questo file, esegui questo comando:

kubectl create -f web.yaml --save-config

5. Crea una risorsa di servizio di tipo NodePort sulla porta 8080 per il deployment web:

kubectl expose deployment web --target-port=8080 --type=NodePort

6. Verifica che il servizio sia stato creato e che sia stata allocata una porta del nodo:

kubectl get service web

Il tuo indirizzo IP e il numero di porta potrebbero essere diversi dall'output di esempio.

Output:

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE web NodePort 10.11.246.185 8080:32056/TCP 12s

Fai clic su Controlla i miei progressi per verificare l'obiettivo. Esegui il deployment di un'applicazione web di esempio in un cluster GKE.

Attività 2 - Configurare la scalabilità automatica sul cluster

In questa attività devi configurare il cluster in modo da scalare automaticamente l'applicazione di esempio di cui hai eseguito il deployment in precedenza.

Configura scalabilità automatica

1. Scarica l'elenco dei deployment per determinare se la tua applicazione web di esempio è ancora in esecuzione:

kubectl get deployment

L'output dovrebbe essere simile all'esempio seguente.

Output:

NAME READY UP-TO-DATE AVAILABLE AGE web 1/1 1 1 5m48s

Se il deployment web della tua applicazione non viene visualizzato, torna all'attività 1 e riesegui il deployment nel cluster.

2. Per configurare l'applicazione di esempio per la scalabilità automatica (e impostare il numero massimo di repliche a 4 e il numero minimo a 1, con un target di utilizzo della CPU dell'1%), esegui il comando seguente:

kubectl autoscale deployment web --max 4 --min 1 --cpu-percent 1

Quando utilizzi kubectl autoscale, devi specificare un numero massimo e minimo di repliche per la tua applicazione, oltre a un target di utilizzo della CPU.

3. Scarica l'elenco dei deployment per verificare che sia ancora presente un solo deployment dell'applicazione web:

kubectl get deployment

Output:

NAME READY UP-TO-DATE AVAILABLE AGE web 1/1 1 1 8m21s

Analizza l'oggetto HorizontalPodAutoscaler

Il comando kubectl autoscale che hai usato nell'attività precedente crea un oggetto HorizontalPodAutoscaler destinato a una risorsa specificata, chiamata target di scalabilità, e la scala in base alle esigenze.

Il gestore della scalabilità automatica regola periodicamente il numero di repliche del target di scalabilità in modo che corrisponda all'utilizzo medio della CPU specificato al momento della creazione del gestore della scalabilità automatica.

1. Esegui il comando seguente per ottenere l'elenco delle risorse HorizontalPodAutoscaler:

kubectl get hpa

L'output dovrebbe essere simile all'esempio seguente.

Output:

NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS AGE web Deployment/web 0%/1% 1 4 1 1m

2. Per analizzare la configurazione di HorizontalPodAutoscaler sotto forma di tabella, esegui il comando seguente:

kubectl describe horizontalpodautoscaler web

L'output dovrebbe essere simile all'esempio seguente.

Output:

Name: web Namespace: default Labels: Annotations: CreationTimestamp: Tue, 08 Sep 2020... Reference: Deployment/web Metrics: ( current / target ) resource cpu on pods (as a percentage of request): 0% (0) / 1% Min replicas: 1 Max replicas: 4 Deployment pods: 1 current / 1 desired Conditions: Type Status Reason Message ---- ------ ------ ------- AbleToScale True ScaleDownStabilized recent recommendations [...] ScalingActive True ValidMetricFound the HPA was able to [...] ScalingLimited False DesiredWithinRange the desired count [...] Events:

3. Per visualizzare la configurazione di HorizontalPodAutoscaler in formato YAML, esegui il comando seguente:

kubectl get horizontalpodautoscaler web -o yaml

L'output dovrebbe essere simile all'esempio seguente.

Output:

apiVersion: autoscaling/v1 kind: HorizontalPodAutoscaler metadata: annotations: autoscaling.alpha.kubernetes.io/conditions: [...] autoscaling.alpha.kubernetes.io/current-metrics: [...] creationTimestamp: 2018-11-14T02:59:28Z name: web namespace: default resourceVersion: "14588" selfLink: /apis/autoscaling/v1/namespaces/[...] spec: maxReplicas: 4 minReplicas: 1 scaleTargetRef: apiVersion: apps/v1 kind: Deployment name: web targetCPUUtilizationPercentage: 1 status: currentCPUUtilizationPercentage: 0 currentReplicas: 1 desiredReplicas: 1

Testa la configurazione della scalabilità automatica

Devi creare un carico elevato nell'applicazione web per forzarne lo scale out. Crea un file di configurazione che definisca un deployment di quattro container che eseguono un ciclo infinito di query HTTP sul server web dell'applicazione di esempio.

Puoi creare il carico sulla tua applicazione web eseguendo il deployment dell'applicazione loadgen utilizzando il file loadgen.yaml che ti è stato fornito.

apiVersion: apps/v1 kind: Deployment metadata: name: loadgen spec: replicas: 4 selector: matchLabels: app: loadgen template: metadata: labels: app: loadgen spec: containers: - name: loadgen image: k8s.gcr.io/busybox args: - /bin/sh - -c - while true; do wget -q -O- http://web:8080; done

1. Per eseguire il deployment di questo container, esegui questo comando:

kubectl apply -f loadgen.yaml

Una volta eseguito il deployment del file manifest, il pod web dovrebbe iniziare a scalare.

Fai clic su Controlla i miei progressi per verificare l'obiettivo. Deployment dell'applicazione loadgen

2. Scarica l'elenco dei deployment per verificare che il generatore di carico sia in esecuzione:

kubectl get deployment

L'output dovrebbe essere simile all'esempio seguente.

Output:

NAME READY UP-TO-DATE AVAILABLE AGE loadgen 4/4 4 4 26s web 1/1 1 1 14m

3. Analizza HorizontalPodAutoscaler:

kubectl get hpa

Una volta che il pod loadgen inizia a generare traffico, l'utilizzo della CPU del deployment web inizia ad aumentare. Nell'output di esempio, i target hanno ora un utilizzo della CPU del 35% rispetto alla soglia dell'1% della CPU.

Output:

NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS AGE web Deployment/web 35%/1% 1 4 1 8m

4. Dopo qualche minuto, analizza nuovamente HorizontalPodAutoscaler:

kubectl get hpa

Il gestore della scalabilità automatica ha aumentato la disponibilità del deployment web a quattro repliche.

Output:

NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS AGE web Deployment/web 88%/1% 1 4 4 9m

5. Per arrestare il carico sull'applicazione web, scala il deployment loadgen fino a zero repliche:

kubectl scale deployment loadgen --replicas 0

6. Scarica l'elenco dei deployment per verificare che sia stato fatto lo scale down del loadgen:

kubectl get deployment

Il deployment loadgen non deve avere repliche.

Output:

NAME READY UP-TO-DATE AVAILABLE AGE loadgen 0/0 0 0 3m40s web 2/4 4 2 18m Nota: devi attendere da 2 a 3 minuti prima di poter rielencare i deployment.

7. Scarica l'elenco dei deployment per verificare che l'applicazione web abbia fatto lo scale down al valore minimo di 1 replica configurato al momento dell'esecuzione del deployment del gestore della scalabilità automatica:

kubectl get deployment

A questo punto dovresti avere un deployment dell'applicazione web.

Output:

NAME READY UP-TO-DATE AVAILABLE AGE loadgen 0/0 0 0 12m web 1/1 1 1 14m

Attività 3 - Gestire i pool di nodi

In questa attività devi creare un nuovo pool di nodi utilizzando istanze prerilasciabili, quindi limitare il deployment web ai soli nodi prerilasciabili.

Aggiungi un pool di nodi

1. Per eseguire il deployment di un nuovo pool di nodi con tre istanze VM prerilasciabili, esegui il comando seguente:

gcloud container node-pools create "temp-pool-1" \ --cluster=$my_cluster --zone=$my_zone \ --num-nodes "2" --node-labels=temp=true --preemptible

Se visualizzi un errore che indica che non sono disponibili istanze prerilasciabili, puoi rimuovere l'opzione --preemptible per procedere con il lab.

2. Ottieni l'elenco dei nodi per verificare che i nuovi nodi siano pronti:

kubectl get nodes

Ora dovresti avere 4 nodi.

I tuoi nomi saranno diversi dall'output di esempio.

Output:

NAME STATUS ROLES AGE VERSION gke-standard-cluster-1-default-pool...xc Ready 33m v1.19.10-gke.1600 gke-standard-cluster-1-default-pool...q8 Ready 33m v1.19.10-gke.1600 gke-standard-cluster-1-temp-pool-1-...vj Ready 32s v1.19.10-gke.1600 gke-standard-cluster-1-temp-pool-1-...xj Ready 37s v1.19.10-gke.1600

Tutti i nodi che hai aggiunto hanno l'etichetta temp=true, perché hai impostato questa etichetta al momento della creazione del pool di nodi. Questa etichetta consente di individuare e configurare questi nodi facilmente.

3. Per elencare solo i nodi con l'etichetta temp=true, esegui il comando seguente:

kubectl get nodes -l temp=true

Dovresti visualizzare solo i due nodi che hai aggiunto.

I tuoi nomi saranno diversi dall'output di esempio.

Output:

NAME STATUS ROLES AGE VERSION gke-standard-cluster-1-temp-pool-1-...vj Ready 3m26s v1.19.10-gke.1600 gke-standard-cluster-1-temp-pool-1-...xj Ready 3m31s v1.19.10-gke.1600

Controlla la pianificazione con incompatibilità e tolleranze

Per impedire allo scheduler di eseguire un pod sui nodi temporanei, aggiungi un'incompatibilità a ciascuno dei nodi nel pool temporaneo. Le incompatibilità sono implementate come coppie chiave-valore con un effetto (ad esempio NoExecute) che determina se i pod possono essere eseguiti su un determinato nodo. Solo i nodi configurati per tollerare la coppia chiave-valore dell'incompatibilità sono pianificati per essere eseguiti su questi nodi.

1. Per aggiungere un'incompatibilità a ciascuno dei nodi appena creati, esegui il comando seguente.

Puoi utilizzare l'etichetta temp=true per applicare la modifica a tutti i nuovi nodi contemporaneamente:

kubectl taint node -l temp=true nodetype=preemptible:NoExecute

Per consentire l'esecuzione dei pod dell'applicazione su questi nodi incompatibili, devi aggiungere una chiave di tolleranza alla configurazione del deployment.

2. Per modificare il file web.yaml, esegui questo comando:

nano web.yaml

3. Aggiungi la seguente chiave nella sezione spec del modello:

tolerations: - key: "nodetype" operator: Equal value: "preemptible"

La sezione spec del file dovrebbe essere simile all'esempio seguente:

... spec: tolerations: - key: "nodetype" operator: Equal value: "preemptible" containers: - image: gcr.io/google-samples/hello-app:1.0 name: web ports: - containerPort: 8080 protocol: TCP resources: # You must specify requests for CPU to autoscale # based on CPU utilization requests: cpu: "250m"

4. Per far sì che il deployment web utilizzi il nuovo pool di nodi, aggiungi una chiave nodeSelector nella sezione spec del modello. Questa chiave è parallela alla chiave di tolleranza che hai appena aggiunto:

nodeSelector: temp: "true" Nota: GKE aggiunge un'etichetta personalizzata a ciascun nodo denominata cloud.google.com/gke-nodepool, che contiene il nome del pool di nodi a cui appartiene il nodo. Questa chiave può essere utilizzata anche come parte di un nodeSelector per garantire che il deployment dei pod venga eseguito solo in nodi idonei.

Il deployment web.yaml completo dovrebbe essere simile all'esempio seguente:

apiVersion: apps/v1 kind: Deployment metadata: name: web spec: replicas: 1 selector: matchLabels: run: web template: metadata: labels: run: web spec: tolerations: - key: "nodetype" operator: Equal value: "preemptible" nodeSelector: temp: "true" containers: - image: gcr.io/google-samples/hello-app:1.0 name: web ports: - containerPort: 8080 protocol: TCP resources: # You must specify requests for CPU to autoscale # based on CPU utilization requests: cpu: "250m"

5. Premi CTRL+X, quindi premi Y e Invio per salvare il file e uscire dall'editor nano.

6. Per applicare questa modifica, esegui il comando seguente:

kubectl apply -f web.yaml

In caso di problemi durante la modifica del file, puoi utilizzare invece il file di esempio precedentemente preparato denominato web-tolerations.yaml.

Fai clic su Controlla i miei progressi per verificare l'obiettivo. Gestisci i pool di nodi

7. Recupera l'elenco dei pod:

kubectl get pods

I tuoi nomi potrebbero essere diversi dall'output di esempio.

Output:

NAME READY STATUS RESTARTS AGE web-7cb566bccd-pkfst 1/1 Running 0 1m

6. Per confermare la modifica, esamina i pod web in esecuzione utilizzando il seguente comando:

kubectl describe pods -l run=web

Nella parte inferiore dell'output troncato dovrebbe essere visualizzata una sezione Tolerations con nodetype=preemptible nell'elenco.

Output:

Node-Selectors: temp=true Tolerations: node.kubernetes.io/not-ready:NoExecute op=Exists for 300s node.kubernetes.io/unreachable:NoExecute op=Exists for 300s nodetype=preemptible Events:

L'output conferma che i pod tollerano il valore di incompatibilità sui nuovi nodi prerilasciabili e che quindi è possibile pianificare l'esecuzione su questi nodi.

7. Per forzare nuovamente l'applicazione web a fare lo scale out, scala di nuovo il deployment loadgen a quattro repliche:

kubectl scale deployment loadgen --replicas 4

Puoi scalare direttamente solo l'applicazione web, ma utilizzando l'app loadgen potrai vedere come le diverse impostazioni di incompatibilità, tolleranza e nodeSelector applicabili alle applicazioni web e loadgen influiscono sui nodi su cui sono pianificate.

8. Ottieni l'elenco di pod utilizzando l'ampio formato di output per mostrare i nodi in esecuzione nei pod:

kubectl get pods -o wide

Indica che l'app loadgen è in esecuzione solo sui nodi default-pool, mentre l'app web esegue solo i nodi prerilasciabili in temp-pool-1.

L'impostazione di incompatibilità impedisce l'esecuzione dei pod sui nodi prerilasciabili in modo che l'applicazione loadgen venga eseguita solo sul pool predefinito. L'impostazione di tolleranza consente all'applicazione web di essere eseguita sui nodi prerilasciabili e il nodeSelector forza l'esecuzione dei pod dell'applicazione web su questi nodi.

NAME READY STATUS [...] NODE Loadgen-x0 1/1 Running [...] gke-xx-default-pool-y0 loadgen-x1 1/1 Running [...] gke-xx-default-pool-y2 loadgen-x3 1/1 Running [...] gke-xx-default-pool-y3 loadgen-x4 1/1 Running [...] gke-xx-default-pool-y4 web-x1 1/1 Running [...] gke-xx-temp-pool-1-z1 web-x2 1/1 Running [...] gke-xx-temp-pool-1-z2 web-x3 1/1 Running [...] gke-xx-temp-pool-1-z3 web-x4 1/1 Running [...] gke-xx-temp-pool-1-z4

Termina il lab

Una volta completato il lab, fai clic su Termina lab. Google Cloud Skills Boost rimuove le risorse che hai utilizzato ed esegue la pulizia dell'account.

Avrai la possibilità di inserire una valutazione in merito alla tua esperienza. Seleziona il numero di stelle applicabile, inserisci un commento, quindi fai clic su Invia.

Il numero di stelle corrisponde alle seguenti valutazioni:

• 1 stella = molto insoddisfatto
• 2 stelle = insoddisfatto
• 3 stelle = esperienza neutra
• 4 stelle = soddisfatto
• 5 stelle = molto soddisfatto

Se non vuoi lasciare un feedback, chiudi la finestra di dialogo.

Per feedback, suggerimenti o correzioni, utilizza la scheda Assistenza.

Copyright 2020 Google LLC Tutti i diritti riservati. Google e il logo Google sono marchi di Google LLC. Tutti gli altri nomi di società e prodotti sono marchi delle rispettive società a cui sono associati.