GSP021

Panoramica

Kubernetes è un progetto open source (disponibile su kubernetes.io) eseguibile su numerosi ambienti, dai laptop ai cluster multinodo ad alta disponibilità, dai cloud pubblici ai deployment on-premise, dalle macchine virtuali alle soluzioni bare metal.

Per questo lab, l'uso di un ambiente gestito come Kubernetes Engine ti permette di concentrarti sulla tua esperienza con Kubernetes anziché sulla configurazione dell'infrastruttura sottostante. Kubernetes Engine è un ambiente gestito per il deployment delle applicazioni containerizzate. Offre le più recenti innovazioni disponibili sul mercato apportando significativi vantaggi in termini di produttività degli sviluppatori, efficienza delle risorse, automazione delle operazioni e flessibilità dell'open source per accelerare il time to market.

Nota: App è ospitata su GitHub e fornisce un'applicazione a 12 fattori di esempio. Nel corso di questo lab lavorerai con le immagini Docker seguenti:

kelseyhightower/monolith - Il monolite include i servizi auth e hello.

kelseyhightower/auth - Microservizio Auth. Genera token JWT per gli utenti autenticati.

kelseyhightower/hello - Microservizio Hello. Dà il benvenuto agli utenti autenticati.

nginx - Frontend ai servizi auth e hello.

Obiettivi

In questo lab imparerai a:

• Eseguire il provisioning di un cluster Kubernetes completo mediante Kubernetes Engine.
• Eseguire il deployment e gestire i container Docker mediante kubectl.
• Suddividere un'applicazione in microservizi mediante deployment e Service di Kubernetes.

Configurazione e requisiti

Prima di fare clic sul pulsante Avvia lab

Leggi le seguenti istruzioni. I lab sono a tempo e non possono essere messi in pausa. Il timer si avvia quando fai clic su Avvia lab e ti mostra per quanto tempo avrai a disposizione le risorse Google Cloud.

Con questo lab pratico avrai la possibilità di completare le attività in prima persona, in un ambiente cloud reale e non di simulazione o demo. Riceverai delle nuove credenziali temporanee che potrai utilizzare per accedere a Google Cloud per la durata del lab.

Per completare il lab, avrai bisogno di:

• Accesso a un browser internet standard (Chrome è il browser consigliato).

Nota: utilizza una finestra del browser in incognito o privata per eseguire questo lab. Ciò evita eventuali conflitti tra il tuo account personale e l'account Studente, che potrebbero causare addebiti aggiuntivi sul tuo account personale.

• È ora di completare il lab: ricorda che, una volta iniziato, non puoi metterlo in pausa.

Nota: se hai già un account o un progetto Google Cloud personale, non utilizzarlo per questo lab per evitare addebiti aggiuntivi al tuo account.

Come avviare il lab e accedere alla console Google Cloud

1. Fai clic sul pulsante Avvia lab. Se devi effettuare il pagamento per il lab, si apre una finestra popup per permetterti di selezionare il metodo di pagamento. A sinistra, trovi il riquadro Dettagli lab con le seguenti informazioni:

   • Pulsante Apri console Google
   • Tempo rimanente
   • Credenziali temporanee da utilizzare per il lab
   • Altre informazioni per seguire questo lab, se necessario

2. Fai clic su Apri console Google. Il lab avvia le risorse e apre un'altra scheda con la pagina di accesso.

   Suggerimento: disponi le schede in finestre separate posizionate fianco a fianco.

   Note: se visualizzi la finestra di dialogo Scegli un account, fai clic su Utilizza un altro account.

3. Se necessario, copia il Nome utente dal riquadro Dettagli lab e incollalo nella finestra di dialogo di accesso. Fai clic su Avanti.

4. Copia la Password dal riquadro Dettagli lab e incollala nella finestra di dialogo di benvenuto. Fai clic su Avanti.

   Importante: devi utilizzare le credenziali presenti nel riquadro di sinistra. Non utilizzare le tue credenziali Google Cloud Skills Boost. Nota: utilizzare il tuo account Google Cloud per questo lab potrebbe comportare addebiti aggiuntivi.

5. Fai clic nelle pagine successive:

   • Accetta i termini e le condizioni.
   • Non inserire opzioni di recupero o l'autenticazione a due fattori, perché si tratta di un account temporaneo.
   • Non registrarti per le prove gratuite.

Dopo qualche istante, la console Google Cloud si apre in questa scheda.

Nota: puoi visualizzare il menu con un elenco di prodotti e servizi Google Cloud facendo clic sul menu di navigazione in alto a sinistra.

Attiva Cloud Shell

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. Cloud Shell fornisce l'accesso da riga di comando alle risorse Google Cloud.

1. Fai clic su Attiva Cloud Shell nella parte superiore della console Google Cloud.

Quando la connessione è attiva, l'autenticazione è già avvenuta e il progetto è impostato sul tuo PROJECT_ID. L'output contiene una riga che dichiara il PROJECT_ID per questa sessione:

Your Cloud Platform project in this session is set to YOUR_PROJECT_ID

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

2. (Facoltativo) Puoi visualizzare il nome dell'account attivo con questo comando:

gcloud auth list

3. Fai clic su Autorizza.

4. L'output dovrebbe avere ora il seguente aspetto:

Output:

ACTIVE: * ACCOUNT: student-01-xxxxxxxxxxxx@qwiklabs.net To set the active account, run: $ gcloud config set account `ACCOUNT`

5. (Facoltativo) Puoi elencare l'ID progetto con questo comando:

gcloud config list project

Output:

[core] project = <project_ID>

Output di esempio:

[core] project = qwiklabs-gcp-44776a13dea667a6 Nota: per la documentazione completa di gcloud, in Google Cloud, fai riferimento alla Panoramica dell'interfaccia a riga di comando gcloud.

Google Kubernetes Engine

1. Nell'ambiente Cloud Shell, digita il comando seguente per impostare la zona:

gcloud config set compute/zone {{{project_0.default_zone|Zone}}}

2. Avvia un cluster da usare in questo lab:

gcloud container clusters create io Al momento della creazione, viene eseguita automaticamente l'autenticazione al tuo cluster. Se per qualsiasi motivo perdi la connessione al tuo Cloud Shell, esegui il comando gcloud container clusters get-credentials io per ripetere l'autenticazione. Nota: la creazione di un cluster richiede del tempo, perché Kubernetes Engine esegue il provisioning di alcune macchine virtuali con cui potrai sperimentare.

Attività 1: recupera il codice campione

1. Copia il codice sorgente dalla riga di comando di Cloud Shell:

gsutil cp -r gs://spls/gsp021/* .

2. Passa alla directory richiesta per questo lab:

cd orchestrate-with-kubernetes/kubernetes

3. Elenca i file per vedere con quali elementi stai lavorando:

ls

L'esempio ha il layout seguente:

deployments/ /* Deployment manifests */ ... nginx/ /* nginx config files */ ... pods/ /* Pod manifests */ ... services/ /* Services manifests */ ... tls/ /* TLS certificates */ ... cleanup.sh /* Cleanup script */

Ora che hai il codice, è il momento di provare Kubernetes!

Attività 2: demo rapida di Kubernetes

Il modo più semplice per iniziare a utilizzare Kubernetes è l'uso del comando kubectl create.

1. Utilizzalo per avviare un'unica istanza del container nginx:

kubectl create deployment nginx --image=nginx:1.10.0

Kubernetes ha creato un deployment. Scoprirai maggiori informazioni sui deployment in seguito, per ora ti basterà sapere che i deployment mantengono i pod in esecuzione anche in caso di arresto dei nodi su cui vengono eseguiti.

In Kubernetes, tutti i container vengono eseguiti in pod.

2. Usa il comando kubectl get pods per vedere il container nginx in esecuzione:

kubectl get pods

3. Quando lo stato del container nginx è In esecuzione, puoi esporlo all'esterno di Kubernetes mediante il comando kubectl expose:

kubectl expose deployment nginx --port 80 --type LoadBalancer

Riassumiamo quanto fatto finora. Dietro le quinte, Kubernetes ha creato un bilanciatore del carico esterno a cui è associato un indirizzo IP pubblico. Qualsiasi client che contatta questo indirizzo IP pubblico viene instradato ai pod da cui dipende il servizio. In questo caso, si tratta del pod nginx.

4. Elenca i nostri servizi usando il comando kubectl get services:

kubectl get services Nota: potrebbero volerci alcuni secondi prima che il campo ExternalIP venga completato per il tuo servizio. Questo è normale: esegui nuovamente il comando kubectl get services a intervalli regolari di alcuni secondi fino a quando il campo non viene completato.

5. Aggiungi l'IP esterno a questo comando per contattare il container Nginx da remoto:

curl http://<External IP>:80

Ecco fatto! Kubernetes supporta un flusso di lavoro facile e pronto per l'uso con i comandi kubectl run ed expose.

Verifica l'attività completata

Fai clic su Controlla i miei progressi qui sotto per verificare lo stato di avanzamento del lab. Se hai creato correttamente un cluster Kubernetes ed esegui il deployment di un container Nginx, visualizzerai un punteggio di valutazione.

Crea un cluster Kubernetes e avvia il container Nginx

Dopo questa rapida panoramica di Kubernetes, è il momento di concentrarsi su ognuno dei componenti e delle astrazioni.

Attività 3: i pod

Il pod è l'elemento fondamentale di Kubernetes.

I pod rappresentano e contengono una raccolta di uno o più container. In generale, se hai più container con una forte dipendenza l'uno dall'altro, li pacchettizzerai in un unico pod.

In questo esempio vediamo un pod che contiene i container monolite e nginx.

I pod, inoltre, sono dotati di volumi. I volumi sono dischi dati la cui durata corrisponde alla durata del pod e che possono essere utilizzati dai container all'interno del pod. I pod forniscono uno spazio dei nomi condiviso per i contenuti, di conseguenza i due container nel nostro pod di esempio comunicano tra loro e condividono anche i volumi collegati.

I pod condividono inoltre uno spazio dei nomi di rete. Di conseguenza, ogni pod ha un indirizzo IP.

Passiamo ora a uno sguardo più approfondito sui pod.

Attività 4: crea i pod

Puoi creare i pod utilizzando file di configurazione pod. Dedica un momento a esplorare il file di configurazione del pod monolite.

1. Vai alla directory:

cd ~/orchestrate-with-kubernetes/kubernetes

2. Esegui questo comando:

cat pods/monolith.yaml

L'output mostra il file di configurazione aperto:

apiVersion: v1 kind: Pod metadata: name: monolith labels: app: monolith spec: containers: - name: monolith image: kelseyhightower/monolith:1.0.0 args: - "-http=0.0.0.0:80" - "-health=0.0.0.0:81" - "-secret=secret" ports: - name: http containerPort: 80 - name: health containerPort: 81 resources: limits: cpu: 0.2 memory: "10Mi"

Ci sono alcuni elementi da notare. Puoi vedere che:

• Il tuo pod è composto da un container (monolite).
• Passi alcuni argomenti al nostro container quando si avvia.
• Apri la porta 80 al traffico http.

3. Crea il pod monolite utilizzando kubectl:

kubectl create -f pods/monolith.yaml

4. Esamina i tuoi pod. Usa il comando kubectl get pods per elencare tutti i pod in esecuzione nello spazio dei nomi predefinito:

kubectl get pods Nota: la preparazione all'esecuzione del pod monolite potrebbe richiedere alcuni secondi. Prima dell'esecuzione, è richiesto il pull dell'immagine del container monolite da Docker Hub.

5. Quando il pod è in esecuzione, usa il comando kubectl describe per ricevere maggiori informazioni sul pod monolite:

kubectl describe pods monolith

Vedrai molte informazioni sul pod monolite, tra cui l'indirizzo IP del pod e il log eventi. Queste informazioni saranno utili durante la risoluzione dei problemi.

Kubernetes facilita la creazione dei pod descrivendoli in file di configurazione e con informazioni facili da visualizzare durante l'esecuzione. A questo punto, puoi creare tutti i pod richiesti dal tuo deployment.

Attività 5: interagisci con i pod

Per impostazione predefinita, ai pod viene allocato un indirizzo IP privato, non raggiungibile dall'esterno del cluster. Usa il comando kubectl port-forward per mappare una porta locale su una porta all'interno del pod monolite.

Nota: da questo momento in poi, il lab richiede di lavorare in più schede di Cloud Shell per configurare la comunicazione tra i pod. La necessità di eseguire i comandi in una seconda o terza shell dei comandi sarà indicata nelle relative istruzioni.

1. Apri un secondo terminale Cloud Shell. Ora hai due terminali; su uno eseguirai il comando kubectl port-forward sull'altro i comandi curl.

2. Nel secondo terminale, esegui questo comando per configurare il port forwarding:

kubectl port-forward monolith 10080:80

3. Ora nel primo terminale inizia a comunicare con il tuo pod utilizzando curl:

curl http://127.0.0.1:10080

Ottimo! Il tuo container ti ha risposto con un amichevole "hello".

4. Ora usa il comando curl per vedere cosa succede quando contatti un endpoint sicuro:

curl http://127.0.0.1:10080/secure

Oh oh.

5. Prova ad accedere per ricevere un token di autenticazione dal monolite:

curl -u user http://127.0.0.1:10080/login

6. Al prompt di accesso, usa la segretissima password password per accedere.

L'accesso ha provocato l'emissione di un token JWT.

7. Poiché Cloud Shell non gestisce bene la copia di stringhe lunghe, crea una variabile di ambiente per il token.

TOKEN=$(curl http://127.0.0.1:10080/login -u user|jq -r '.token')

8. Alla richiesta della password dell'host, inserisci di nuovo la segretissima password password.

9. Usa questo comando per copiare, quindi usa il token per contattare l'endpoint sicuro con curl:

curl -H "Authorization: Bearer $TOKEN" http://127.0.0.1:10080/secure

A questo punto, dovresti ottenere una risposta dalla nostra applicazione, che ci fa sapere che ora tutto va di nuovo per il verso giusto.

10. Usa il comando kubectl logs per visualizzare i log del pod monolith.

kubectl logs monolith

11. Apri un terzo terminale e usa il flag -f per ottenere un flusso dei log in tempo reale:

kubectl logs -f monolith

12. Ora se usi curl nel primo terminale per interagire con il monolite, vedrai che i log vengono aggiornati (nel terzo terminale):

curl http://127.0.0.1:10080

13. Usa il comando kubectl exec per eseguire una shell interattiva all'interno del pod monolite. Questo può essere utile per risolvere i problemi dall'interno di un container:

kubectl exec monolith --stdin --tty -c monolith -- /bin/sh

14. Ad esempio, una volta che hai una shell nel container monolite, puoi testare la connettività esterna con il comando ping:

ping -c 3 google.com

15. Assicurati di uscire quando hai finito di lavorare con questa shell interattiva.

exit

Come puoi vedere, l'interazione con i pod si riassume nel comando kubectl. Se devi contattare un container da remoto o aprire una shell di accesso, Kubernetes ti offre tutto ciò di cui hai bisogno per iniziare.

Attività 6: i servizi

I pod non sono pensati per essere permanenti. Possono essere arrestati o avviati per vari motivi, tra cui il mancato superamento di controlli di attività o idoneità, e questo crea un problema:

Cosa succede se vuoi comunicare con un insieme di pod? Quando vengono riavviati, potrebbero avere un indirizzo IP diverso.

È qui che entrano in gioco i servizi. I servizi offrono endpoint stabili per i pod.

Per determinare su quali pod operano, i servizi si basano su etichette. Se i pod hanno le etichette corrette, vengono rilevati ed esposti automaticamente dai nostri servizi.

Il livello di accesso fornito da un servizio a un insieme di pod dipende dal tipo di servizio. Attualmente, sono disponibili tre tipi:

• ClusterIP (interno): il tipo predefinito, significa che questo servizio è visibile solo all'interno del cluster.
• NodePort: fornisce a ogni nodo nel cluster un IP accessibile dall'esterno.
• LoadBalancer: aggiunge un bilanciatore del carico dal cloud provider che inoltra il traffico dal servizio ai nodi al suo interno.

Ora imparerai come:

• Creare un servizio
• Utilizzare i selettori di etichette per esporre all'esterno un insieme limitato di pod

Attività 7: crea un servizio

Prima di poter creare i servizi, crea un pod sicuro in grado di gestire il traffico https.

1. Se hai cambiato directory, accertati di tornare in ~/orchestrate-with-kubernetes/kubernetes:

cd ~/orchestrate-with-kubernetes/kubernetes

2. Esplora il file di configurazione del servizio monolite:

cat pods/secure-monolith.yaml

3. Crea i pod secure-monolith e i dati delle relative configurazioni:

kubectl create secret generic tls-certs --from-file tls/ kubectl create configmap nginx-proxy-conf --from-file nginx/proxy.conf kubectl create -f pods/secure-monolith.yaml

Ora che hai un pod sicuro, è il momento di esporre il pod secure-monolith all'esterno. Per farlo, crea un servizio Kubernetes.

4. Esplora il file di configurazione del servizio monolite:

cat services/monolith.yaml

(Output):

kind: Service apiVersion: v1 metadata: name: "monolith" spec: selector: app: "monolith" secure: "enabled" ports: - protocol: "TCP" port: 443 targetPort: 443 nodePort: 31000 type: NodePort Considerazioni da tenere presenti:

* È presente un selettore, utilizzato per trovare ed esporre automaticamente tutti i pod con le etichette "app: monolith" e "secure: enabled".

* Ora devi esporre qui la porta del nodo, perché è così che inoltrerai il traffico esterno dalla porta 31000 a nginx (sulla porta 443).

5. Usa il comando kubectl create per creare il servizio monolite dal file di configurazione del servizio monolite:

kubectl create -f services/monolith.yaml

(Output):

service/monolith created

Verifica l'attività completata

Fai clic su Controlla i miei progressi qui sotto per verificare lo stato di avanzamento del lab. Se hai creato correttamente i pod e il servizio monolite, visualizzerai un punteggio di valutazione.

Crea i pod e il servizio monolite

Per esporre il servizio stai utilizzando una porta. Di conseguenza, sono possibili conflitti di porta se un'altra app tenta l'associazione alla porta 31000 su uno dei tuoi server.

Normalmente, l'assegnazione delle porte viene gestita da Kubernetes. In questo lab sei tu a scegliere una porta perché questo facilita la successiva configurazione dei controlli di integrità.

6. Usa il comando gcloud compute firewall-rules per consentire il traffico al servizio monolite sulla porta del nodo esposta:

gcloud compute firewall-rules create allow-monolith-nodeport \ --allow=tcp:31000

Verifica l'attività completata

Fai clic su Controlla i miei progressi qui sotto per verificare lo stato di avanzamento del lab. Se hai creato correttamente una regola firewall per autorizzare il traffico TCP sulla porta 31000, visualizzerai un punteggio di valutazione.

Autorizza il traffico al servizio monolite sulla porta del nodo esposta

Ora che hai configurato tutto, dovresti poter contattare il servizio secure-monolith dall'esterno del cluster senza utilizzare il port forwarding.

1. Per prima cosa, ricevi un indirizzo IP esterno per uno dei nodi.

gcloud compute instances list

2. Ora prova a contattare il servizio secure-monolith utilizzando curl:

curl -k https://<EXTERNAL_IP>:31000

Oh oh. Ha raggiunto il timeout. Che sta succedendo?

Nota: è il momento per un rapido controllo delle conoscenze.

Usa i comandi seguenti per rispondere alle domande:

kubectl get services monolith

kubectl describe services monolith

Domande:

Perché non sei in grado di ricevere una risposta dal servizio monolite?

Quanti endpoint ha il servizio monolite?

Quali etichette deve avere un pod per essere selezionato dal servizio monolite?

Suggerimento: il problema ha a che fare con le etichette. Lo correggerai nella sezione successiva.

Attività 8: aggiungi etichette ai pod

Attualmente il servizio monolite non ha endpoint. Un modo per risolvere un problema di questo genere è utilizzare il comando kubectl get pods con una query sulle etichette.

1. Puoi osservare diversi pod in esecuzione con l'etichetta monolite.

kubectl get pods -l "app=monolith"

2. Cosa viene restituito per "app=monolith" e "secure=enabled"?

kubectl get pods -l "app=monolith,secure=enabled"

Nota che questa query sulle etichette non restituisce alcun risultato. Sembra che tu debba aggiungere l'etichetta "secure=enabled".

3. Usa il comando kubectl label per aggiungere l'etichetta secure=enabled mancante al pod secure-monolith. Dopodiché, potrai controllare e verificare che le etichette sono state aggiornate.

kubectl label pods secure-monolith 'secure=enabled' kubectl get pods secure-monolith --show-labels

4. Ora che i pod hanno le etichette corrette, visualizza l'elenco di endpoint sul servizio monolite:

kubectl describe services monolith | grep Endpoints

Ce n'è uno!

5. Provalo contattando di nuovo uno dei nostri nodi.

gcloud compute instances list curl -k https://<EXTERNAL_IP>:31000

Evviva! Houston, abbiamo un contatto.

Verifica l'attività completata

Fai clic su Controlla i miei progressi qui sotto per verificare lo stato di avanzamento del lab. Se hai aggiunto correttamente le etichette ai pod monolite, visualizzerai un punteggio di valutazione.

Aggiungi etichette ai pod

Attività 9: esegui il deployment delle applicazioni con Kubernetes

L'obiettivo di questo lab è prepararti alla scalabilità e alla gestione dei container in produzione. È qui che entrano in gioco i deployment. I deployment sono un metodo dichiarativo per assicurare che il numero di pod in esecuzione corrisponda al numero di pod desiderato, specificato dall'utente.

Il principale vantaggio dei deployment è l'astrazione dei dettagli di basso livello nella gestione dei pod. Dietro le quinte, i deployment usano set di replica per gestire l'avvio e l'arresto dei pod. Se è necessario aggiornare o scalare i pod, è il deployment a occuparsene. Il deployment gestisce inoltre il riavvio dei pod che si arrestano per qualsiasi motivo.

Guarda un esempio rapido:

I pod sono collegati alla durata del nodo su cui vengono creati. Nell'esempio precedente, Node3 si è arrestato (e di conseguenza anche un pod). Anziché creare manualmente un nuovo pod e trovare un nodo in cui ospitarlo, il deployment ha creato un nuovo pod e lo ha avviato su Node2.

Non male!

È il momento di combinare tutto ciò che hai appreso su pod e servizi per suddividere l'applicazione monolitica in servizi più piccoli utilizzando i deployment.

Attività 10: crea i deployment

Suddividerai l'app monolitica in tre parti separate:

• auth - Genera token JWT per gli utenti autenticati.
• hello - Dà il benvenuto agli utenti autenticati.
• frontend - Indirizza il traffico ai servizi auth e hello.

Ora è tutto pronto per la creazione dei deployment, uno per ciascun servizio. Successivamente, definirai i servizi interni per i deployment auth e hello e il servizio esterno per il deployment del frontend. Al termine sarai in grado di interagire con i microservizi proprio come con il monolite, con la differenza che ora è possibile scalare ed eseguire il deployment di ogni porzione in modo indipendente.

1. Per iniziare, esamina il file di configurazione del deployment auth.

cat deployments/auth.yaml

(Output)

apiVersion: apps/v1 kind: Deployment metadata: name: auth spec: selector: matchlabels: app: auth replicas: 1 template: metadata: labels: app: auth track: stable spec: containers: - name: auth image: "kelseyhightower/auth:2.0.0" ports: - name: http containerPort: 80 - name: health containerPort: 81 ...

Il deployment crea 1 replica: stai utilizzando la versione 2.0.0 del container auth.

Quando esegui il comando kubectl create per creare il deployment auth, viene creato un pod conforme ai dati nel manifest del deployment. Ciò significa che puoi scalare il numero di pod modificando il valore specificato nel campo Repliche.

2. Procedi alla creazione del tuo oggetto deployment:

kubectl create -f deployments/auth.yaml

3. Ora crea un servizio per il deployment auth. Usa il comando kubectl create per creare il servizio auth:

kubectl create -f services/auth.yaml

4. Ora esegui la stessa operazione per creare ed esporre il deployment hello:

kubectl create -f deployments/hello.yaml kubectl create -f services/hello.yaml

5. Eseguila ancora una volta per creare ed esporre il deployment frontend.

kubectl create configmap nginx-frontend-conf --from-file=nginx/frontend.conf kubectl create -f deployments/frontend.yaml kubectl create -f services/frontend.yaml Nota: per creare il frontend serve un ulteriore passaggio, poiché devi archiviare alcuni dati di configurazione con il container.

6. Interagisci con il frontend recuperando il suo IP esterno e condividendolo tramite comando curl:

kubectl get services frontend Nota: la generazione di un indirizzo IP esterno potrebbe richiedere qualche minuto. Esegui di nuovo il comando precedente se lo stato della colonna EXTERNAL-IP è pending. curl -k https://<EXTERNAL-IP>

In questo modo ottieni una risposta da hello.

Verifica l'attività completata

Fai clic su Controlla i miei progressi qui sotto per verificare lo stato di avanzamento del lab. Se hai creato correttamente i deployment Auth, Hello e Frontend, visualizzerai un punteggio di valutazione.

Crea i deployment (Auth, Hello e Frontend)

Complimenti!

Complimenti! Hai sviluppato un'applicazione multiservizio utilizzando Kubernetes. Le competenze che hai acquisito ti permetteranno di eseguire il deployment di applicazioni complesse su Kubernetes sfruttando una raccolta di deployment e servizi.

Prossimi passi/Scopri di più

• Puoi seguire le novità di Kubernetes su X e sul blog della community.
• Ricorda che Kubernetes è un progetto open source (http://kubernetes.io/) ospitato su GitHub. Feedback e contributi sono sempre benvenuti.

Formazione e certificazione Google Cloud

… per utilizzare al meglio le tecnologie Google Cloud. I nostri corsi ti consentono di sviluppare competenze tecniche e best practice per aiutarti a metterti subito al passo e avanzare nel tuo percorso di apprendimento. Offriamo vari livelli di formazione, dal livello base a quello avanzato, con opzioni di corsi on demand, dal vivo e virtuali, in modo da poter scegliere il più adatto in base ai tuoi impegni. Le certificazioni ti permettono di confermare e dimostrare le tue abilità e competenze relative alle tecnologie Google Cloud.

Ultimo aggiornamento del manuale: 26 gennaio 2023

Ultimo test del lab: 26 gennaio 2023

Copyright 2024 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.