Questa pagina è stata tradotta dall'API Cloud Translation.

Percorso di apprendimento: applicazioni scalabili - Crea un cluster

Autopilota

Questo insieme di tutorial è rivolto ad amministratori IT e operatori che vogliono eseguire il deployment, eseguire e gestire ambienti di applicazioni moderni che funzionano su Google Kubernetes Engine (GKE). Man mano che procedi in questa serie di tutorial, imparerai a configurare monitoraggio e avvisi, scalare i carichi di lavoro e simulare in errore, il tutto utilizzando l'applicazione di microservizi di esempio di Cymbal Bank:

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

Panoramica e obiettivi

Cymbal Bank utilizza Python e Java per eseguire i vari servizi e include una PostgreSQL. Non è necessaria esperienza con questi linguaggi o questi database piattaforma per completare la serie di tutorial, come Cymbal Bank è solo un esempio. per mostrare in che modo GKE può supportare le esigenze dei tuoi attività.

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 cluster GKE. Imparerai a completare le seguenti attività:

Crea 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 l'applicazione di esempio di Cymbal Bank.

Costi

Se attivi GKE ed esegui il deployment dell'applicazione di esempio Cymbal Bank per questa serie di tutorial, ti verranno addebitati costi per cluster per GKE su Google Cloud come indicato nella nostra pagina dei prezzi finché non disattivi GKE o non 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 Compute Engine e i bilanciatori del carico.

Prima di iniziare

In questo primo tutorial della serie, completa tutti i seguenti passaggi di configurazione "Prima di iniziare" prima di iniziare. Devi solo completare seguendo "Prima di iniziare" passaggi 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 i cluster e i parchi risorse GKE, insieme ad altri servizi Google Cloud.
kubectl: consente di gestire Kubernetes, il sistema di orchestrazione dei cluster utilizzato con GKE.

Per eseguire i comandi in questa pagina, configura l'interfaccia a riga di comando Google Cloud e kubectl in uno dei seguenti ambienti di sviluppo:

Cloud Shell

Per utilizzare un terminale online con l'interfaccia a riga di comando gcloud e kubectl già configurati, attiva Cloud Shell:

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

Shell locale

Per utilizzare un ambiente di sviluppo locale:

Installa gcloud CLI.
Inizializza gcloud CLI.
Installa kubectl l'interfaccia a riga di comando gcloud:
```
gcloud components install kubectl
```

Configura il progetto

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

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

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

Vai alla pagina di Google Kubernetes Engine
Crea o seleziona un progetto. Questo è il progetto in cui attivi GKE.
Se richiesto, abilita l'API GKE.
Attendi che l'API e i relativi servizi siano abilitati. L'operazione può richiedere diversi minuti.
Make sure that billing is enabled for your Google Cloud project.

Concedi ruoli IAM

Se sei il proprietario del progetto (ad esempio se lo hai creato tu), hai già 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 Google Cloud nella tua organizzazione per aiutarti a concedere i ruoli richiesti.

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

Grant roles to your user account. Run the following command once for each of the following IAM roles: 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_IDENTIFIER" --role=ROLE

Replace PROJECT_ID with your project ID.
Replace USER_IDENTIFIER with the identifier for your user account. For example, user:myemail@example.com.
Replace ROLE with each individual role.

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 descritti nelle sezioni precedenti, puoi ora inizia a creare un cluster GKE ed eseguire il deployment di un'applicazione.

GKE è un servizio Kubernetes gestito che puoi utilizzare per eseguire il deployment e gestire applicazioni containerizzate. Un ambiente GKE è costituito da nodes, ovvero macchine virtuali (VM) Compute Engine, raggruppate insieme a formare un cluster.

Crea un cluster GKE che utilizzerai nel resto dei tutorial di questa serie:
```
gcloud container clusters create-auto scalable-apps \
  --project=PROJECT_ID \
  --region=REGION
```
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 tuo progetto potrebbe essere scalable-apps, ma l'ID progetto potrebbe essere scalable-apps-567123.
- REGION con la regione in cui vuoi creare il tuo cluster, ad esempio us-central1.
La creazione del cluster e la verifica del corretto funzionamento richiedono alcuni minuti.

In questa serie di tutorial, utilizzerai i cluster in modalità Autopilot e intervalli di indirizzi IP predefiniti quando crei i cluster. Un deployment di produzione le tue applicazioni richiedono una pianificazione più attenta degli indirizzi IP. Nella Autopilot, Google gestisce la configurazione del cluster, tra cui scalabilità automatica, 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 sui tuoi nodi.

In questa serie di tutorial esegui il deployment di un'applicazione di esempio basata su microservizi chiamata Cymbal Bank in uno o più cluster GKE. Cymbal Bank utilizza Python e Java per eseguire i vari servizi e include un database PostgreSQL di un backend cloud. Per completare la serie di tutorial, non è necessaria esperienza con questi linguaggi o con la piattaforma di database. Cymbal Bank è solo un'applicazione di esempio mostrano in che modo GKE può supportare le esigenze della tua azienda.

Quando utilizzi Cymbal Bank nell'ambito di questo insieme di tutorial, nel tuo cluster GKE vengono eseguiti i deployment dei seguenti servizi:

Servizio	Lingua	Descrizione
`frontend`	Python	Espone un server HTTP per pubblicare il sito web. Contiene una pagina di accesso, una pagina di registrazione e una 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 ed efficiente dei saldi degli utenti, 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 nel menu a discesa in "Invia pagamento" e "Deposito" moduli.
`accounts-db`	PostgreSQL	Database per gli account utente e i dati associati. Opzione per la precompilazione con utenti 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 i seguenti passaggi:

Cymbal Bank utilizza token web JSON (JWT) per gestire l'autenticazione degli utenti. I JWT utilizzano 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 e 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.
Un secret Kubernetes può archiviare dati sensibili come chiavi o password. I carichi di lavoro in esecuzione nel cluster possono quindi accedere al secret per ottenere dati sensibili invece di inserirli tramite hardcoded nell'applicazione.

Crea un secret di Kubernetes dal file della chiave creato nel passaggio precedente per consentire a Cymbal Bank di utilizzarlo con le richieste di autenticazione:
```
kubectl create secret generic jwt-key --from-file=./jwtRS256.key --from-file=./jwtRS256.key.pub
```

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

Quando i manifest vengono applicati al tuo cluster, potresti visualizzare messaggi nell'output kubectl relativi ai limiti di Autopilot. Autopilot utilizza richieste di risorse specificate nella configurazione e configurare i nodi che eseguono i carichi di lavoro. Implementazione forzata di Autopilot richieste di risorse minima e massima in base alla classe di computing o della configurazione hardware utilizzata dai carichi di lavoro. Se non specifichi richieste per alcuni container, Autopilot assegna valori predefiniti per consentire l'esecuzione corretta dei 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.5
            - 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.5@sha256:d72050f70d12383e4434ad04d189b681dc625f696087ddf0b5df641645c9dafa
          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 rispetto ai valori minimo e massimo consentiti per la classe di computing o la configurazione hardware selezionata (ad esempio GPU). Se se le tue richieste sono inferiori al minimo, Autopilot modifica la configurazione del carico di lavoro per portare le richieste all'interno intervallo consentito. Questi messaggi indicano che i limiti appropriati vengono assegnati automaticamente.

Attendi che i pod siano pronti. Usa kubectl per controllare lo stato della Pod:

kubectl get pods

La colonna STATUS cambia da Pending a ContainerCreating. La creazione qualche minuto affinché tutti i pod siano nello stato Running, come mostrato in il seguente output di esempio:

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 siano nello stato Running. È normale che alcuni pod riportino uno stato READY di 0/1 fino a quando Cymbal Bank non sarà pronta a gestire correttamente il traffico.

Il servizio frontend espone un server HTTP per pubblicare il sito web di Cymbal Bank, incluse la pagina di accesso, la pagina di registrazione e la home page. Un oggetto Ingresse 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.

Ottieni l'indirizzo IP esterno per l'Ingress frontend:
```
kubectl get ingress frontend | awk '{print $4}'
```
In una finestra del browser web, apri l'indirizzo IP mostrato nell'output del kubectl get ingress per accedere alla tua istanza di Cymbal Bank.

Le credenziali predefinite vengono compilate automaticamente, quindi puoi accedere a l'app ed esplorare alcune transazioni e saldi di esempio. Esistono non devi fare niente, se non per confermare che Cymbal La banca viene eseguita correttamente. Potrebbero essere necessari uno o due minuti prima che tutti i servizi comunichino correttamente e ti consentano di accedere.

Esplora il tuo deployment

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

Cluster

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

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

Vai alla pagina Cluster
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, nonché le configurazioni di rete e sicurezza del cluster. Puoi anche vedere quali Le funzionalità GKE sono abilitate in questo cluster nella sezione Funzionalità. .

Osservabilità

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

Seleziona il tuo cluster dalla pagina Cluster di Google Kubernetes Engine della console Google Cloud, poi vai alla scheda Osservabilità.
Esamina alcuni dei grafici delle metriche per elementi come CPU e Memoria. Questo consente di monitorare le prestazioni delle diverse parti del cluster senza dover eseguire il deployment di funzionalità di monitoraggio aggiuntive.
Per visualizzare i log trasmessi dal cluster, seleziona la scheda Log. Puoi filtra per gravità dei log o crea filtri personalizzati per visualizzare dati specifici spazi dei nomi, servizi o pod. Come per gli avvisi e gli eventi dei pod, questa visualizzazione raccolta dei log del cluster può aiutarti a risolvere rapidamente i problemi utilizzando la console Google Cloud.

È normale visualizzare voci di log durante il primo dispiegamento di Cymbal Bank quando alcuni servizi non possono ancora comunicare.
Seleziona la scheda Errori dell'app. Durante l'esecuzione dei carichi di lavoro, puoi visualizzare avvisi ed eventi compressi nella console Google Cloud. Questo approccio può aiutare eseguire il debug dei problemi senza doverti connettere al cluster, ai nodi o ai pod singolarmente.

Ancora una volta, è normale vedere gli eventi registrati durante il primo dispiegamento di Cymbal Bank quando alcuni servizi non possono ancora 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 cluster GKE.

Nella pagina Google Kubernetes Engine della console Google Cloud, vai al file 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

I Servizi e La vista Ingress mostra il servizio e l'Ingress del progetto Google Cloud. Un servizio espone un insieme di pod come servizio di rete con un mentre una risorsa Ingress gestisce l'accesso esterno ai servizi in un cluster.

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

Vai alla pagina Gateway, servizi e Ingress
Per trovare il traffico in entrata di Cymbal Bank, fai clic sulla scheda Ingress e trova in entrata con il nome frontend. Un traffico in entrata gestisce il traffico in entrata la tua applicazione. Puoi visualizzare le informazioni su bilanciatore del carico, porte endpoint esterni.
Fai clic sull'indirizzo IP per l'ingresso frontend, ad esempio 198.51.100.143:80. Questo indirizzo apre l'interfaccia web di Cymbal Bank.

Esegui la pulizia

L'insieme di tutorial per Cymbal Bank è pensato per essere completato uno dopo il e l'altro. Man mano che avanzi nell'insieme di tutorial, acquisisci nuove competenze e utilizzi altri prodotti e servizi Google Cloud.

Se vuoi fare una pausa prima di passare al prossimo tutorial ed evitare comportano addebiti sul tuo account Google Cloud per le risorse utilizzate in 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à descritte in questo documento, quando lo elimini elimini anche tutto il 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 appspot.com URL, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, il riuso dei progetti può aiutarti a non superare i limiti di quota.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Passaggi successivi

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