Percorso di apprendimento: applicazioni scalabili - Crea un cluster

---

Questo insieme di tutorial è rivolto agli amministratori IT e agli operatori che vogliono eseguire il deployment, eseguire e gestire ambienti applicativi moderni eseguiti sulla versione Google Kubernetes Engine (GKE) Enterprise. Man mano che procedi in questo insieme di tutorial, imparerai a configurare monitoraggio e avvisi, scalare i carichi di lavoro e simulare errori, il tutto utilizzando l'applicazione di microservizi di esempio Cymbal Bank:

1. Crea un cluster ed esegui il deployment di un'applicazione di esempio (questo tutorial)
2. Monitoraggio con Google Cloud Managed Service per Prometheus
3. Scala i carichi di lavoro
4. Simula un errore

Panoramica e obiettivi

Cymbal Bank utilizza Python e Java per eseguire i vari servizi e include un backend PostgreSQL. Non è necessaria esperienza con questi linguaggi o questa piattaforma di database per completare la serie di tutorial, perché Cymbal Bank è solo un'applicazione di esempio per mostrare come GKE Enterprise può supportare le esigenze della tua azienda.

In questo tutorial imparerai a creare un singolo cluster GKE ed eseguire il deployment di un'applicazione di esempio basata su microservizi denominata Cymbal Bank, in un cluster GKE. Imparerai a completare le attività seguenti:

• Creare un cluster GKE che utilizza Autopilot.

• Esegui il deployment di un'applicazione di esempio basata su microservizi denominata Cymbal Bank.

• Utilizzare la console Google Cloud per esplorare le risorse GKE utilizzate dall'applicazione di esempio di Cymbal Bank.

Costi

L'abilitazione di GKE Enterprise e il deployment dell'applicazione di esempio Cymbal Bank per questa serie di tutorial comportano l'addebito di addebiti per cluster per GKE Enterprise su Google Cloud, come indicato nella nostra pagina Prezzi, fino a quando non disattivi GKE Enterprise o elimini il progetto.

Sei inoltre responsabile di altri costi di Google Cloud sostenuti durante l'esecuzione dell'applicazione di esempio Cymbal Bank, ad esempio gli addebiti per le VM e i bilanciatori del carico di Compute Engine.

Prima di iniziare

I primi tutorial di questa serie utilizzano principalmente le funzionalità di base disponibili per tutti gli utenti di GKE, ma man mano che procedi con i tutorial utilizzi altre funzionalità aggiuntive disponibili solo tramite il livello Enterprise.

In questo primo tutorial della serie, completa tutti i passaggi di configurazione della sezione "Inizia" prima di iniziare. Devi completare i seguenti passaggi "Prima di iniziare" una sola volta.

Configura la shell e gli strumenti

In questa serie di tutorial, utilizzerai i seguenti strumenti per eseguire il deployment e gestire il tuo ambiente:

• gcloud CLI: crea e gestisci cluster e parchi risorse GKE, insieme ad altri servizi Google Cloud.
• kubectl: gestisci Kubernetes, il sistema di orchestrazione dei cluster utilizzato da GKE Enterprise.

Per eseguire i comandi in questa pagina, configura Google Cloud CLI e kubectl in uno dei seguenti ambienti di sviluppo:

Cloud Shell

Per utilizzare un terminale online con gcloud CLI e kubectl già configurati, attiva Cloud Shell:

In fondo a questa pagina, viene avviata una sessione di Cloud Shell e viene visualizzato un prompt della riga di comando. L'inizializzazione della sessione può richiedere alcuni secondi.

Shell locale

Per utilizzare un ambiente di sviluppo locale, segui questi passaggi:

• Installa gcloud CLI.
• Inizializza gcloud CLI.

• Installa kubectl gcloud CLI:

  gcloud components install kubectl
  

Configura il progetto

Segui questi passaggi per configurare un progetto Google Cloud, inclusa l'abilitazione dei servizi di fatturazione e GKE. Questo è il progetto in cui abiliterai GKE Enterprise.

Potresti aver bisogno di un amministratore di Google Cloud nella tua organizzazione che ti conceda l'accesso per creare o utilizzare un progetto e abilitare le API.

1. Nella console Google Cloud, vai alla pagina Google Kubernetes Engine:

   Vai alla pagina di Google Kubernetes Engine

2. Crea o seleziona un progetto. Questo è il progetto in cui abiliti GKE Enterprise.

3. Se richiesto, abilita l'API GKE Enterprise.

4. Attendi che l'API e i servizi correlati siano abilitati. Questa operazione può richiedere diversi minuti.

5. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

Dopo aver abilitato GKE, abilita la versione Google Kubernetes Engine (GKE) Enterprise:

1. Nella console Google Cloud, vai alla pagina GKE Enterprise:

   Vai alla pagina di GKE Enterprise

2. Seleziona Scopri di più sulla versione Google Kubernetes Engine (GKE) Enterprise.

3. Se hai l'idoneità, puoi selezionare l'opzione Inizia la prova gratuita di 90 giorni.

4. Seleziona Abilita GKE Enterprise e poi Conferma.

Concedi ruoli IAM

Se sei il proprietario del progetto (ad esempio se lo hai creato personalmente), disponi già di tutte le autorizzazioni necessarie per completare questi tutorial. Se non sei il proprietario, assicurati che il tuo account Google Cloud disponga dei ruoli IAM necessari per il progetto selezionato per questo insieme di tutorial. Anche in questo caso, potresti aver bisogno di un amministratore di Google Cloud nella tua organizzazione che ti aiuti a concedere i ruoli richiesti.

Nei comandi seguenti, sostituisci PROJECT_ID con l'ID generato automaticamente del progetto che hai creato o selezionato nella sezione precedente. L'ID progetto è spesso diverso dal nome del progetto. Ad esempio, il tuo progetto potrebbe essere scalable-apps, ma l'ID progetto potrebbe essere scalable-apps-567123.

Concedi i ruoli al tuo Account Google. Esegui questo comando una volta per ciascuno dei seguenti ruoli IAM: roles/resourcemanager.projectIamAdmin, roles/iam.serviceAccountAdmin, roles/iam.serviceAccountUser, roles/iam.securityAdmin, roles/serviceusage.serviceUsageAdmin, roles/container.admin, roles/logging.logWriter, roles/gkehub.admin, roles/viewer, roles/monitoring.viewer

$ gcloud projects add-iam-policy-binding PROJECT_ID --member="user:EMAIL_ADDRESS" --role=ROLE

• Sostituisci PROJECT_ID con l'ID progetto.
• Sostituisci EMAIL_ADDRESS con il tuo indirizzo email.
• Sostituisci ROLE con ogni singolo ruolo.

clona l'applicazione di esempio

Clona il repository Git che include tutti i manifest di esempio per Cymbal Bank:

  git clone https://github.com/GoogleCloudPlatform/bank-of-anthos
  cd bank-of-anthos/

crea un cluster

Dopo aver completato tutti i passaggi dei prerequisiti nelle sezioni precedenti, ora puoi iniziare a creare un cluster Google Kubernetes Engine ed eseguire il deployment di un'applicazione di esempio.

GKE è un servizio Kubernetes gestito che puoi usare per eseguire il deployment e il funzionamento di applicazioni containerizzate. Un ambiente GKE è costituito da nodi, ovvero macchine virtuali (VM) di Compute Engine, raggruppati per formare un cluster.

I cluster GKE possono anche essere raggruppati in parchi risorse, ovvero gruppi logici di cluster che possono essere gestiti insieme. Molte funzionalità di GKE Enterprise, incluse quelle che utilizzerai più avanti in questa serie di tutorial, si basano sui parchi risorse e sui principi di uguaglianza e affidabilità assunti dai parchi risorse.

• Crea un cluster GKE che utilizzerai negli altri tutorial di questa serie:

  gcloud container clusters create-auto scalable-apps \
    --project=PROJECT_ID \
    --region=REGION \
    --enable-fleet
  

  Sostituisci quanto segue:

  • PROJECT_ID con l'ID generato automaticamente del progetto creato nella sezione precedente. L'ID progetto è spesso diverso dal nome del progetto. Ad esempio, il progetto potrebbe essere scalable-apps, ma l'ID progetto potrebbe essere scalable-apps-567123.
  • REGION con la regione in cui vuoi creare il cluster, ad esempio us-central1.

  Sono necessari alcuni minuti per creare il cluster e verificare che tutto funzioni correttamente.

In questa serie di tutorial, utilizzerai i cluster in modalità Autopilot e alcuni intervalli di indirizzi IP predefiniti durante la creazione dei cluster. Un deployment di produzione delle tue applicazioni richiede una pianificazione più attenta degli indirizzi IP. In modalità Autopilot, Google gestisce la configurazione del tuo cluster, incluse la scalabilità automatica, la sicurezza e altre impostazioni preconfigurate. I cluster in modalità Autopilot sono ottimizzati per eseguire la maggior parte dei carichi di lavoro di produzione e per eseguire il provisioning delle risorse di calcolo in base ai manifest Kubernetes.

Esegui il deployment di Cymbal Bank

Puoi pacchettizzare le app (chiamate anche carichi di lavoro) in container. Esegui il deployment di insiemi di container come pod nei tuoi nodi.

In questa serie di tutorial eseguirai il deployment di un'applicazione di esempio basata su microservizi denominata Cymbal Bank, in uno o più cluster GKE. Cymbal Bank utilizza Python e Java per eseguire i vari servizi e include un backend PostgreSQL. Non è necessaria esperienza con questi linguaggi o questa piattaforma di database per completare la serie di tutorial. Cymbal Bank è solo un'applicazione di esempio per mostrare in che modo la versione Google Kubernetes Engine (GKE) Enterprise può supportare le esigenze della tua azienda.

Quando utilizzi Cymbal Bank nell'ambito di questo insieme di tutorial, nel tuo cluster GKE viene eseguito il deployment dei seguenti servizi:

Servizio	Lingua	Descrizione
frontend	Python	Espone un server HTTP per la pubblicazione del sito web. Contiene una pagina di accesso, una pagina di registrazione e una home page.
ledger-writer	Java	Accetta e convalida le transazioni in arrivo prima di scriverle nel registro.
balance-reader	Java	Fornisce una cache leggibile efficiente dei saldi utente, come letto da ledger-db.
transaction-history	Java	Fornisce una cache leggibile efficiente delle transazioni passate, come lette da ledger-db.
ledger-db	PostgreSQL	Registro di tutte le transazioni. Opzione per precompilare con transazioni per gli utenti dimostrativi.
user-service	Python	Gestisce gli account utente e l'autenticazione. Firma i JWT utilizzati per l'autenticazione da parte di altri servizi.
contacts	Python	Archivia l'elenco di altri account associati a un utente. Utilizzato per il menu a discesa nei moduli "Invia pagamento" e "Deposito".
accounts-db	PostgreSQL	Database per gli account utente e i dati associati. Opzione per precompilare gli utenti della demo.
loadgenerator	Python / Locusta	Invia continuamente al frontend richieste che imitano gli utenti. Crea periodicamente nuovi account e simula le transazioni tra di loro.

Per eseguire il deployment di Cymbal Bank nel tuo cluster GKE, completa questi passaggi:

1. Cymbal Bank utilizza token web JSON (JWT) per gestire l'autenticazione degli utenti. I JWT usano coppie di chiavi asimmetriche per firmare e verificare i token. In Cymbal Bank, userservice crea e firma i token con una chiave privata RSA quando un utente accede, mentre gli altri servizi utilizzano la chiave pubblica corrispondente per convalidare l'utente.

   Crea un JWT RS256 con una forza di 4096 bit:

   openssl genrsa -out jwtRS256.key 4096
   openssl rsa -in jwtRS256.key -outform PEM -pubout -out jwtRS256.key.pub
   

   Se necessario, scarica e installa gli strumenti OpenSSL per la tua piattaforma.

2. Un secret di Kubernetes può archiviare dati sensibili come chiavi o password. I carichi di lavoro in esecuzione nel cluster possono quindi accedere al secret per ottenere i dati sensibili invece di codificarli come hardcoded nell'applicazione.

   Crea un secret Kubernetes dal file della chiave creato nel passaggio precedente da utilizzare per Cymbal Bank con le richieste di autenticazione:

   kubectl create secret generic jwt-key --from-file=./jwtRS256.key --from-file=./jwtRS256.key.pub
   

3. Esegui il deployment di Cymbal Bank nel tuo cluster. Il seguente comando esegue il deployment di tutti i file manifest nella directory kubernetes-manifests. Ogni file manifest esegue il deployment e configura uno dei servizi:

   kubectl apply -f kubernetes-manifests/accounts-db.yaml
   kubectl apply -f kubernetes-manifests/balance-reader.yaml
   kubectl apply -f kubernetes-manifests/config.yaml
   kubectl apply -f kubernetes-manifests/contacts.yaml
   kubectl apply -f extras/postgres-hpa/kubernetes-manifests/frontend.yaml
   kubectl apply -f kubernetes-manifests/ledger-db.yaml
   kubectl apply -f kubernetes-manifests/ledger-writer.yaml
   kubectl apply -f extras/postgres-hpa/loadgenerator.yaml
   kubectl apply -f kubernetes-manifests/transaction-history.yaml
   kubectl apply -f kubernetes-manifests/userservice.yaml
   

   Potresti vedere messaggi nell'output kubectl man mano che i manifest vengono applicati al cluster sui limiti Autopilot. Autopilot utilizza le richieste di risorse specificate nella configurazione dei carichi di lavoro per configurare i nodi che eseguono i carichi di lavoro. Autopilot applica richieste di risorse minime e massime in base alla classe di computing o alla configurazione hardware utilizzata dai carichi di lavoro. Se non specifichi le richieste per alcuni container, Autopilot assegna valori predefiniti per consentire l'esecuzione corretta di questi container.

   Esamina il seguente manifest di esempio per il servizio frontend:

   # Copyright 2024 Google LLC
   #
   # Licensed under the Apache License, Version 2.0 (the "License");
   # you may not use this file except in compliance with the License.
   # You may obtain a copy of the License at
   #
   #     https://www.apache.org/licenses/LICENSE-2.0
   #
   # Unless required by applicable law or agreed to in writing, software
   # distributed under the License is distributed on an "AS IS" BASIS,
   # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   # See the License for the specific language governing permissions and
   # limitations under the License.
   
   apiVersion: v1
   kind: Service
   metadata:
     labels:
       application: bank-of-anthos
       environment: development
       team: frontend
       tier: web
     name: frontend
   spec:
     ports:
       - name: http
         port: 80
         targetPort: 8080
     selector:
       app: frontend
       application: bank-of-anthos
       environment: development
       team: frontend
       tier: web
     type: LoadBalancer
   ---
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     labels:
       application: bank-of-anthos
       environment: development
       team: frontend
       tier: web
     name: frontend
   spec:
     selector:
       matchLabels:
         app: frontend
         application: bank-of-anthos
         environment: development
         team: frontend
         tier: web
     template:
       metadata:
         annotations:
           proxy.istio.io/config: '{ "holdApplicationUntilProxyStarts": true }'
         labels:
           app: frontend
           application: bank-of-anthos
           environment: development
           team: frontend
           tier: web
       spec:
         containers:
           - env:
               - name: VERSION
                 value: v0.6.4
               - name: PORT
                 value: "8080"
               - name: ENABLE_TRACING
                 value: "true"
               - name: SCHEME
                 value: http
               - name: LOG_LEVEL
                 value: info
               - name: DEFAULT_USERNAME
                 valueFrom:
                   configMapKeyRef:
                     key: DEMO_LOGIN_USERNAME
                     name: demo-data-config
               - name: DEFAULT_PASSWORD
                 valueFrom:
                   configMapKeyRef:
                     key: DEMO_LOGIN_PASSWORD
                     name: demo-data-config
               - name: REGISTERED_OAUTH_CLIENT_ID
                 valueFrom:
                   configMapKeyRef:
                     key: DEMO_OAUTH_CLIENT_ID
                     name: oauth-config
                     optional: true
               - name: ALLOWED_OAUTH_REDIRECT_URI
                 valueFrom:
                   configMapKeyRef:
                     key: DEMO_OAUTH_REDIRECT_URI
                     name: oauth-config
                     optional: true
             envFrom:
               - configMapRef:
                   name: environment-config
               - configMapRef:
                   name: service-api-config
             image: us-central1-docker.pkg.dev/bank-of-anthos-ci/bank-of-anthos/frontend:v0.6.4@sha256:f25db63509515fb6caf98c8c76e906f3c2868e345767d12565ab3750e52963f0
             livenessProbe:
               httpGet:
                 path: /ready
                 port: 8080
               initialDelaySeconds: 60
               periodSeconds: 15
               timeoutSeconds: 30
             name: front
             readinessProbe:
               httpGet:
                 path: /ready
                 port: 8080
               initialDelaySeconds: 10
               periodSeconds: 5
               timeoutSeconds: 10
             resources:
               limits:
                 cpu: 250m
                 memory: 128Mi
               requests:
                 cpu: 100m
                 memory: 64Mi
             securityContext:
               allowPrivilegeEscalation: false
               capabilities:
                 drop:
                   - all
               privileged: false
               readOnlyRootFilesystem: true
             volumeMounts:
               - mountPath: /tmp
                 name: tmp
               - mountPath: /tmp/.ssh
                 name: publickey
                 readOnly: true
         securityContext:
           fsGroup: 1000
           runAsGroup: 1000
           runAsNonRoot: true
           runAsUser: 1000
         serviceAccountName: bank-of-anthos
         terminationGracePeriodSeconds: 5
         volumes:
           - emptyDir: {}
             name: tmp
           - name: publickey
             secret:
               items:
                 - key: jwtRS256.key.pub
                   path: publickey
               secretName: jwt-key

   Questo manifest per il servizio frontend richiede 100m di CPU e 64Mi e imposta limiti di 250m di CPU e 128Mi per pod.

   Quando esegui il deployment di un carico di lavoro in un cluster Autopilot, GKE convalida la configurazione del carico di lavoro in base ai valori minimo e massimo consentiti per la classe di calcolo o la configurazione hardware selezionata (come le GPU). Se le tue richieste sono inferiori al minimo, Autopilot modifica automaticamente la configurazione dei carichi di lavoro per riportarle all'interno dell'intervallo consentito. Questi messaggi indicano che vengono assegnati automaticamente i limiti appropriati.

4. Attendi che i pod siano pronti. Utilizza kubectl per controllare lo stato dei pod:

   kubectl get pods
   

   La colonna STATUS cambia da Pending a ContainerCreating. Affinché tutti i pod siano in stato Running, sono necessari alcuni minuti, come mostrato nell'output di esempio che segue:

   NAME                                  READY   STATUS    RESTARTS   AGE
   accounts-db-6f589464bc-6r7b7          1/1     Running   0          99s
   balancereader-797bf6d7c5-8xvp6        1/1     Running   0          99s
   contacts-769c4fb556-25pg2             1/1     Running   0          98s
   frontend-7c96b54f6b-zkdbz             1/1     Running   0          98s
   ledger-db-5b78474d4f-p6xcb            1/1     Running   0          98s
   ledgerwriter-84bf44b95d-65mqf         1/1     Running   0          97s
   loadgenerator-559667b6ff-4zsvb        1/1     Running   0          97s
   transactionhistory-5569754896-z94cn   1/1     Running   0          97s
   userservice-78dc876bff-pdhtl          1/1     Running   0          96s
   

   Quando tutti i pod sono nello stato Running, vai al passaggio successivo. Anche in questo caso, sono necessari alcuni minuti prima che tutti i pod si trovino nello stato Running. È normale che alcuni pod riportino lo stato READY pari a 0/1 finché Cymbal Bank non è pronta a gestire correttamente il traffico.

5. Il servizio frontend espone un server HTTP per la gestione del sito web di Cymbal Bank, tra cui la pagina di accesso, la pagina di registrazione e la home page. Un oggetto Ingress definisce le regole per instradare il traffico HTTP(S) alle applicazioni in esecuzione in un cluster utilizzando un bilanciatore del carico HTTP(S) di Google Cloud.

   Ottieni l'indirizzo IP esterno per la risorsa Ingress frontend:

   kubectl get ingress frontend | awk '{print $4}'
   

6. In una finestra del browser web, apri l'indirizzo IP mostrato nell'output del comando kubectl get ingress per accedere alla tua istanza di Cymbal Bank.

   Le credenziali predefinite vengono compilate automaticamente, quindi puoi accedere all'app ed esplorare alcune transazioni e saldi di esempio. Non devi eseguire alcuna azione specifica se non verificare che Cymbal Bank funzioni correttamente. Potrebbero essere necessari un paio di minuti prima che tutti i servizi comunichino correttamente e ti consentano di accedere.

Obiettivo: congratulazioni. Ora hai un cluster GKE funzionante che utilizza Autopilot e hai eseguito il deployment dell'applicazione di microservizi Cymbal Bank di esempio.

Esplora il tuo deployment

Dopo aver creato un cluster GKE ed eseguito il deployment dei carichi di lavoro, potresti dover modificare le impostazioni o rivedere le prestazioni dell'applicazione. In questa sezione imparerai a utilizzare la console Google Cloud per esaminare le risorse che fanno parte del tuo cluster e l'applicazione di esempio di Cymbal Bank.

Come accennato al momento della creazione del cluster, le funzionalità di GKE Enterprise si basano sull'idea del parco risorse: un raggruppamento logico di cluster Kubernetes che possono essere gestiti insieme. La panoramica di GKE Enterprise nella console Google Cloud offre una visione generale dell'intero parco risorse. Al momento della creazione, il cluster GKE è stato registrato automaticamente nel parco risorse utilizzando il parametro --enable-fleet.

Per visualizzare le informazioni su GKE Enterprise e sul parco risorse, vai alla pagina Panoramica nella console Google Cloud:

Vai alla panoramica di GKE Enterprise

La pagina Panoramica mostra le seguenti informazioni:

• Il numero di cluster presenti nel tuo parco risorse e se sono in stato integro.
• Utilizzo delle risorse del parco risorse, incluso utilizzo di CPU, memoria e disco, aggregato per parco risorse e cluster.
• Eventuali problemi di sicurezza identificati per il parco risorse, la copertura di Policy Controller a livello di parco risorse e lo stato di sincronizzazione dei pacchetti di Config Sync. Aggiungi Policy Controller e Config Sync al tuo cluster nei tutorial futuri di questa serie.

La pagina Cluster di GKE mostra tutti i cluster nel tuo progetto. I cluster registrati in un parco risorse hanno il loro parco risorse elencato nella colonna Fleet.

Nelle sezioni seguenti, esaminerai più da vicino le risorse GKE di Cymbal Bank.

Cluster

In questo tutorial hai creato un cluster GKE e hai eseguito il deployment dei carichi di lavoro di Cymbal Bank.

1. Nella pagina Google Kubernetes Engine della console Google Cloud, vai alla pagina Cluster.

   Vai alla pagina Cluster

2. Fai clic sul cluster scalable-apps di cui è stato eseguito il deployment. Nella pagina dei dettagli del cluster che si apre, puoi visualizzare i dettagli di base del cluster insieme alle configurazioni di networking e sicurezza del cluster. Puoi anche vedere quali funzionalità di GKE sono abilitate in questo cluster nella sezione Funzionalità.

Osservabilità

Puoi visualizzare le metriche di base per l'integrità e le prestazioni del cluster. Nel prossimo tutorial di questa serie, abiliti Google Cloud Managed Service per Prometheus per un monitoraggio e un'osservabilità più granulari.

1. Seleziona il tuo cluster dalla pagina Cluster di Google Kubernetes Engine della console Google Cloud, quindi vai alla scheda Osservabilità.

2. Esamina alcuni elementi grafici delle metriche, ad esempio CPU e Memoria. Questa visualizzazione consente di monitorare le prestazioni delle diverse parti dei carichi di lavoro del cluster senza dover eseguire il deployment di funzionalità di monitoraggio aggiuntive.

3. Per visualizzare i log trasmessi dal cluster, seleziona la scheda Log. Puoi filtrare per Gravità dei log o creare filtri personalizzati per visualizzare spazi dei nomi, servizi o pod specifici. Come per gli avvisi e gli eventi relativi ai pod, questa visualizzazione combinata dei log del cluster può aiutarti a eseguire rapidamente il debug dei problemi utilizzando la console Google Cloud.

   È normale vedere le voci di log quando viene eseguito il deployment di Cymbal Bank per la prima volta quando alcuni servizi non sono ancora in grado di comunicare.

4. Seleziona la scheda Errori dell'app. Durante l'esecuzione dei carichi di lavoro, puoi visualizzare gli avvisi e gli eventi confrontati nella console Google Cloud. Questo approccio può aiutare a eseguire il debug dei problemi senza doversi connettere singolarmente al cluster, ai nodi o ai pod.

   Come già detto, è normale vedere gli eventi registrati come il deployment di Cymbal Bank quando alcuni servizi non sono ancora in grado di comunicare.

Carichi di lavoro

La pagina GKE della console Google Cloud include una sezione Carichi di lavoro che mostra una visualizzazione aggregata dei carichi di lavoro in esecuzione su tutti i tuoi cluster GKE.

1. Nella pagina Google Kubernetes Engine della console Google Cloud, vai alla pagina Carichi di lavoro.

   Vai alla pagina Carichi di lavoro

   La scheda Panoramica mostra un elenco di carichi di lavoro e spazi dei nomi del cluster GKE. Puoi filtrare per spazi dei nomi per vedere quali carichi di lavoro vengono eseguiti in ogni spazio dei nomi.

Servizi e ingress

La vista Servizi e Ingress mostra le risorse Servizio e Ingress del progetto. Un servizio espone un insieme di pod come servizio di rete con un endpoint, mentre un Ingress gestisce l'accesso esterno ai servizi in un cluster.

1. Nella pagina Google Kubernetes Engine della console Google Cloud, vai alla pagina Gateway, servizi e Ingress.

   Vai alla pagina Gateway, servizi e Ingress

2. Per trovare il traffico in entrata di Cymbal Bank, fai clic sulla scheda "Ingress" e individua il traffico in entrata con il nome frontend. Un Ingress gestisce il traffico in entrata per la tua applicazione. Puoi visualizzare le informazioni sul bilanciatore del carico, sulle porte e sugli endpoint esterni.

3. Fai clic sull'indirizzo IP per il traffico in entrata frontend, ad esempio 198.51.100.143:80. Questo indirizzo si apre nell'interfaccia web di Cymbal Bank.

Esegui la pulizia

La serie di tutorial per Cymbal Bank è progettata per essere completata uno dopo l'altro. Proseguendo con la serie di tutorial, acquisisci nuove competenze e utilizzi prodotti e servizi Google Cloud aggiuntivi.

Se vuoi fare una pausa prima di passare al tutorial successivo ed evitare che al tuo account Google Cloud vengano addebitati costi per le risorse utilizzate in questo tutorial, elimina il progetto che hai creato.

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

• L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività in questo documento, quando lo elimini elimini anche qualsiasi altro lavoro svolto nel progetto.
• Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

1. Nella console Google Cloud, vai alla pagina Gestisci risorse.

   Vai a Gestisci risorse

2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Passaggi successivi

Scopri come monitorare i carichi di lavoro in GKE Enterprise utilizzando Google Cloud Managed Service per Prometheus e Cloud Monitoring nel prossimo tutorial.