Ottimizza la scalabilità automatica dei pod in base alle metriche

Questo tutorial mostra come scalare automaticamente i carichi di lavoro Google Kubernetes Engine (GKE) in base alle metriche disponibili in Cloud Monitoring.

In questo tutorial puoi configurare la scalabilità automatica in base a una delle seguenti metriche:

Pub/Sub

Backlog Pub/Sub

Scala in base a una metrica esterna che indica il numero di messaggi non confermati rimanenti in una sottoscrizione Pub/Sub. In questo modo, è possibile ridurre efficacemente la latenza prima che diventi un problema, ma potrebbero essere utilizzate relativamente più risorse rispetto alla scalabilità automatica in base all'utilizzo della CPU.

Metrica personalizzata

Metrica Prometheus personalizzata

Scala in base a una metrica personalizzata definita dall'utente, esportata nel formato Prometheus tramite Google Managed Prometheus. La tua metrica Prometheus deve essere di tipo Misuratore.

La scalabilità automatica consiste fondamentalmente nel trovare un equilibrio accettabile tra costi e latenza. Ti consigliamo di sperimentare una combinazione di queste metriche e altre per trovare un criterio adatto alle tue esigenze.

Deployment dell'adattatore delle metriche personalizzate

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

Pub/Sub

La procedura per installare l'adattatore delle metriche personalizzate varia a seconda che i cluster abbiano abilitata o meno 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 nel 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 service account Kubernetes custom-metrics-stackdriver-adapter nello spazio dei nomi custom-metrics. Consenti a questo service account di leggere le metriche di Cloud Monitoring assegnando il 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 precedente

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 nel 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 varia a seconda che i cluster abbiano abilitata o meno 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 nel 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 service account Kubernetes custom-metrics-stackdriver-adapter nello spazio dei nomi custom-metrics. Consenti a questo service account di leggere le metriche di Cloud Monitoring assegnando il 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 precedente

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 nel 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:

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 il codice che esporta le metriche in Cloud Monitoring:

Pub/Sub

Questa applicazione esegue il polling di una sottoscrizione Pub/Sub per rilevare i nuovi messaggi e inviare un ACK non appena arrivano. Le metriche della sottoscrizione Pub/Sub vengono automaticamente raccolte 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 una 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 per eseguire il deployment dell'applicazione nel tuo cluster. Un deployment è un oggetto API Kubernetes che ti consente di eseguire più repliche di pod distribuite tra i nodi di un cluster:

Pub/Sub

Il manifest varia a seconda che i cluster abbiano abilitata o meno 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 

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 precedente 

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 le metriche di Prometheus in 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

A partire dalla versione 1.27 di GKE Standard o dalla versione 1.25 di GKE Autopilot, Google Cloud Managed Service per Prometheus è abilitato. Per abilitare Google Cloud Managed Service per Prometheus nei cluster delle versioni precedenti, consulta Abilita raccolta gestita.

Esegui il deployment dell'applicazione nel tuo cluster:

Pub/Sub

La procedura per il deployment dell'applicazione varia a seconda che i cluster abbiano abilitata o meno 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 service account Kubernetes pubsub-sa. Assegna il ruolo Sottoscrittore Pub/Sub per consentire all'applicazione di pubblicare messaggi nell'argomento Pub/Sub.

    gcloud projects add-iam-policy-binding projects/$PROJECT_ID \   --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

    Il comando precedente utilizza un identificatore entità, che consente a IAM di fare riferimento direttamente a un account di servizio Kubernetes.

    Best practice:

    Utilizza gli identificatori entità, ma tieni presente la limitazione riportata nella descrizione di un metodo alternativo.

Autenticazione precedente

  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 service account 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 del service account:

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

  5. Importa la chiave del service account 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 lo stato Ready:

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 con Esplora metriche, 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 Monitoring.

  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 di una macchina virtuale, segui questi passaggi:
    1. (Facoltativo) Per ridurre le opzioni del menu, inserisci parte del nome della metrica nella 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 l'elemento Filtro.

  4. Per combinare le serie temporali, utilizza i menu dell'elemento Aggregazione. Ad esempio, per visualizzare l'utilizzo della CPU per le VM, in base alla zona, imposta il primo menu su Media e il secondo menu su zona.

    Tutte le serie temporali vengono visualizzate quando il primo menu dell'elemento Aggregazione è impostato su Nessuna aggregazione. Le impostazioni predefinite per l'elemento Aggregazione sono determinate dal tipo di metrica che hai selezionato.

Il tipo di risorsa e le metriche sono i seguenti:

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

A seconda della metrica, potresti non vedere ancora molta attività su Esplora metriche di Cloud Monitoring. Non sorprenderti se la tua metrica non si aggiorna.

Creazione di un oggetto HorizontalPodAutoscaler

Quando visualizzi la metrica in Cloud Monitoring, puoi eseguire il deployment di un oggetto HorizontalPodAutoscaler per ridimensionare il deployment in base alla metrica.

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:

Pub/Sub 

kubectl apply -f deployment/pubsub-hpa.yaml

Metrica personalizzata

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

Generazione del carico

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

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 di 40 per la metrica personalizzata. HorizontalPodAutoscaler è impostato con un valore target di 20, quindi tenta di fare lo scale up del deployment automaticamente.

Potrebbe essere necessario attendere un paio di minuti prima che HorizontalPodAutoscaler risponda ai cambiamenti delle metriche.

Osservazione dello scale up di HorizontalPodAutoscaler

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

kubectl get deployments

Dopo aver atteso la propagazione della metrica, il deployment crea cinque pod per gestire il backlog.

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

kubectl describe hpa