Ottimizza la scalabilità automatica dei pod in base alle metriche

---

Questo tutorial mostra come scalare automaticamente Carichi di lavoro di Google Kubernetes Engine (GKE) basati sulle metriche disponibili in Cloud Monitoring.

In questo tutorial puoi configurare la scalabilità automatica in base a uno dei seguenti metrics:

CPU

Utilizzo CPU

Scalabilità in base alla percentuale di utilizzo delle CPU tra i nodi. Può essere economicamente convenienti, consentendoti di massimizzare l'utilizzo delle risorse della CPU. Poiché L'utilizzo della CPU è una metrica finale, ma i tuoi utenti potrebbero riscontrare latenza mentre è in corso uno scale up.

Pub/Sub

Backlog Pub/Sub

Applicare la scalabilità in base a una metrica esterna che segnala il numero di non riconosciuti messaggi rimanenti in Sottoscrizione Pub/Sub. In questo modo, è possibile ridurre la latenza prima che diventi un problema, ma potresti utilizzare una quantità rispetto alla scalabilità automatica basata sull'utilizzo della CPU.

Metrica personalizzata

Metrica Prometheus personalizzata

Applica la scalabilità in base a una metrica personalizzata definita dall'utente, esportata in Prometheus tramite Google Managed Prometheus. Il tuo La metrica di Prometheus deve essere di tipo Indicatore.

La scalabilità automatica punta fondamentalmente a trovare un equilibrio accettabile tra costi e latenza. Ti consigliamo di sperimentare una combinazione di queste metriche e altri per trovare una norma adatta alle tue esigenze.

Obiettivi

Questo tutorial copre le seguenti attività:

1. Come eseguire il deployment dell'adattatore delle metriche personalizzate.
2. Come esportare le metriche dal codice dell'applicazione.
3. Come visualizzare le metriche nell'interfaccia di Cloud Monitoring.
4. Eseguire il deployment di un HorizontalPodAutoscaler (HPA) per scalare l'applicazione in base alle metriche di Cloud Monitoring.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

• GKE
• Pub/Sub

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Una volta completate le attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la pagina Pulizia.

Prima di iniziare

Per abilitare l'API Kubernetes Engine, segui questi passaggi:

1. Visita il pagina Kubernetes Engine nella console Google Cloud.
2. Crea o seleziona un progetto.
3. Attendi che l'API e i servizi correlati siano abilitati. Questa operazione può richiedere diversi minuti.

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

Puoi seguire questo tutorial utilizzando Cloud Shell, disponibile sono preinstallati gli strumenti a riga di comando gcloud e kubectl utilizzati in questo tutorial. Se utilizzi Cloud Shell, non è necessario installare a riga di comando sulla workstation.

Per utilizzare Cloud Shell:

1. Vai alla console Google Cloud.

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

   Una sessione di Cloud Shell si apre all'interno di un nuovo frame in basso della console Google Cloud e visualizza un prompt della riga di comando.

   

Configurazione dell'ambiente

1. Imposta la zona predefinita per Google Cloud CLI:

   gcloud config set compute/zone zone
   

   Sostituisci quanto segue:

   • zone: scegli la zona più vicina a te. Per ulteriori informazioni, vedi Regioni e zone.

2. Imposta le variabili di ambiente PROJECT_ID e PROJECT_NUMBER sul tuo ID e numero di progetto Google Cloud:

   export PROJECT_ID=project-id
   export PROJECT_NUMBER=$(gcloud projects describe $PROJECT_ID --format 'get(projectNumber)')
   

3. Imposta la zona predefinita per Google Cloud CLI:

   gcloud config set project $PROJECT_ID
   

4. Crea un cluster GKE cluster

   Per maggiore sicurezza durante l'accesso ai servizi Google Cloud, ti consigliamo abilitando la Federazione delle identità per i carichi di lavoro per GKE sul tuo cluster. Mentre questa pagina include esempi che utilizzano il metodo precedente (con Federazione delle identità per i carichi di lavoro per GKE disabilitata), la sua abilitazione migliora la protezione.

   Workload Identity

   Per creare un cluster con la federazione delle identità per i carichi di lavoro abilitata per GKE, esegui questo comando :

   gcloud container clusters create metrics-autoscaling --workload-pool=$PROJECT_ID.svc.id.goog
   

   Autenticazione legacy

   Per creare un cluster con federazione delle identità per i carichi di lavoro per GKE disabilitata, esegui seguente comando:

   gcloud container clusters create metrics-autoscaling
   

Deployment dell'adattatore delle metriche personalizzate

L'adattatore delle metriche personalizzate consente al cluster di inviare e ricevere le metriche con Cloud Monitoring.

CPU

Non applicabile: Horizontal Pod Autoscaler possono scalare in base all'utilizzo della CPU in modo nativo, per cui non occorre l'adattatore delle metriche personalizzate.

Pub/Sub

La procedura per installare l'adattatore delle metriche personalizzate è diversa per i cluster con o senza la federazione delle identità per i carichi di lavoro per GKE. Seleziona l'opzione corrispondente alla configurazione che hai scelto quando hai creato il cluster.

Workload Identity

Concedi all'utente la possibilità di creare i ruoli di autorizzazione richiesti:

kubectl create clusterrolebinding cluster-admin-binding \
    --clusterrole cluster-admin --user "$(gcloud config get-value account)"

Esegui il deployment dell'adattatore delle metriche personalizzate sul tuo cluster:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml

L'adattatore utilizza il piano custom-metrics-stackdriver-adapter di Kubernetes nello spazio dei nomi custom-metrics. Consenti questo servizio di Cloud Monitoring per leggere le metriche di Cloud Monitoring assegnandole Ruolo Visualizzatore Monitoring:

gcloud projects add-iam-policy-binding projects/$PROJECT_ID \
  --role roles/monitoring.viewer \
  --member=principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/$PROJECT_ID.svc.id.goog/subject/ns/custom-metrics/sa/custom-metrics-stackdriver-adapter

Autenticazione legacy

Concedi all'utente la possibilità di creare i ruoli di autorizzazione richiesti:

kubectl create clusterrolebinding cluster-admin-binding \
    --clusterrole cluster-admin --user "$(gcloud config get-value account)"

Esegui il deployment dell'adattatore delle metriche personalizzate sul tuo cluster:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml

Metrica personalizzata

La procedura per installare l'adattatore delle metriche personalizzate è diversa per i cluster con o senza la federazione delle identità per i carichi di lavoro per GKE. Seleziona l'opzione corrispondente alla configurazione che hai scelto quando hai creato il cluster.

Workload Identity

Concedi all'utente la possibilità di creare i ruoli di autorizzazione richiesti:

kubectl create clusterrolebinding cluster-admin-binding \
    --clusterrole cluster-admin --user "$(gcloud config get-value account)"

Esegui il deployment dell'adattatore delle metriche personalizzate sul tuo cluster:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml

L'adattatore utilizza il piano custom-metrics-stackdriver-adapter di Kubernetes nello spazio dei nomi custom-metrics. Consenti questo servizio di Cloud Monitoring per leggere le metriche di Cloud Monitoring assegnandole Ruolo Visualizzatore Monitoring:

gcloud projects add-iam-policy-binding projects/$PROJECT_ID \
  --role roles/monitoring.viewer \
  --member=principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/$PROJECT_ID.svc.id.goog/subject/ns/custom-metrics/sa/custom-metrics-stackdriver-adapter

Autenticazione legacy

Concedi all'utente la possibilità di creare i ruoli di autorizzazione richiesti:

kubectl create clusterrolebinding cluster-admin-binding \
    --clusterrole cluster-admin --user "$(gcloud config get-value account)"

Esegui il deployment dell'adattatore delle metriche personalizzate sul tuo cluster:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/k8s-stackdriver/master/custom-metrics-stackdriver-adapter/deploy/production/adapter_new_resource_model.yaml

Deployment di un'applicazione con metriche

Scarica il repository contenente il codice dell'applicazione per questo tutorial:

CPU

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
cd kubernetes-engine-samples/quickstarts/hello-app

Pub/Sub

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
cd kubernetes-engine-samples/databases/cloud-pubsub

Metrica personalizzata

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
cd kubernetes-engine-samples/observability/custom-metrics-autoscaling/google-managed-prometheus

Il repository contiene codice che esporta le metriche in Cloud Monitoring:

CPU

Questa applicazione risponde "Hello, world!" a tutte le richieste web sulla porta 8080. Le metriche di CPU di Compute Engine vengono automaticamente raccolte da Cloud Monitoring.

package main

import (
	"fmt"
	"log"
	"net/http"
	"os"
)

func main() {
	// register hello function to handle all requests
	mux := http.NewServeMux()
	mux.HandleFunc("/", hello)

	// use PORT environment variable, or default to 8080
	port := os.Getenv("PORT")
	if port == "" {
		port = "8080"
	}

	// start the web server on port and accept requests
	log.Printf("Server listening on port %s", port)
	log.Fatal(http.ListenAndServe(":"+port, mux))
}

// hello responds to the request with a plain-text "Hello, world" message.
func hello(w http.ResponseWriter, r *http.Request) {
	log.Printf("Serving request: %s", r.URL.Path)
	host, _ := os.Hostname()
	fmt.Fprintf(w, "Hello, world!\n")
	fmt.Fprintf(w, "Version: 1.0.0\n")
	fmt.Fprintf(w, "Hostname: %s\n", host)
}

Pub/Sub

Questa applicazione esegue il polling di una sottoscrizione Pub/Sub per i nuovi messaggi, ricevendoli all'arrivo. Pub/Sub le metriche dell'abbonamento vengono raccolte automaticamente da Cloud Monitoring.

from google import auth
from google.cloud import pubsub_v1


def main():
    """Continuously pull messages from subsciption"""

    # read default project ID
    _, project_id = auth.default()
    subscription_id = 'echo-read'

    subscriber = pubsub_v1.SubscriberClient()
    subscription_path = subscriber.subscription_path(
        project_id, subscription_id)

    def callback(message: pubsub_v1.subscriber.message.Message) -> None:
        """Process received message"""
        print(f"Received message: ID={message.message_id} Data={message.data}")
        print(f"[{datetime.datetime.now()}] Processing: {message.message_id}")
        time.sleep(3)
        print(f"[{datetime.datetime.now()}] Processed: {message.message_id}")
        message.ack()

    streaming_pull_future = subscriber.subscribe(
        subscription_path, callback=callback)
    print(f"Pulling messages from {subscription_path}...")

    with subscriber:
        try:
            streaming_pull_future.result()
        except Exception as e:
            print(e)

Metrica personalizzata

Questa applicazione risponde a qualsiasi richiesta web al percorso /metrics con un metrica a valore costante utilizzando il formato Prometheus.

metric := prometheus.NewGauge(
	prometheus.GaugeOpts{
		Name: *metricName,
		Help: "Custom metric",
	},
)
prometheus.MustRegister(metric)
metric.Set(float64(*metricValue))

http.Handle("/metrics", promhttp.Handler())
log.Printf("Starting to listen on :%d", *port)
err := http.ListenAndServe(fmt.Sprintf(":%d", *port), nil)

Il repository contiene anche un manifest Kubernetes su cui eseguire il deployment dell'applicazione. nel tuo cluster:

CPU

apiVersion: apps/v1
kind: Deployment
metadata:
  name: helloweb
  labels:
    app: hello
spec:
  selector:
    matchLabels:
      app: hello
      tier: web
  template:
    metadata:
      labels:
        app: hello
        tier: web
    spec:
      containers:
      - name: hello-app
        image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
        ports:
        - containerPort: 8080
        resources:
          requests:
            cpu: 200m

Pub/Sub

Il manifest è diverso per i cluster con o senza federazione delle identità per i carichi di lavoro per GKE in un bucket con il controllo delle versioni attivo. Seleziona l'opzione corrispondente alla configurazione scelta quando creato il tuo cluster.

Workload Identity

apiVersion: apps/v1
kind: Deployment
metadata:
  name: pubsub
spec:
  selector:
    matchLabels:
      app: pubsub
  template:
    metadata:
      labels:
        app: pubsub
    spec:
      serviceAccountName: pubsub-sa
      containers:
      - name: subscriber
        image: us-docker.pkg.dev/google-samples/containers/gke/pubsub-sample:v2

Autenticazione legacy

apiVersion: apps/v1
kind: Deployment
metadata:
  name: pubsub
spec:
  selector:
    matchLabels:
      app: pubsub
  template:
    metadata:
      labels:
        app: pubsub
    spec:
      volumes:
      - name: google-cloud-key
        secret:
          secretName: pubsub-key
      containers:
      - name: subscriber
        image: us-docker.pkg.dev/google-samples/containers/gke/pubsub-sample:v2
        volumeMounts:
        - name: google-cloud-key
          mountPath: /var/secrets/google
        env:
        - name: GOOGLE_APPLICATION_CREDENTIALS
          value: /var/secrets/google/key.json

Metrica personalizzata

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: custom-metrics-gmp
  name: custom-metrics-gmp
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      run: custom-metrics-gmp
  template:
    metadata:
      labels:
        run: custom-metrics-gmp
    spec:
      containers:
      # sample container generating custom metrics
      - name: prometheus-dummy-exporter
        image: us-docker.pkg.dev/google-samples/containers/gke/prometheus-dummy-exporter:v0.2.0
        command: ["./prometheus-dummy-exporter"]
        args:
        - --metric-name=custom_prometheus
        - --metric-value=40
        - --port=8080

Con la risorsa PodMonitoring, Google Cloud Managed Service per Prometheus esporta Metriche Prometheus a Cloud Monitoring:

apiVersion: monitoring.googleapis.com/v1
kind: PodMonitoring
metadata:
  name: "custom-metrics-exporter"
spec:
  selector:
    matchLabels:
      run: custom-metrics-gmp
  endpoints:
  - port: 8080
    path: /metrics
    interval: 15s

Nota: a partire da GKE versione Standard 1.27 o GKE Autopilot versione 1.25, Google Cloud Managed Service per Prometheus è abilitato. Per attivare Google Cloud Managed Service per Prometheus nei cluster delle versioni precedenti, consulta Abilita la raccolta gestita.

Esegui il deployment dell'applicazione nel tuo cluster:

CPU

kubectl apply -f manifests/helloweb-deployment.yaml

Pub/Sub

La procedura per il deployment dell'applicazione è diversa per i cluster con o senza che sia abilitata la federazione delle identità per i carichi di lavoro per GKE. Seleziona l'opzione corrispondente alla configurazione che hai scelto quando hai creato il cluster.

Workload Identity

1. Abilita l'API Pub/Sub sul tuo progetto:

   gcloud services enable cloudresourcemanager.googleapis.com pubsub.googleapis.com
   

2. Crea un argomento e una sottoscrizione Pub/Sub:

   gcloud pubsub topics create echo
   gcloud pubsub subscriptions create echo-read --topic=echo
   

3. Esegui il deployment dell'applicazione nel tuo cluster:

   kubectl apply -f deployment/pubsub-with-workload-identity.yaml
   

4. Questa applicazione definisce un account di servizio Kubernetes pubsub-sa. Assegna il ruolo Sottoscrittore Pub/Sub per consentire all'applicazione di pubblicare messaggi l'argomento Pub/Sub.

   gcloud projects add-iam-policy-binding projects/jmfran-gke-dev \
     --role=roles/pubsub.subscriber \
     --member=principal://iam.googleapis.com/projects/$PROJECT_NUMBER/locations/global/workloadIdentityPools/$PROJECT_ID.svc.id.goog/subject/ns/default/sa/pubsub-sa
   

   Nota: il comando precedente utilizza un identificatore entità che consente IAM per fare riferimento direttamente a un account di servizio Kubernetes. Ti consigliamo di utilizzare gli identificatori Principal, ma tieni in considerazione è limitato la descrizione di un metodo alternativo.

Autenticazione legacy

1. Abilita l'API Pub/Sub sul tuo progetto:

   gcloud services enable cloudresourcemanager.googleapis.com pubsub.googleapis.com
   

2. Crea un argomento e una sottoscrizione Pub/Sub:

   gcloud pubsub topics create echo
   gcloud pubsub subscriptions create echo-read --topic=echo
   

3. Crea un account di servizio con accesso a Pub/Sub:

   gcloud iam service-accounts create autoscaling-pubsub-sa
   gcloud projects add-iam-policy-binding $PROJECT_ID \
     --member "serviceAccount:autoscaling-pubsub-sa@$PROJECT_ID.iam.gserviceaccount.com" \
     --role "roles/pubsub.subscriber"
   

4. Scarica il file della chiave dell'account di servizio:

   gcloud iam service-accounts keys create key.json \
     --iam-account autoscaling-pubsub-sa@$PROJECT_ID.iam.gserviceaccount.com
   

5. Importa la chiave dell'account di servizio nel cluster come Secret:

   kubectl create secret generic pubsub-key --from-file=key.json=./key.json
   

6. Esegui il deployment dell'applicazione nel tuo cluster:

   kubectl apply -f deployment/pubsub-with-secret.yaml
   

Metrica personalizzata

kubectl apply -f custom-metrics-gmp.yaml

Dopo aver atteso il deployment dell'applicazione, tutti i pod raggiungono Ready stato:

CPU

kubectl get pods

Output:

NAME                        READY   STATUS    RESTARTS   AGE
helloweb-7f7f7474fc-hzcdq   1/1     Running   0          10s

Pub/Sub

kubectl get pods

Output:

NAME                     READY   STATUS    RESTARTS   AGE
pubsub-8cd995d7c-bdhqz   1/1     Running   0          58s

Metrica personalizzata

kubectl get pods

Output:

NAME                                  READY   STATUS    RESTARTS   AGE
custom-metrics-gmp-865dffdff9-x2cg9   1/1     Running   0          49s

Visualizzazione delle metriche su Cloud Monitoring

Durante l'esecuzione, l'applicazione scrive le metriche in Cloud Monitoring.

Per visualizzare le metriche per una risorsa monitorata mediante Metrics Explorer, segui questi passaggi:

1. Nella console Google Cloud, vai alla Pagina Esplora metriche:

   Vai a Esplora metriche

   Se utilizzi la barra di ricerca per trovare questa pagina, seleziona il risultato con il sottotitolo Monitoraggio.

2. Nell'elemento Metrica, espandi il menu Seleziona una metrica e poi seleziona un tipo di risorsa e un tipo di metrica. Ad esempio, per tracciare un grafico sull'utilizzo della CPU macchina virtuale, segui questi passaggi:
   1. (Facoltativo) Per ridurre le opzioni del menu, inserisci parte del nome della metrica nel Barra dei filtri. Per questo esempio, inserisci utilization.
   2. Nel menu Risorse attive, seleziona Istanza VM.
   3. Nel menu Categorie di metriche attive, seleziona Istanza.
   4. Nel menu Metriche attive, seleziona Utilizzo CPU e poi fai clic su Applica.

3. Per filtrare le serie temporali visualizzate, utilizza la Elemento Filtro:

4. Per combinare le serie temporali, utilizza i menu nella Elemento di aggregazione: Ad esempio, per visualizzare l'utilizzo della CPU per le VM, in base alla zona, imposta il valore il primo menu su Media e il secondo menu su zone.

   Tutte le serie temporali vengono visualizzate nel primo menu dell'elemento Aggregation è impostato su Unaggregated (Non aggregato). Le impostazioni predefinite per l'elemento Aggregation sono determinati dal tipo di metrica selezionato.

Il tipo di risorsa e le metriche sono i seguenti:

CPU

Esplora metriche

Tipo di risorsa: gce_instance

Metrica: compute.googleapis.com/instance/cpu/utilization

Pub/Sub

Esplora metriche

Tipo di risorsa: pubsub_subscription

Metrica: pubsub.googleapis.com/subscription/num_undelivered_messages

Metrica personalizzata

Esplora metriche

Tipo di risorsa: prometheus_target

Metrica: prometheus.googleapis.com/custom_prometheus/gauge

Nota: a seconda della metrica, potresti non vedere molta attività nella Esplora metriche di Cloud Monitoring. Non sorprenderti se la tua metrica non si aggiorna.

Creazione di un oggetto HorizontalPodAutoscaler

Quando vedi la metrica in Cloud Monitoring, puoi eseguire il deployment HorizontalPodAutoscaler per ridimensionare il deployment in base alla metrica.

CPU

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: cpu
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: helloweb
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 30

Pub/Sub

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: pubsub
spec:
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - external:
      metric:
       name: pubsub.googleapis.com|subscription|num_undelivered_messages
       selector:
         matchLabels:
           resource.labels.subscription_id: echo-read
      target:
        type: AverageValue
        averageValue: 2
    type: External
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: pubsub

Metrica personalizzata

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: custom-metrics-gmp-hpa
  namespace: default
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: custom-metrics-gmp
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: Pods
    pods:
      metric:
        name: prometheus.googleapis.com|custom_prometheus|gauge
      target:
        type: AverageValue
        averageValue: 20

Esegui il deployment di HorizontalPodAutoscaler nel tuo cluster:

CPU

kubectl apply -f manifests/helloweb-hpa.yaml

Pub/Sub

kubectl apply -f deployment/pubsub-hpa.yaml

Metrica personalizzata

kubectl apply -f custom-metrics-gmp-hpa.yaml

Generazione del carico in corso...

Per alcune metriche, potrebbe essere necessario generare un carico per osservare la scalabilità automatica:

CPU

Simula 10.000 richieste al server helloweb:

 kubectl exec -it deployments/helloweb -- /bin/sh -c \
     "for i in $(seq -s' ' 1 10000); do wget -q -O- localhost:8080; done"

Pub/Sub

Pubblica 200 messaggi nell'argomento Pub/Sub:

for i in {1..200}; do gcloud pubsub topics publish echo --message="Autoscaling #${i}"; done

Metrica personalizzata

Non applicabile: il codice utilizzato in questo esempio esporta un valore costante 40 per la metrica personalizzata. HorizontalPodAutoscaler è impostato con un valore valore target di 20, quindi tenta di fare lo scale up del deployment automaticamente.

Nota: potrebbe essere necessario attendere un paio di minuti prima che HorizontalPodAutoscaler ai cambiamenti delle metriche.

Osservazione dello scale up di HorizontalPodAutoscaler

Puoi controllare il numero attuale di repliche del tuo deployment eseguendo:

kubectl get deployments

Dopo aver concesso un po' di tempo per la propagazione della metrica, Deployment crea cinque pod per gestire il backlog.

Puoi anche esaminare lo stato e l'attività recente del HorizontalPodAutoscaler eseguendo:

kubectl describe hpa

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.

CPU

Elimina il tuo cluster GKE:

 gcloud container clusters delete metrics-autoscaling

Pub/Sub

1. Esegui la pulizia della sottoscrizione Pub/Sub e dell'argomento:

   gcloud pubsub subscriptions delete echo-read
   gcloud pubsub topics delete echo
   

2. Elimina il tuo cluster GKE:

   gcloud container clusters delete metrics-autoscaling
   

Metrica personalizzata

Elimina il tuo cluster GKE:

 gcloud container clusters delete metrics-autoscaling

Passaggi successivi

• Scopri di più sulle metriche personalizzate ed esterne per la scalabilità dei carichi di lavoro.

• Esplora altri tutorial su Kubernetes Engine.