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. Procedendo in questa serie di tutorial, imparerai a configurare monitoraggio e avvisi, scalare 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. Simulare un errore

Panoramica e obiettivi

Cymbal Bank utilizza Python e Java per eseguire i vari servizi e include un backend PostgreSQL. Non hai bisogno di esperienza con questi linguaggi o queste piattaforme di database per completare la serie di tutorial, poiché Cymbal Bank è solo un'applicazione di esempio per mostrare in che modo 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 seguenti attività:

  • Creare un cluster GKE che utilizza Autopilot.

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

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

Costi

Se abiliti GKE Enterprise ed esegui il deployment dell'applicazione di esempio Cymbal Bank per questa serie di tutorial, ti verranno addebitati costi per cluster GKE Enterprise su Google Cloud, come indicato nella nostra pagina Prezzi, finché non disabiliti GKE Enterprise o non elimini il progetto.

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

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, utilizzerai sempre più funzionalità aggiuntive disponibili solo tramite il livello Enterprise.

In questo primo tutorial della serie, completa tutti i seguenti passaggi di configurazione descritti in "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 l'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 che mostra un prompt della riga di comando. L'inizializzazione della sessione potrebbe richiedere alcuni secondi.

Shell locale

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

Configura il progetto

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

Potrebbe essere necessario che un amministratore di Google Cloud della tua organizzazione 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 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 GKE Enterprise

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

  3. Se soddisfi i requisiti di idoneità, puoi selezionare l'opzione per iniziare 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 hai creato tu il progetto), 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 questa serie di tutorial. Anche in questo caso, potrebbe essere necessario un amministratore di Google Cloud della tua organizzazione affinché conceda i ruoli richiesti.

Nei seguenti comandi, 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 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

Una volta completati tutti i passaggi preliminari delle sezioni precedenti, 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 utilizzare per eseguire il deployment di applicazioni containerizzate e gestirle. Un ambiente GKE è costituito da nodi, che sono macchine virtuali (VM) Compute Engine raggruppati per formare un cluster.

I cluster GKE possono anche essere raggruppati in parchi risorse: 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 unione e affidabilità che i parchi risorse assumono.

  • Crea un cluster GKE che utilizzerai nei 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 che hai 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 cluster in modalità Autopilot e alcuni intervalli di indirizzi IP predefiniti quando crei i cluster. Un deployment in produzione delle tue applicazioni richiede una pianificazione più attenta degli indirizzi IP. In modalità Autopilot, Google gestisce la configurazione del tuo cluster, inclusi 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 contenitori. Puoi eseguire il deployment di insiemi di container come pod nei nodi.

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

Quando utilizzi Cymbal Bank in questa serie di tutorial, viene eseguito il deployment dei seguenti servizi nel cluster GKE:

Servizio Lingua Descrizione
frontend Python Espone un server HTTP per pubblicare il sito web. Contiene la pagina di accesso, la pagina di registrazione e la home page.
ledger-writer Java Accetta e convalida le transazioni in entrata prima di scriverle nel libro mastro.
balance-reader Java Fornisce una cache leggibile efficiente dei saldi degli utenti, come letto da ledger-db.
transaction-history Java Fornisce una cache leggibile efficiente delle transazioni passate, in base alla lettura da ledger-db.
ledger-db PostgreSQL Dati contabili di tutte le transazioni. Opzione per precompilare le transazioni con 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 dei moduli "Invia pagamento" e "Deposito".
accounts-db PostgreSQL Database per gli account utente e i dati associati. Opzione per precompilare con utenti dimostrativi.
loadgenerator Python / Locusta Invia continuamente al frontend richieste che imitano gli utenti. Crea periodicamente nuovi account e simula le transazioni tra di essi.

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

  1. Cymbal Bank utilizza JWT (JSON Web Tokens) 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 esegue l'accesso e gli altri servizi utilizzano la chiave pubblica corrispondente per convalidare l'utente.

    Crea un JWT RS256 con 4.096 bit di potenza:

    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 doverli codificare nell'applicazione.

    Crea un secret Kubernetes dal file della chiave creato nel passaggio precedente per Cymbal Bank da utilizzare 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 distribuisce 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 quando i manifest vengono applicati al tuo cluster sui limiti di 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 il numero minimo e massimo di richieste di risorse 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 la corretta esecuzione 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 pari a 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 computing o la configurazione hardware selezionata (ad esempio le GPU). Se le tue richieste sono inferiori al minimo, Autopilot modifica automaticamente la configurazione dei carichi di lavoro per portare le richieste all'interno dell'intervallo consentito. Questi messaggi indicano che i limiti appropriati vengono assegnati automaticamente.

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

    kubectl get pods

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

    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 perché tutti i pod si trovino nello stato Running. È normale che alcuni pod riportino uno stato READY pari a 0/1 finché Cymbal Bank non sarà pronta per gestire correttamente il traffico.

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

    Recupera l'indirizzo IP esterno per frontend Ingress:

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

  6. In una finestra del browser web, apri l'indirizzo IP visualizzato 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 delle transazioni e dei saldi di esempio. Non ci sono azioni specifiche da intraprendere, se non per verificare che Cymbal Bank funzioni correttamente. Potrebbero essere necessari un paio di minuti prima che tutti i servizi comunicano correttamente e ti permettano di accedere.

Esplora il deployment

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

Come annunciato durante la 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. Quando hai creato 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

Nella pagina Panoramica vengono mostrate le seguenti informazioni:

  • Quanti cluster ci sono nel tuo parco risorse e se sono integri.
  • L'utilizzo delle risorse del tuo parco risorse, compreso l'utilizzo di CPU, memoria e disco, aggregato per parco risorse e per 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 Config Sync. Nei tutorial futuri di questa serie aggiungerai Policy Controller e Config Sync al tuo cluster.

La pagina Cluster GKE mostra tutti i cluster nel tuo progetto. Il parco risorse dei cluster registrati in un parco risorse è elencato nella colonna Gruppo.

Nelle sezioni seguenti, approfondirai 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 tuo cluster. Nel prossimo tutorial di questa serie, configurerai Google Cloud Managed Service per Prometheus per un monitoraggio e un'osservabilità più granulari.

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

  2. Esamina alcuni dei grafici delle metriche per verificare la presenza di elementi come 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 oppure 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 voci di log poiché Cymbal Bank viene distribuita per la prima volta quando alcuni servizi non sono ancora in grado di comunicare.

  4. Seleziona la scheda Errori relativi all'app. Durante l'esecuzione dei carichi di lavoro, puoi visualizzare gli avvisi e gli eventi raccolti nella console Google Cloud. Questo approccio può aiutare il debug dei problemi senza doverti connettere individualmente al cluster, ai nodi o ai pod.

    Di nuovo, è normale che gli eventi vengano registrati come deployment di Cymbal Bank quando alcuni servizi non sono ancora in grado di comunicare.

Carichi di lavoro

La pagina GKE della console Google Cloud contiene 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 Service e Ingress del progetto. Un servizio espone un insieme di pod come servizio di rete con un endpoint, mentre un elemento 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 nome in entrata di frontend. Un Ingress gestisce il traffico in entrata per l'applicazione. Puoi visualizzare 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. Man mano che progredisci nella serie di tutorial, acquisisci nuove competenze e utilizzi ulteriori prodotti e servizi Google Cloud.

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.

  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.