Panoramica

In questo lab, creerai due deployment di pod e lavorerai con tre diversi tipi di servizi, inclusa la risorsa Ingress. Inoltre, scoprirai come i servizi Kubernetes in GKE vengono associati ai bilanciatori del carico di rete di Google Cloud.

Obiettivi

In questo lab imparerai a:

• Osservare il DNS di Kubernetes in azione.
• Definire i vari tipi di servizi (ClusterIP, NodePort, LoadBalancer) nei manifest insieme ai selettori di etichette per la connessione ai pod e ai deployment con etichette esistenti, eseguirne il deployment in un cluster e testare la connettività.
• Eseguire il deployment di una risorsa Ingress che connette i client a due diversi servizi in base al percorso dell'URL inserito.
• Verificare la creazione del bilanciatore del carico di rete di Google Cloud per i servizi con type=LoadBalancer.

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.

Apri Cloud Shell

Svolgerai la maggior parte del lavoro per il lab in Cloud Shell.

1. Nella barra del titolo della console Google Cloud, fai clic su Attiva Cloud Shell ( ).
2. Fai clic su Continua.

Dopo il provisioning, viene visualizzato il prompt di Cloud Shell.

Attività 1: connettiti al cluster GKE del lab e testa il DNS

In questa attività, ti connetterai al cluster GKE del lab e creerai un manifest di deployment per un set di pod all'interno del cluster che utilizzerai per testare la risoluzione DNS dei nomi di pod e servizi.

Connettiti al cluster GKE del lab

1. In Cloud Shell, digita il comando seguente per creare variabili di ambiente per il nome della zona Google Cloud e del cluster che verranno utilizzati per creare il cluster per questo lab:

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

Attività 2: crea pod e servizi per testare la risoluzione DNS

Creerai un servizio chiamato dns-demo con due pod dell'applicazione di esempio, dns-demo-1 e dns-demo-2.

Clona il repository dei file di origine ed esegui il deployment dei pod dell'applicazione di esempio

Il deployment dei pod che utilizzerai per testare la connettività di rete tramite i servizi Kubernetes viene eseguito utilizzando il file manifest dns-demo.yaml fornito nel repository di codice sorgente. Utilizzerai questi pod in seguito per testare la connettività tramite i vari servizi dai sistemi interni al cluster Kubernetes.

Eseguirai il test della connettività anche da indirizzi esterni utilizzando Cloud Shell. Puoi utilizzare Cloud Shell per questa operazione perché si trova su una rete completamente separata dalle reti del tuo cluster Kubernetes.

apiVersion: v1 kind: Service metadata: name: dns-demo spec: selector: name: dns-demo clusterIP: None ports: - name: dns-demo port: 1234 targetPort: 1234 --- apiVersion: v1 kind: Pod metadata: name: dns-demo-1 labels: name: dns-demo spec: hostname: dns-demo-1 subdomain: dns-demo containers: - name: nginx image: nginx --- apiVersion: v1 kind: Pod metadata: name: dns-demo-2 labels: name: dns-demo spec: hostname: dns-demo-2 subdomain: dns-demo containers: - name: nginx image: nginx

1. In Cloud Shell, inserisci questo comando 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/GKE_Services/

4. Crea il servizio e i pod:

kubectl apply -f dns-demo.yaml

5. Verifica che i pod siano in esecuzione:

kubectl get pods

L'output dovrebbe essere simile all'esempio seguente.

Output:

NAME READY STATUS RESTARTS AGE dns-demo-1 1/1 Running 0 8s dns-demo-2 1/1 Running 0 8s

Fai clic su Controlla i miei progressi per verificare l'obiettivo. Crea pod e servizi per testare la risoluzione DNS

6. Per entrare nel cluster, apri una sessione interattiva nella bash eseguita da dns-demo-1:

kubectl exec -it dns-demo-1 -- /bin/bash

Ora ti trovi in un container del cluster e i comandi successivi verranno eseguiti in quel contesto. Questo ti consentirà di testare la connettività di rete inviando un ping ai vari target individuati nelle attività successive. Tuttavia, non esiste uno strumento per eseguire il ping in questo container, quindi devi prima installare il comando ping.

7. Aggiorna apt-get e installa uno strumento ping:

apt-get update apt-get install -y iputils-ping

8. Ping dns-demo-2:

ping dns-demo-2.dns-demo.default.svc.cluster.local

Questo ping dovrebbe riuscire e segnalare che il target ha l'indirizzo IP trovato in precedenza per il pod dns-demo-2.

9. Premi Ctrl+C per interrompere il comando ping.
10. Invia un ping al nome di dominio completo del servizio dns-demo anziché a un pod specifico all'interno del servizio:

ping dns-demo.default.svc.cluster.local

Anche questo ping dovrebbe riuscire, ma restituirà una risposta dal nome di dominio completo di uno dei due pod demo-dns, ovvero da demo-dns-1 o demo-dns-2.

11. Premi Ctrl+C per interrompere il comando ping.

Quando esegui il deployment delle applicazioni, il codice dell'applicazione viene eseguito all'interno di un container del cluster, quindi il codice può accedere agli altri servizi utilizzando i loro nomi di dominio completi dall'interno del cluster. Questo approccio è più semplice rispetto all'utilizzo di indirizzi IP o anche di nomi di pod, che sono più soggetti a modifiche.

12. Lascia in esecuzione la shell interattiva su dns-demo-1.

Attività 3: esegui il deployment di un carico di lavoro di esempio e di un servizio ClusterIP

In questa attività crei un manifest di deployment per un insieme di pod nel cluster, quindi esponi i pod utilizzando un servizio ClusterIP.

Esegui il deployment di un'applicazione web di esempio nel cluster Kubernetes Engine

In questa attività eseguirai il deployment di un'immagine container dell'applicazione web di esempio che rimane in ascolto su un server HTTP sulla porta 8080 utilizzando il manifest seguente, già creato per te nel file manifest hello-v1.yaml.

apiVersion: apps/v1 kind: Deployment metadata: name: hello-v1 spec: replicas: 3 selector: matchLabels: run: hello-v1 template: metadata: labels: run: hello-v1 name: hello-v1 spec: containers: - image: gcr.io/google-samples/hello-app:1.0 name: hello-v1 ports: - containerPort: 8080 protocol: TCP

1. Nella barra dei menu di Cloud Shell, fai clic sull'icona del segno più () per avviare una nuova sessione di Cloud Shell.

Nella finestra di Cloud Shell viene visualizzata una seconda sessione di Cloud Shell. Puoi passare da una sessione all'altra facendo clic su queste nella barra dei menu.

2. Nella seconda scheda di Cloud Shell, passa alla directory che contiene i file di esempio per questo lab:

cd ~/ak8s/GKE_Services/

3. Per creare un deployment dal file hello-v1.yaml, esegui questo comando:

kubectl create -f hello-v1.yaml

4. Per visualizzare un elenco dei deployment, esegui questo comando:

kubectl get deployments

L'output dovrebbe essere simile all'esempio seguente.

Output:

NAME READY UP-TO-DATE AVAILABLE AGE hello-v1 3/3 3 3 14s

Definisci i tipi di servizio nel manifest

In questa attività eseguirai il deployment di un Service utilizzando un ClusterIP con il manifest di esempio hello-svc.yaml che è già stato creato.

apiVersion: v1 kind: Service metadata: name: hello-svc spec: type: ClusterIP selector: name: hello-v1 ports: - protocol: TCP port: 80 targetPort: 8080

1. Per il deployment del servizio ClusterIP, esegui questo comando:

kubectl apply -f ./hello-svc.yaml

Questo manifest definisce un servizio ClusterIP e lo applica ai pod che corrispondono al selettore. In questo caso, il manifest viene applicato ai pod hello-v1 di cui hai eseguito il deployment. Questo servizio verrà applicato automaticamente a qualsiasi altro deployment con l'etichetta name: hello-v1.

2. Verifica che il servizio sia stato creato e che sia stato allocato un Cluster-IP:

kubectl get service hello-svc

Il tuo indirizzo IP potrebbe essere diverso dall'output di esempio.

Output:

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE hello-svc ClusterIP 10.11.253.203 80/TCP 20s

Nessun IP esterno è allocato per questo servizio. Poiché gli indirizzi IP del cluster Kubernetes non sono accessibili dall'esterno per impostazione predefinita, la creazione di questo servizio non rende l'applicazione accessibile al di fuori del cluster.

Fai clic su Controlla i miei progressi per verificare l'obiettivo. Esegui il deployment di un carico di lavoro di esempio e di un servizio ClusterIP

Testa l'applicazione

1. In Cloud Shell, prova ad aprire una sessione HTTP con il nuovo servizio utilizzando questo comando:

curl hello-svc.default.svc.cluster.local

La connessione non dovrebbe riuscire perché il servizio non è esposto all'esterno del cluster.

Output:

curl: (6) Could not resolve host: hello-svc.default.svc.cluster.local

Ora testerai il servizio dall'interno del cluster utilizzando la shell interattiva che è ancora in esecuzione sul pod dns-demo-1.

2. Torna alla prima finestra di Cloud Shell, che attualmente reindirizza stdin e stdout del pod dns-demo-1.
3. Installa curl per poter effettuare chiamate ai servizi web dalla riga di comando:

apt-get install -y curl

4. Utilizza il comando seguente per testare la connessione HTTP tra i pod:

curl hello-svc.default.svc.cluster.local

Questa connessione dovrebbe riuscire e fornire una risposta simile all'output di seguito. Il nome host potrebbe essere diverso dall'output di esempio.

Output:

root@dns-demo-1:/# curl hello-svc.default.svc.cluster.local Hello, world! Version: 1.0.0 Hostname: hello-v1-85b99869f-mp4vd root@dns-demo-1:/#

Questa connessione funziona perché il clusterIP può essere risolto utilizzando il DNS interno del cluster Kubernetes Engine.

Attività 4: converti il servizio per utilizzare NodePort

In questa attività, convertirai il servizio ClusterIP esistente in un servizio NodePort e proverai nuovamente l'accesso al servizio dall'interno e dall'esterno del cluster.

È già stata creata una versione modificata del file hello-svc.yaml, denominata hello-nodeport-svc.yaml, che modifica il tipo di servizio in NodePort.

apiVersion: v1 kind: Service metadata: name: hello-svc spec: type: NodePort selector: name: hello-v1 ports: - protocol: TCP port: 80 targetPort: 8080 nodePort: 30100

1. Torna alla seconda finestra di Cloud Shell. Questa è la finestra NON connessa a stdin e stdout del pod dns-test.
2. Per il deployment del manifest che modifica il tipo di servizio di hello-svc in NodePort, esegui questo comando:

kubectl apply -f ./hello-nodeport-svc.yaml

Questo manifest ridefinisce hello-svc come servizio NodePort e assegna la porta di servizio 30100 su ciascun nodo del cluster per quel servizio.

3. Inserisci il seguente comando per verificare che il tipo di servizio sia stato cambiato in NodePort:

kubectl get service hello-svc

Il tuo indirizzo IP potrebbe essere diverso dall'output di esempio.

Output:

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE hello-svc NodePort 10.11.253.203 80:30100/TCP 59m Nota: non esiste ancora un IP esterno assegnato per questo servizio.

Fai clic su Controlla i miei progressi per verificare l'obiettivo. Converti il servizio per utilizzare NodePort

Testa l'applicazione

1. In Cloud Shell, prova ad aprire una sessione HTTP con il nuovo servizio utilizzando questo comando:

curl hello-svc.default.svc.cluster.local

La connessione non dovrebbe riuscire perché il servizio non è esposto all'esterno del cluster.

Output:

curl: (6) Could not resolve host: hello-svc.default.svc.cluster.local

Ora testerai il servizio da un altro pod.

2. Torna alla prima finestra di Cloud Shell, che attualmente reindirizza stdin e stdout del pod dns-test.
3. Utilizza il comando seguente per testare la connessione HTTP tra i pod:

curl hello-svc.default.svc.cluster.local

Questa connessione dovrebbe riuscire e fornire una risposta simile all'output di seguito. Il nome host potrebbe essere diverso dall'output di esempio.

Output:

root@dns-demo-1:/# curl hello-svc.default.svc.cluster.local Hello, world! Version: 1.0.0 Hostname: hello-v1-85b99869f-mp4vd root@dns-demo-1:/#

Questa connessione funziona perché il clusterIP può essere risolto utilizzando il DNS interno del cluster GKE.

Attività 5: crea indirizzi IP pubblici statici con Google Cloud Networking

Prenota indirizzi IP statici di Google Cloud Networking

1. Nel menu di navigazione della console Google Cloud, vai a Networking > Rete VPC > Indirizzi IP.

2. Fai clic su Prenota indirizzo IP statico esterno.

3. Inserisci regional-loadbalancer in Nome.

4. Scorri le opzioni, ma lascia invariate le impostazioni predefinite. Tieni presente che il tipo predefinito è Regionale.

Nota: la regione predefinita deve corrispondere a quella in cui hai eseguito il deployment del cluster GKE. In caso contrario, modifica qui la regione in modo che corrisponda a quella utilizzata per creare il cluster. Se hai accettato i valori predefiniti del lab, la regione dovrebbe essere .

5. Fai clic su Prenota.

6. Prendi nota dell'indirizzo IP esterno, chiamato regional-loadbalancer. Lo utilizzerai in un'attività successiva.

7. Fai clic su Prenota indirizzo IP statico esterno.

8. Inserisci global-ingress nel campo Nome.

9. Imposta il tipo su Globale.

10. Non modificare le altre impostazioni predefinite.

11. Fai clic su Prenota.

12. Prendi nota dell'indirizzo IP esterno chiamato global-ingress. Lo utilizzerai in un'attività successiva.

Fai clic su Controlla i miei progressi per verificare l'obiettivo. Crea indirizzi IP pubblici statici con Google Cloud Networking

Attività 6: esegui il deployment di un nuovo insieme di pod e di un servizio LoadBalancer

Ora eseguirai il deployment di un nuovo insieme di pod con una versione diversa dell'applicazione, in modo da poter distinguere facilmente i due servizi. Potrai quindi esporre i nuovi pod come servizio LoadBalancer e accedere al servizio dall'esterno del cluster.

È stato creato per te un secondo manifest di deployment denominato hello-v2.yaml, che crea un nuovo deployment con la versione 2 dell'applicazione di esempio hello sulla porta 8080.

apiVersion: apps/v1 kind: Deployment metadata: name: hello-v2 spec: replicas: 3 selector: matchLabels: run: hello-v2 template: metadata: labels: run: hello-v2 name: hello-v2 spec: containers: - image: gcr.io/google-samples/hello-app:2.0 name: hello-v2 ports: - containerPort: 8080 protocol: TCP

1. Torna alla seconda finestra di Cloud Shell. Questa è la finestra NON connessa a stdin e stdout del pod dns-test.
2. Per il deployment del manifest che crea il deployment hello-v2, esegui questo comando:

kubectl create -f hello-v2.yaml

3. Per visualizzare un elenco dei deployment, esegui questo comando:

kubectl get deployments

L'output dovrebbe essere simile all'esempio seguente.

Output:

NAME READY UP-TO-DATE AVAILABLE AGE hello-v1 3/3 3 3 18m hello-v2 3/3 3 3 7s

Definisci i tipi di servizio nel manifest

In questa attività eseguirai il deployment di un servizio LoadBalancer utilizzando il manifest di esempio hello-lb-svc.yaml già creato.

Utilizzerai il comando sed per sostituire l'indirizzo segnaposto 10.10.10.10 nel file yaml del bilanciatore del carico con l'indirizzo statico prenotato in precedenza.

apiVersion: v1 kind: Service metadata: name: hello-lb-svc spec: type: LoadBalancer loadBalancerIP: 10.10.10.10 selector: name: hello-v2 ports: - protocol: TCP port: 80 targetPort: 8080

1. Verifica di essere ancora nella seconda finestra di Cloud Shell. Questa è la finestra NON connessa a stdin e stdout del pod dns-test.

2. Inserisci il comando seguente in Cloud Shell per salvare l'indirizzo IP statico regionale creato in precedenza in una variabile di ambiente:

   export STATIC_LB=$(gcloud compute addresses describe regional-loadbalancer --region {{{project_0.default_region | REGION}}} --format json | jq -r '.address')

3. Inserisci il seguente comando in Cloud Shell per sostituire l'indirizzo segnaposto con l'indirizzo IP statico regionale:

sed -i "s/10\.10\.10\.10/$STATIC_LB/g" hello-lb-svc.yaml

4. Per verificare che l'indirizzo IP esterno sia stato sostituito correttamente, inserisci il comando seguente in Cloud Shell:

cat hello-lb-svc.yaml

Il valore di loadBalancerIP deve corrispondere all'indirizzo annotato in precedenza per l'indirizzo IP statico prenotato regional-loadbalancer.

5. Per il deployment del manifest del servizio LoadBalancer, esegui questo comando:

kubectl apply -f ./hello-lb-svc.yaml

Questo manifest definisce un servizio LoadBalancer che esegue il deployment di un bilanciatore del carico di rete Google Cloud per fornire un accesso esterno al servizio. Questo servizio si applica solo ai pod con il selettore name: hello-v2.

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

kubectl get services

Il tuo indirizzo IP potrebbe essere diverso dall'output di esempio.

Output:

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE dns-demo ClusterIP None 1234/TCP 1h hello-lb-svc LoadBalancer 10.11.253.48 35.184.45.240 80:30103/TCP 2m hello-svc NodePort 10.11.253.203 80:30100/TCP 1h kubernetes ClusterIP 10.11.240.1 443/TCP 2h

Nota che il nuovo servizio LoadBalancer elenca l'indirizzo prenotato regional-loadbalancer come indirizzo IP esterno. Negli ambienti GKE il bilanciatore del carico esterno per il tipo di servizio LoadBalancer viene implementato utilizzando un bilanciatore del carico Google Cloud e la creazione richiede alcuni minuti. Questo indirizzo IP esterno rende il servizio accessibile dall'esterno del cluster.

Conferma che è stato creato un bilanciatore del carico Google Cloud regionale

1. Nella console Google Cloud, vai a Networking > Servizi di rete > Bilanciamento del carico.

Dovresti visualizzare un bilanciatore del carico TCP con 1 backend del pool di destinazione e 2 istanze.

2. Fai clic sul nome per aprire la pagina dei dettagli.

I dettagli dovrebbero mostrare che si tratta di un bilanciatore del carico TCP a livello di area geografica e che utilizza l'indirizzo IP statico che hai denominato regional-loadbalancer in un passaggio precedente, quando hai eseguito la prenotazione.

Fai clic su Controlla i miei progressi per verificare l'obiettivo. Esegui il deployment di un nuovo insieme di pod e di un servizio LoadBalancer

Testa l'applicazione

1. In Cloud Shell, prova ad aprire una sessione HTTP con il nuovo servizio utilizzando questo comando:

curl hello-lb-svc.default.svc.cluster.local

La connessione non dovrebbe riuscire perché il nome del servizio non è esposto all'esterno del cluster.

Output:

curl: (6) Could not resolve host: hello-lb-svc.default.svc.cluster.local

Questo accade perché l'indirizzo IP esterno non è registrato con questo nome host.

2. Prova nuovamente a stabilire la connessione utilizzando l'indirizzo IP esterno associato al servizio bilanciatore del carico regionale. Digita il comando seguente e sostituisci [external_IP] con l'indirizzo IP esterno del tuo servizio:

curl [external_IP]

Esempio:

curl 35.184.45.240

Questa volta la connessione viene stabilita perché l'indirizzo IP esterno di LoadBalancer può essere raggiunto dall'esterno di Google Cloud.

Nota: potrebbero essere necessari fino a 5 minuti perché la connessione diventi disponibile.

Output:

Hello, world! Version: 2.0.0 Hostname: hello-v2-59c99d8b65-jrx2d

3. Torna alla prima finestra di Cloud Shell, che attualmente reindirizza stdin e stdout del pod dns-demo-1.
4. Utilizza il comando seguente per testare la connessione HTTP tra i pod:

curl hello-lb-svc.default.svc.cluster.local

Questa connessione dovrebbe riuscire e fornire una risposta simile all'output di seguito. Il nome host sarà diverso dall'output di esempio.

Output:

root@dns-demo-1:/# curl hello-lb-svc.default.svc.cluster.local Hello, world! Version: 2.0.0 Hostname: hello-v2-59c99d8b65-78ggz root@dns-demo-1:/#

Il nome DNS interno funziona nel pod e puoi vedere che stai accedendo alla stessa versione v2 dell'applicazione come se fossi all'esterno del cluster e avessi usato l'indirizzo IP esterno.

5. Prova nuovamente a connetterti al pod utilizzando l'indirizzo IP esterno associato al servizio. Digita il comando seguente e sostituisci [external_IP] con l'indirizzo IP esterno del tuo servizio:

curl [external_IP]

Esempio:

curl 35.184.45.240

Output:

root@dns-demo-1:/# curl 35.184.45.240 Hello, world! Version: 2.0.0 Hostname: hello-v2-59c99d8b65-jrx2d root@dns-demo-1:/#

L'IP esterno funziona anche dai pod interni in esecuzione nel cluster e restituisce un risultato dalla stessa versione v2 delle applicazioni.

6. Esci dalla sessione di reindirizzamento della console al pod digitando exit:

exit

Verrà visualizzato il prompt dei comandi di Cloud Shell.

Attività 7: esegui il deployment di una risorsa Ingress

Nel cluster sono presenti due servizi per l'applicazione hello. Uno ospita la versione 1.0 tramite un servizio NodePort, mentre l'altro ospita la versione 2.0 tramite un servizio LoadBalancer. Ora eseguirai il deployment di una risorsa Ingress che indirizzerà il traffico a entrambi i servizi in base all'URL inserito dall'utente.

Crea una risorsa Ingress

Ingress è una risorsa Kubernetes che incapsula una raccolta di regole e configurazione per il routing del traffico HTTP(S) esterno ai servizi interni.

Su GKE, la risorsa Ingress viene implementata utilizzando Cloud Load Balancing. Quando crei una risorsa Ingress nel cluster, GKE crea un bilanciatore del carico HTTP(S) e lo configura per il routing del traffico verso l'applicazione.

È stato creato un manifest di esempio denominato hello-ingress.yaml che configura una risorsa Ingress.

apiVersion: networking.k8s.io/v1 kind: Ingress metadata: name: hello-ingress annotations: nginx.ingress.kubernetes.io/rewrite-target: / kubernetes.io/ingress.global-static-ip-name: "global-ingress" spec: rules: - http: paths: - path: /v1 pathType: ImplementationSpecific backend: service: name: hello-svc port: number: 80 - path: /v2 pathType: ImplementationSpecific backend: service: name: hello-lb-svc port: number: 80

Questo file di configurazione definisce una risorsa Ingress che verrà collegata all'indirizzo IP statico global-ingress che hai creato in un passaggio precedente. La risorsa Ingress creerà un bilanciatore del carico HTTP(S) globale che indirizza il traffico ai tuoi servizi web in base al percorso inserito.

L'annotazione kubernetes.io/ingress.global-static-ip-name consente di specificare un indirizzo IP prenotato con nome, che verrà utilizzato dalla risorsa Ingress durante la creazione del bilanciatore del carico HTTP(S) globale di Google Cloud.

• Per il deployment della risorsa Ingress, esegui questo comando:

kubectl apply -f hello-ingress.yaml

Quando esegui il deployment di questo manifest, Kubernetes crea una risorsa Ingress sul tuo cluster. Il controller Ingress in esecuzione nel cluster è responsabile della creazione di un bilanciatore del carico HTTP(S) per il routing di tutto il traffico HTTP esterno (sulla porta 80) al servizio web NodePort e al servizio LoadBalancer che hai esposto.

Conferma che è stato creato un bilanciatore del carico HTTP(S) globale

1. Nella console Google Cloud, vai a Networking > Servizi di rete > Bilanciamento del carico. A questo punto, dovresti visualizzare anche un bilanciatore del carico HTTP(S).

2. Fai clic sul nome per aprire la pagina dei dettagli. I dettagli dovrebbero mostrare che si tratta di un bilanciatore del carico HTTP(S) globale che utilizza l'indirizzo IP statico che hai denominatoglobal-ingress in un passaggio precedente, quando hai eseguito la prenotazione.

Fai clic su Controlla i miei progressi per verificare l'obiettivo. Esegui il deployment di una risorsa Ingress

Testa l'applicazione

1. Per recuperare l'indirizzo IP esterno del bilanciatore del carico che gestisce l'applicazione, esegui questo comando:

kubectl describe ingress hello-ingress

Output parziale:

Name: hello-ingress Namespace: default Address: 35.244.173.44 Default backend: default-http-backend:80 (10.8.2.5:8080) Rules: Host Path Backends ---- ---- -------- * /v1 hello-svc:80 () /v2 hello-lb-svc:80 () [...] ingress.kubernetes.io/backends:{"k8s-[...]"HEALTHY"[...]} [...] Events: Type Reason Age From Message ---- ------ --- ---- ------- Normal ADD 5m loadbalancer-controller default/hello-ingress Normal CREATE 5m loadbalancer-controller ip: 35.244.173.44 Nota: prima che l'indirizzo esterno venga visualizzato, devi attendere qualche minuto perché il bilanciatore del carico diventi attivo e i controlli di integrità vengano superati.

Ripeti il comando a intervalli di pochi minuti per verificare se l'inizializzazione della risorsa Ingress è stata completata. Quando il bilanciatore del carico HTTP(S) globale di Google Cloud viene creato e inizializzato, il comando segnala l'indirizzo IP esterno che corrisponderà all'indirizzo IP statico globale prenotato in precedenza e chiamato global-ingress.

2. Utilizza l'indirizzo IP esterno associato alla risorsa Ingress e digita il comando seguente, sostituendo [external_IP] con l'indirizzo IP esterno della risorsa Ingress. Assicurati di includere /v1 nel percorso dell'URL:

curl http://[external_IP]/v1

Esempio:

curl http://35.201.92.69/v1

Output:

Hello, world! Version: 1.0.0 Hostname: hello-v1-85b99869f-4rmqw

L'URL v1 è configurato in hello-ingress.yaml per puntare al servizio NodePort hello-svc che dirige il traffico ai pod dell'applicazione v1.

Nota: GKE potrebbe impiegare alcuni minuti per configurare le regole di forwarding finché il bilanciatore del carico globale utilizzato per la risorsa Ingress non sarà pronto per gestire l'applicazione.

Nel frattempo, potresti ricevere errori come HTTP 404 o HTTP 500 finché la configurazione del bilanciatore del carico non viene propagata globalmente.

3. Ora verifica il percorso dell'URL v2 da Cloud Shell. Utilizza l'indirizzo IP esterno associato alla risorsa Ingress e digita il comando seguente, sostituendo [external_IP] con l'indirizzo IP esterno della risorsa Ingress. Assicurati di includere /v2 nel percorso dell'URL:

curl http://[external_IP]/v2

L'URL v2 è configurato in hello-ingress.yaml per puntare al servizio LoadBalancer hello-lb-svc che indirizza il traffico ai pod dell'applicazione v2.

Esempio:

curl http://35.201.92.69/v2

Output:

Hello, world! Version: 2.0.0 Hostname: hello-v2-59c99d8b65-jrx2d

Esamina le modifiche alle risorse di networking nella console Google Cloud

1. Nel menu di navigazione della console Google Cloud, fai clic su Networking > Servizi di rete > Bilanciamento del carico.

Ora sono elencati due bilanciatori del carico:

• È presente il bilanciatore del carico a livello di area geografica iniziale per il servizio hello-lb-svc. Questo bilanciatore del carico ha un nome in stile UID ed è configurato per bilanciare il carico del traffico TCP sulla porta 80 diretto ai nodi del cluster.

• Il secondo è stato creato per l'oggetto Ingress ed è un bilanciatore del carico HTTP(S) completo che include regole dell'host e del percorso corrispondenti alla configurazione della risorsa Ingress. Il nome conterrà hello-ingress.

2. Fai clic sul bilanciatore del carico con hello-ingress nel nome.

Verranno visualizzate le informazioni di riepilogo su protocolli, porte, percorsi e servizi di backend del bilanciatore del carico HTTP(S) globale di Google Cloud creato per la risorsa Ingress.

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.