Questo tutorial mostra come eseguire un'applicazione web supportata da un database relazionale a disponibilità elevata su larga fare lo scale in Google Kubernetes Engine (GKE).
L'applicazione di esempio utilizzata in questo tutorial è Bank of Anthos, un'applicazione web basata su HTTP che simula la rete di elaborazione dei pagamenti di una banca. Bank of Anthos utilizza più servizi per funzionare. Questo tutorial si concentra sul frontend del sito web e sui database PostgreSQL relazionali che supportano i servizi di Bank of Anthos. Per saperne di più su Bank of Anthos, inclusi la sua architettura e i servizi che implementa, consulta la pagina Bank of Anthos su GitHub.
Obiettivi
- Crea e configura un cluster GKE.
- Esegui il deployment di un'applicazione web di esempio e di un database PostgreSQL a disponibilità elevata.
- Configura la scalabilità automatica dell'applicazione web e del database.
- Simula i picchi di traffico utilizzando un generatore di carico.
- Osserva come i servizi vengono scalati verso l'alto e verso il basso.
Costi
In questo documento, utilizzi i seguenti componenti fatturabili di Google Cloud:
Per generare una stima dei costi in base all'utilizzo previsto,
utilizza il calcolatore prezzi.
Al termine delle attività descritte in questo documento, puoi evitare l'addebito di ulteriori costi eliminando le risorse che hai creato. Per ulteriori informazioni, vedi Pulizia.
Prima di iniziare
- Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.
-
Install the Google Cloud CLI.
-
If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.
-
To initialize the gcloud CLI, run the following command:
gcloud init
-
Create or select a Google Cloud project.
-
Create a Google Cloud project:
gcloud projects create PROJECT_ID
Replace
PROJECT_ID
with a name for the Google Cloud project you are creating. -
Select the Google Cloud project that you created:
gcloud config set project PROJECT_ID
Replace
PROJECT_ID
with your Google Cloud project name.
-
-
Make sure that billing is enabled for your Google Cloud project.
-
Enable the GKE API:
gcloud services enable container.googleapis.com
-
Install the Google Cloud CLI.
-
If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.
-
To initialize the gcloud CLI, run the following command:
gcloud init
-
Create or select a Google Cloud project.
-
Create a Google Cloud project:
gcloud projects create PROJECT_ID
Replace
PROJECT_ID
with a name for the Google Cloud project you are creating. -
Select the Google Cloud project that you created:
gcloud config set project PROJECT_ID
Replace
PROJECT_ID
with your Google Cloud project name.
-
-
Make sure that billing is enabled for your Google Cloud project.
-
Enable the GKE API:
gcloud services enable container.googleapis.com
- Installa la CLI Helm.
Prepara l'ambiente
Clona il repository di esempio utilizzato in questo tutorial:
git clone https://github.com/GoogleCloudPlatform/bank-of-anthos.git cd bank-of-anthos/
Imposta le variabili di ambiente:
PROJECT_ID=PROJECT_ID GSA_NAME=bank-of-anthos GSA_EMAIL=bank-of-anthos@${PROJECT_ID}.iam.gserviceaccount.com KSA_NAME=default
Sostituisci
PROJECT_ID
con l'ID progetto Google Cloud .
Configura il cluster e i service account
Crea un cluster:
gcloud container clusters create-auto bank-of-anthos --region=us-central1
L'avvio del cluster potrebbe richiedere fino a cinque minuti.
Crea un account di servizio IAM:
gcloud iam service-accounts create bank-of-anthos
Concedi l'accesso al account di servizio IAM:
gcloud projects add-iam-policy-binding PROJECT_ID \ --role roles/cloudtrace.agent \ --member "serviceAccount:bank-of-anthos@PROJECT_ID.iam.gserviceaccount.com" gcloud projects add-iam-policy-binding PROJECT_ID \ --role roles/monitoring.metricWriter \ --member "serviceAccount:bank-of-anthos@PROJECT_ID.iam.gserviceaccount.com" gcloud iam service-accounts add-iam-policy-binding "bank-of-anthos@PROJECT_ID.iam.gserviceaccount.com" \ --role roles/iam.workloadIdentityUser \ --member "serviceAccount:PROJECT_ID.svc.id.goog[default/default]"
Questo passaggio concede il seguente accesso:
roles/cloudtrace.agent
: Scrivi dati di traccia come informazioni sulla latenza in Trace.roles/monitoring.metricWriter
: scrivi le metriche in Cloud Monitoring.roles/iam.workloadIdentityUser
: consente a un account di servizio Kubernetes di utilizzare Workload Identity Federation for GKE per fungere da service account IAM.
Configura il account di servizio Kubernetes
default
nello spazio dei nomidefault
in modo che funga da account di servizio IAM che hai creato:kubectl annotate serviceaccount default \ iam.gke.io/gcp-service-account=bank-of-anthos@PROJECT_ID.iam.gserviceaccount.com
In questo modo, i pod che utilizzano il service account Kubernetes
default
nello spazio dei nomidefault
possono accedere alle stesse risorse Google Cloud dell'account di servizio IAM.
Esegui il deployment di Bank of Anthos e PostgreSQL
In questa sezione, installerai Bank of Anthos e un database PostgreSQL in modalità ad alta disponibilità (HA), che ti consente di scalare automaticamente le repliche del server di database. Se vuoi visualizzare gli script, il grafico Helm e i manifest Kubernetes utilizzati in questa sezione, consulta il repository Bank of Anthos su GitHub.
Esegui il deployment dello schema del database e di uno script DDL (Data Definition Language):
kubectl create configmap initdb \ --from-file=src/accounts/accounts-db/initdb/0-accounts-schema.sql \ --from-file=src/accounts/accounts-db/initdb/1-load-testdata.sql \ --from-file=src/ledger/ledger-db/initdb/0_init_tables.sql \ --from-file=src/ledger/ledger-db/initdb/1_create_transactions.sh
Installa PostgreSQL utilizzando il grafico Helm di esempio:
helm repo add bitnami https://charts.bitnami.com/bitnami helm install accounts-db bitnami/postgresql-ha \ --version 10.0.1 \ --values extras/postgres-hpa/helm-postgres-ha/values.yaml \ --set="postgresql.initdbScriptsCM=initdb" \ --set="postgresql.replicaCount=1" \ --wait
Questo comando crea un cluster PostgreSQL con un conteggio di repliche iniziale pari a 1. Più avanti in questo tutorial, scalerai il cluster in base alle connessioni in entrata. Il completamento di questa operazione potrebbe richiedere 10 minuti o più.
Esegui il deployment di Bank of Anthos:
kubectl apply -f extras/jwt/jwt-secret.yaml kubectl apply -f extras/postgres-hpa/kubernetes-manifests
Il completamento dell'operazione potrebbe richiedere alcuni minuti.
Checkpoint: convalida della configurazione
Verifica che tutti i pod di Bank of Anthos siano in esecuzione:
kubectl get pods
L'output è simile al seguente:
NAME READY STATUS accounts-db-pgpool-57ffc9d685-c7xs8 3/3 Running accounts-db-postgresql-0 1/1 Running balancereader-57b59769f8-xvp5k 1/1 Running contacts-54f59bb669-mgsqc 1/1 Running frontend-6f7fdc5b65-h48rs 1/1 Running ledgerwriter-cd74db4cd-jdqql 1/1 Running pgpool-operator-5f678457cd-cwbhs 1/1 Running transactionhistory-5b9b56b5c6-sz9qz 1/1 Running userservice-f45b46b49-fj7vm 1/1 Running
Verifica di poter accedere al frontend del sito web:
Ottieni l'indirizzo IP esterno del servizio
frontend
:kubectl get ingress frontend
L'output è simile al seguente:
NAME CLASS HOSTS ADDRESS PORTS AGE frontend <none> * 203.0.113.9 80 12m
In un browser, vai all'indirizzo IP esterno. Viene visualizzata la pagina di accesso di Bank of Anthos. Se ti incuriosisce, esplora l'applicazione.
Se ricevi un errore 404, attendi qualche minuto per il provisioning dei microservizi e riprova.
Scalare automaticamente l'app web e il database PostgreSQL
GKE Autopilot esegue la scalabilità automatica delle risorse di calcolo del cluster in base al numero di workload nel cluster. Per scalare automaticamente il numero di pod nel cluster in base alle metriche delle risorse, devi implementare la scalabilità automatica del pod orizzontale di Kubernetes. Puoi utilizzare le metriche integrate di CPU e memoria di Kubernetes oppure metriche personalizzate come le richieste HTTP al secondo o la quantità di istruzioni SELECT, estratte da Cloud Monitoring.
In questa sezione, imparerai a:
- Configura la scalabilità automatica orizzontale dei pod per i microservizi Bank of Anthos utilizzando sia metriche integrate sia metriche personalizzate.
- Simula il carico sull'applicazione Bank of Anthos per attivare gli eventi di scalabilità automatica.
- Osserva come il numero di pod e nodi nel cluster aumenta e diminuisce automaticamente in risposta al carico.
Configurare la raccolta di metriche personalizzate
Per leggere le metriche personalizzate da Monitoring, devi eseguire il deployment dell'adattatore Custom Metrics - Stackdriver Adapter nel tuo cluster.
Esegui il deployment dell'adattatore:
kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter.yaml
Configura l'adattatore in modo che utilizzi la federazione delle identità per i carichi di lavoro per GKE per ottenere le metriche:
Configura il account di servizio IAM:
gcloud projects add-iam-policy-binding PROJECT_ID \ --member "serviceAccount:bank-of-anthos@PROJECT_ID.iam.gserviceaccount.com" \ --role roles/monitoring.viewer gcloud iam service-accounts add-iam-policy-binding bank-of-anthos@PROJECT_ID.iam.gserviceaccount.com \ --role roles/iam.workloadIdentityUser \ --member "serviceAccount:PROJECT_ID.svc.id.goog[custom-metrics/custom-metrics-stackdriver-adapter]"
Aggiungi un'annotazione al account di servizio Kubernetes utilizzato dall'adattatore:
kubectl annotate serviceaccount custom-metrics-stackdriver-adapter \ --namespace=custom-metrics \ iam.gke.io/gcp-service-account=bank-of-anthos@PROJECT_ID.iam.gserviceaccount.com
Riavvia il deployment dell'adattatore per propagare le modifiche:
kubectl rollout restart deployment custom-metrics-stackdriver-adapter \ --namespace=custom-metrics
Configurare la scalabilità automatica per il database
Quando hai deployato Bank of Anthos e PostgreSQL in precedenza in questo tutorial, hai eseguito il deployment del database come StatefulSet con una replica di lettura/scrittura primaria per gestire tutte le istruzioni SQL in entrata. In questa sezione, configuri la scalabilità automatica orizzontale dei pod per aggiungere nuove repliche di standby di sola lettura per gestire le istruzioni SELECT in entrata. Un buon modo per ridurre il carico su ogni replica è distribuire le istruzioni SELECT, che sono operazioni di lettura. Il deployment di
PostgreSQL include uno strumento denominato Pgpool-II
che esegue questo bilanciamento del carico
e migliora la velocità effettiva del sistema.
PostgreSQL esporta la metrica dell'istruzione SELECT come
metrica Prometheus.
Utilizzerai un esportatore di metriche leggero denominato prometheus-to-sd
per inviare queste
metriche a Cloud Monitoring in un formato supportato.
Esamina l'oggetto
HorizontalPodAutoscaler
:Questo manifest fa quanto segue:
- Imposta il numero massimo di repliche durante uno scale up su
5
. - Imposta il numero minimo durante una riduzione delle dimensioni a
1
. - Utilizza una metrica esterna per prendere decisioni di scalabilità. In questo esempio, la metrica è il numero di istruzioni SELECT. Si verifica un evento di scale up se il conteggio delle istruzioni SELECT in entrata supera 15.
- Imposta il numero massimo di repliche durante uno scale up su
Applica il manifest al cluster:
kubectl apply -f extras/postgres-hpa/hpa/postgresql-hpa.yaml
Configurare la scalabilità automatica per l'interfaccia web
In Esegui il deployment di Bank of Anthos e PostgreSQL, hai eseguito il deployment
dell'interfaccia web di Bank of Anthos. Quando il numero di utenti aumenta, il servizio
userservice
consuma più risorse CPU. In questa sezione, configura la scalabilità automatica orizzontale dei pod per il deployment userservice
quando i pod esistenti utilizzano più del 60% della CPU richiesta e per il deployment frontend
quando il numero di richieste HTTP in entrata al bilanciatore del carico è superiore a 5 al secondo.
Configura la scalabilità automatica per il deployment di userservice
Rivedi il manifest
HorizontalPodAutoscaler
per il deploymentuserservice
:Questo manifest fa quanto segue:
- Imposta il numero massimo di repliche durante uno scale up su
50
. - Imposta il numero minimo durante una riduzione delle dimensioni a
5
. - Utilizza una metrica Kubernetes integrata per prendere decisioni di scalabilità. In questo esempio, la metrica è l'utilizzo della CPU e l'utilizzo target è del 60%, il che evita un utilizzo eccessivo e insufficiente.
- Imposta il numero massimo di repliche durante uno scale up su
Applica il manifest al cluster:
kubectl apply -f extras/postgres-hpa/hpa/userservice.yaml
Configurare la scalabilità automatica per il deployment del frontend
Rivedi il manifest
HorizontalPodAutoscaler
per il deploymentuserservice
:Questo manifest utilizza i seguenti campi:
spec.scaleTargetRef
: la risorsa Kubernetes da scalare.spec.minReplicas
: il numero minimo di repliche, che in questo esempio è5
.spec.maxReplicas
: il numero massimo di repliche, che in questo esempio è25
.spec.metrics.*
: la metrica da utilizzare. In questo esempio, si tratta del numero di richieste HTTP al secondo, che è una metrica personalizzata di Cloud Monitoring fornita dall'adattatore che hai implementato.spec.metrics.external.metric.selector.matchLabels
: L'etichetta di risorsa specifica da filtrare durante la scalabilità automatica.
Trova il nome della regola di forwarding dal bilanciatore del carico al deployment
frontend
:export FW_RULE=$(kubectl get ingress frontend -o=jsonpath='{.metadata.annotations.ingress\.kubernetes\.io/forwarding-rule}') echo $FW_RULE
L'output è simile al seguente:
k8s2-fr-j76hrtv4-default-frontend-wvvf7381
Aggiungi la regola di forwarding al manifest:
sed -i "s/FORWARDING_RULE_NAME/$FW_RULE/g" "extras/postgres-hpa/hpa/frontend.yaml"
Questo comando sostituisce
FORWARDING_RULE_NAME
con la regola di forwarding salvata.Applica il manifest al cluster:
kubectl apply -f extras/postgres-hpa/hpa/frontend.yaml
Checkpoint: convalida della configurazione della scalabilità automatica
Ottieni lo stato delle tue risorse HorizontalPodAutoscaler
:
kubectl get hpa
L'output è simile al seguente:
NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS AGE
accounts-db-postgresql StatefulSet/accounts-db-postgresql 10905m/15 (avg) 1 5 2 5m2s
contacts Deployment/contacts 1%/70% 1 5 1 11m
frontend Deployment/frontend <unknown>/5 (avg) 5 25 1 34s
userservice Deployment/userservice 0%/60% 5 50 5 4m56s
A questo punto, hai configurato l'applicazione e la scalabilità automatica. Il frontend e il database ora possono scalare in base alle metriche che hai fornito.
Simula il carico e osserva la scalabilità di GKE
Bank of Anthos include un servizio loadgenerator
che ti consente di simulare il traffico
per testare lo scaling dell'applicazione sotto carico. In questa sezione, eseguirai il deployment del servizio loadgenerator
, genererai un carico e osserverai lo scaling risultante.
Esegui il deployment del generatore di test di carico
Crea una variabile di ambiente con l'indirizzo IP del bilanciatore del carico di Bank of Anthos:
export LB_IP=$(kubectl get ingress frontend -o=jsonpath='{.status.loadBalancer.ingress[0].ip}') echo $LB_IP
L'output è simile al seguente:
203.0.113.9
Aggiungi l'indirizzo IP del bilanciatore del carico al manifest:
sed -i "s/FRONTEND_IP_ADDRESS/$LB_IP/g" "extras/postgres-hpa/loadgenerator.yaml"
Applica il manifest al cluster:
kubectl apply -f extras/postgres-hpa/loadgenerator.yaml
Il generatore di carico inizia ad aggiungere un utente al secondo, fino a 250 utenti.
Simula carico
In questa sezione, utilizzi un generatore di carico per simulare picchi di traffico e osservare l'aumento del numero di repliche e di nodi per gestire il carico maggiore nel tempo. Dopodiché, termini il test e osservi la fare lo scale down del numero di repliche e nodi in risposta.
Esporre localmente l'interfaccia web del generatore di carico:
kubectl port-forward svc/loadgenerator 8080
Se visualizzi un messaggio di errore, riprova quando il pod è in esecuzione.
In un browser, apri l'interfaccia web del generatore di carico.
- Se utilizzi una shell locale, apri un browser e vai all'indirizzo http://127.0.0.1:8080.
- Se utilizzi Cloud Shell, fai clic su Anteprima web, quindi fai clic su Anteprima sulla porta 8080.
Fai clic sulla scheda Grafici per osservare il rendimento nel tempo.
Apri una nuova finestra del terminale e osserva il conteggio delle repliche degli autoscaler dei pod orizzontali:
kubectl get hpa -w
Il numero di repliche aumenta man mano che il carico aumenta. Lo scale up potrebbe richiedere circa 10 minuti.
NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS accounts-db-postgresql StatefulSet/accounts-db-postgresql 8326m/15 (avg) 1 5 5 contacts Deployment/contacts 51%/70% 1 5 2 frontend Deployment/frontend 5200m/5 (avg) 5 25 13 userservice Deployment/userservice 71%/60% 5 50 17
Apri un'altra finestra del terminale e controlla il numero di nodi nel cluster:
gcloud container clusters list \ --filter='name=bank-of-anthos' \ --format='table(name, currentMasterVersion, currentNodeVersion, currentNodeCount)' \ --region="us-central1"
Il numero di nodi è aumentato dalla quantità iniziale di tre nodi per ospitare le nuove repliche.
Apri l'interfaccia del generatore di carico e fai clic su Interrompi per terminare il test.
Controlla di nuovo il conteggio delle repliche e dei nodi e osserva come i numeri diminuiscono con il carico ridotto. Lo fare lo scale down potrebbe richiedere un po' di tempo perché la finestra di stabilizzazione predefinita per le repliche nella risorsa
HorizontalPodAutoscaler
di Kubernetes è di cinque minuti. Per ulteriori informazioni, consulta la finestra di stabilizzazione.
Esegui la pulizia
Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.
Elimina singole risorse
Google Cloud crea risorse, come i bilanciatori del carico, in base agli oggetti Kubernetes che crei. Per eliminare tutte le risorse di questo tutorial:
Elimina le risorse Kubernetes di esempio:
kubectl delete \ -f extras/postgres-hpa/loadgenerator.yaml \ -f extras/postgres-hpa/hpa \ -f extras/postgres-hpa/kubernetes-manifests \ -f extras/jwt/jwt-secret.yaml \ -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter.yaml
Elimina il database PostgreSQL:
helm uninstall accounts-db kubectl delete pvc -l "app.kubernetes.io/instance=accounts-db" kubectl delete configmaps initdb
Elimina il cluster GKE e il service account IAM:
gcloud iam service-accounts delete "bank-of-anthos@PROJECT_ID.iam.gserviceaccount.com" --quiet gcloud container clusters delete "bank-of-anthos" --region="us-central1" --quiet
Elimina il progetto
Delete a Google Cloud project:
gcloud projects delete PROJECT_ID
Passaggi successivi
- Scopri di più sulla scalabilità automatica pod verticale, che puoi utilizzare per regolare automaticamente le richieste di risorse per i workload a lunga esecuzione con consigli basati sull'utilizzo storico.
- Scopri di più sulla scalabilità automatica pod orizzontale.