Pod-Autoscaling anhand von Messwerten optimieren

---

In dieser Anleitung wird gezeigt, wie Sie Ihre GKE-Arbeitslasten (Google Kubernetes Engine) anhand von Messwerten, die in Cloud Monitoring verfügbar sind, automatisch skalieren.

In dieser Anleitung können Sie das Autoscaling basierend auf einem von vier verschiedenen Messwerten einrichten:

CPU

CPU-Auslastung

Sie skalieren basierend auf der prozentualen Auslastung von CPUs über Knoten hinweg. Dies kann kostengünstig sein, wodurch Sie die CPU-Ressourcennutzung maximieren können. Da die CPU-Auslastung ein nachhängender Messwert ist, kann bei Ihren Nutzern jedoch Latenz auftreten, während eine vertikale Skalierung erfolgt.

Pub/Sub

Pub/Sub-Rückstand

Sie skalieren basierend auf der Anzahl der unbestätigten Nachrichten, die in einem Pub/Sub-Abo vorhanden sind. Dies kann die Latenz wirksam reduzieren, bevor sie zu einem Problem wird. Es kann aber auch den Ressourcenverbrauch gegenüber dem Autoscaling basierend auf der CPU-Auslastung erhöhen.

Benutzerdefinierter Messwert

Benutzerdefinierter Cloud Monitoring-Messwert

Sie skalieren basierend auf einem benutzerdefinierten Messwert, der von den Cloud Monitoring-Clientbibliotheken exportiert wird. Weitere Informationen finden Sie unter Benutzerdefinierte Messwerte erstellen in der Cloud Monitoring-Dokumentation.

Prometheus (benutzerdefiniert)

Benutzerdefinierter Prometheus-Messwert

Sie skalieren basierend auf einem benutzerdefinierten Messwert, der in das Prometheus-Format exportiert wurde. Der Prometheus-Messwert muss vom Typ Gauge sein und darf nicht das Präfix custom.googleapis.com enthalten.

Beim Autoscaling geht es im Wesentlichen darum, ein akzeptables Verhältnis zwischen Kosten und Latenz zu finden. Sie können eine Kombination dieser Messwerte und anderer Messwerte ausprobieren, um eine für Sie geeignete Richtlinie zu finden.

Ziele

In dieser Anleitung werden die folgenden Aufgaben behandelt:

1. Adapter für benutzerdefinierte Messwerte bereitstellen
2. Messwerte aus dem Anwendungscode exportieren
3. Messwerte in der Cloud Monitoring-Oberfläche ansehen
4. HPA-Ressource (HorizontalPodAutoscaler) bereitstellen, um Ihre Anwendung basierend auf Cloud Monitoring-Messwerten zu skalieren

Kosten

In diesem Dokument verwenden Sie die folgenden kostenpflichtigen Komponenten von Google Cloud:

• GKE
• Pub/Sub

Mit dem Preisrechner können Sie eine Kostenschätzung für Ihre voraussichtliche Nutzung vornehmen. Neuen Google Cloud-Nutzern steht möglicherweise eine kostenlose Testversion zur Verfügung.

Nach Abschluss der in diesem Dokument beschriebenen Aufgaben können Sie weitere Kosten vermeiden, indem Sie die erstellten Ressourcen löschen. Weitere Informationen finden Sie unter Bereinigen.

Vorbereitung

Führen Sie folgende Schritte aus, um die Kubernetes Engine API zu aktivieren:

1. Rufen Sie in der Google Cloud Console die Seite "Kubernetes Engine" auf.
2. Erstellen Sie ein Projekt oder wählen Sie eines aus.
3. Warten Sie, bis die API und die zugehörigen Dienste aktiviert worden sind. Dieser Vorgang kann einige Minuten dauern.

4. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

Sie können diese Anleitung mit Cloud Shell ausführen, das mit den in dieser Anleitung verwendeten gcloud- und kubectl-Befehlszeilentools vorinstalliert wird. Wenn Sie Cloud Shell verwenden, müssen Sie diese Befehlszeilentools nicht auf Ihrer Workstation installieren.

So verwenden Sie Cloud Shell:

1. Öffnen Sie die Google Cloud Console.

2. Klicken Sie im oberen Bereich der Google Cloud Console auf Cloud Shell aktivieren .

   Im unteren Bereich der Google Cloud Console wird ein neues Feld mit einer Cloud Shell-Sitzung und einer Befehlszeilen-Eingabeaufforderung geöffnet.

   

Umgebung einrichten

1. Legen Sie das Standardprojekt für Google Cloud CLI fest:

   gcloud config set compute/zone zone
   

   Dabei gilt:

   • zone: Wählen Sie eine Zone aus, die geografisch in Ihrer Nähe liegt. Weitere Informationen finden Sie unter Regionen und Zonen.

2. Legen Sie für die Umgebungsvariable PROJECT_ID Ihre Google Cloud-Projekt-ID (project-id) fest.

   export PROJECT_ID=project-id
   

3. Legen Sie das Standardprojekt für Google Cloud CLI fest:

   gcloud config set project $PROJECT_ID
   

4. Erstellen Sie einen GKE-Cluster.

   gcloud container clusters create metrics-autoscaling
   

   Hinweis: Diese Anleitung bezieht sich auf Cluster, für die Workload Identity-Föderation für GKE deaktiviert ist. Wenn für Ihren Cluster Workload Identity-Föderation für GKE aktiviert ist, müssen Sie weitere Schritte ausführen, wie auf dieser GitHub-Seite erläutert.

Adapter für benutzerdefinierte Messwerte bereitstellen

Der Adapter für benutzerdefinierte Messwerte ermöglicht Ihrem Cluster, Messwerte mit Cloud Monitoring zu senden und zu empfangen.

CPU

Nicht zutreffend: Horizontale Pod-Autoscalings können nativ basierend auf der CPU-Auslastung skaliert werden. Der Adapter für benutzerdefinierte Messwerte wird deshalb nicht benötigt.

Pub/Sub

Ermöglichen Sie dem Nutzer, die erforderlichen Autorisierungsrollen zu erstellen:

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

Stellen Sie für Ihren Cluster den Adapter für das neue Ressourcenmodell bereit:

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

Benutzerdefinierter Messwert

Ermöglichen Sie dem Nutzer, die erforderlichen Autorisierungsrollen zu erstellen:

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

Stellen Sie für Ihren Cluster den Adapter für das Ressourcenmodell bereit:

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

Prometheus (benutzerdefiniert)

Ermöglichen Sie dem Nutzer, die erforderlichen Autorisierungsrollen zu erstellen:

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

Stellen Sie für Ihren Cluster den Adapter für das Legacy-Ressourcenmodell bereit:

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

Hinweis: Es gibt zwei Versionen des Adapters: das Legacy-Modell und das neue Ressourcenmodell. Weitere Informationen finden Sie auf der GitHub-Seite des Adapters.

Anwendung mit Messwerten bereitstellen

Laden Sie das Repository mit dem Anwendungscode für diese Anleitung herunter:

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

Benutzerdefinierter Messwert

git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
cd kubernetes-engine-samples/observability/custom-metrics-autoscaling/direct-to-sd

Prometheus (benutzerdefiniert)

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

Das Repository enthält Code, der Messwerte in Cloud Monitoring exportiert:

CPU

Diese Anwendung antwortet auf alle Webanfragen an Port 8080 mit"Hello, world!". Compute Engine-CPU-Messwerte werden von Cloud Monitoring automatisch erfasst.

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

Diese Anwendung fragt ein Pub/Sub-Abo nach neuen Nachrichten ab und bestätigt sie beim Eingang. Pub/Sub-Abomesswerte werden von Cloud Monitoring automatisch erfasst.

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)

Benutzerdefinierter Messwert

Diese Anwendung exportiert einen konstanten Messwert mithilfe der Cloud Monitoring-Clientbibliotheken.

func exportMetric(stackdriverService *monitoring.Service, metricName string,
	metricValue int64, metricLabels map[string]string, monitoredResource string, resourceLabels map[string]string) error {
	dataPoint := &monitoring.Point{
		Interval: &monitoring.TimeInterval{
			EndTime: time.Now().Format(time.RFC3339),
		},
		Value: &monitoring.TypedValue{
			Int64Value: &metricValue,
		},
	}
	// Write time series data.
	request := &monitoring.CreateTimeSeriesRequest{
		TimeSeries: []*monitoring.TimeSeries{
			{
				Metric: &monitoring.Metric{
					Type:   "custom.googleapis.com/" + metricName,
					Labels: metricLabels,
				},
				Resource: &monitoring.MonitoredResource{
					Type:   monitoredResource,
					Labels: resourceLabels,
				},
				Points: []*monitoring.Point{
					dataPoint,
				},
			},
		},
	}
	projectName := fmt.Sprintf("projects/%s", resourceLabels["project_id"])
	_, err := stackdriverService.Projects.TimeSeries.Create(projectName, request).Do()
	return err
}

Prometheus (benutzerdefiniert)

Diese Anwendung exportiert einen konstanten Messwert im Prometheus-Format.

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)

Das Repository enthält außerdem ein Kubernetes-Manifest, um die Anwendung in Ihrem Cluster bereitzustellen:

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

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

Benutzerdefinierter Messwert

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: custom-metric-sd
  name: custom-metric-sd
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      run: custom-metric-sd
  template:
    metadata:
      labels:
        run: custom-metric-sd
    spec:
      containers:
      - command: ["./sd-dummy-exporter"]
        args:
        - --use-new-resource-model=true
        - --use-old-resource-model=false
        - --metric-name=custom-metric
        - --metric-value=40
        - --pod-name=$(POD_NAME)
        - --namespace=$(NAMESPACE)
        image: us-docker.pkg.dev/google-samples/containers/gke/sd-dummy-exporter:v0.3.0
        name: sd-dummy-exporter
        resources:
          requests:
            cpu: 100m
        env:
        # save Kubernetes metadata as environment variables for use in metrics
        - name: POD_NAME
          valueFrom:
            fieldRef:
              apiVersion: v1
              fieldPath: metadata.name
        - name: NAMESPACE
          valueFrom:
            fieldRef:
              apiVersion: v1
              fieldPath: metadata.namespace

Prometheus (benutzerdefiniert)

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: custom-metric-prometheus-sd
  name: custom-metric-prometheus-sd
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      run: custom-metric-prometheus-sd
  template:
    metadata:
      labels:
        run: custom-metric-prometheus-sd
    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
      # pre-built 'prometheus-to-sd' sidecar container to export prometheus
      # metrics to Stackdriver
      - name: prometheus-to-sd
        image: gcr.io/google-containers/prometheus-to-sd:v0.5.0
        command: ["/monitor"]
        args:
        - --source=:http://localhost:8080
        - --stackdriver-prefix=custom.googleapis.com
        - --pod-id=$(POD_ID)
        - --namespace-id=$(POD_NAMESPACE)
        env:
        # save Kubernetes metadata as environment variables for use in metrics
        - name: POD_ID
          valueFrom:
            fieldRef:
              apiVersion: v1
              fieldPath: metadata.uid
        - name: POD_NAMESPACE
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace

Stellen Sie die Anwendung in Ihrem Cluster bereit:

CPU

kubectl apply -f manifests/helloweb-deployment.yaml

Pub/Sub

Aktivieren Sie die Pub/Sub API für Ihr Projekt:

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

Erstellen Sie ein Pub/Sub-Thema und -Abo:

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

Erstellen Sie ein Dienstkonto mit Zugriff auf 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"

Hinweis: In den obigen Dienstkontoeinstellungen wird davon ausgegangen, dass für den Cluster Workload Identity-Föderation für GKE deaktiviert ist. Wenn Ihr Cluster Workload Identity-Föderation für GKE aktiviert hat, sind weitere dienstkontospezifische Schritte auszuführen, wie auf dieser GitHub-Seite erläutert.

Laden Sie die Dienstkontoschlüsseldatei herunter:

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

Importieren Sie den Dienstkontoschlüssel als Secret in Ihren Cluster:

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

Stellen Sie die Anwendung in Ihrem Cluster bereit:

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

Benutzerdefinierter Messwert

kubectl apply -f custom-metrics-sd.yaml

Prometheus (benutzerdefiniert)

kubectl apply -f custom-metrics-prometheus-sd.yaml

Nachdem Sie einen Moment auf die Bereitstellung der Anwendung gewartet haben, erreichen alle Pods den Status Ready:

CPU

kubectl get pods

Ausgabe:

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

Pub/Sub

kubectl get pods

Ausgabe:

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

Benutzerdefinierter Messwert

kubectl get pods

Ausgabe:

NAME                                READY   STATUS    RESTARTS   AGE
custom-metric-sd-58dbf4ffc5-tm62v   1/1     Running   0          33s

Prometheus (benutzerdefiniert)

kubectl get pods

Ausgabe:

NAME                                           READY   STATUS    RESTARTS   AGE
custom-metric-prometheus-sd-697bf7c7d7-ns76p   2/2     Running   0          49s

Messwerte in Cloud Monitoring ansehen

Bei der Ausführung der Anwendung werden die Messwerte in Cloud Monitoring geschrieben.

So rufen Sie mit dem Metrics Explorer die Messwerte für eine überwachte Ressource auf:

1. Wählen Sie im Navigationsbereich der Google Cloud Console Monitoring und anschließend  Metrics Explorer aus:

   Zum Metrics Explorer

2. Erweitern Sie im Element Messwert das Menü Messwert auswählen und wählen Sie dann einen Ressourcentyp und einen Messwerttyp aus. So erstellen Sie beispielsweise die CPU-Auslastung einer virtuellen Maschine:
   1. (Optional) Um die Optionen des Menüs zu reduzieren, geben Sie einen Teil des Messwertnamens in die Filterleiste ein. Geben Sie für dieses Beispiel utilization ein.
   2. Wählen Sie im Menü Aktive Ressourcen die Option VM-Instanz aus.
   3. Wählen Sie im Menü Aktive Messwertkategorien die Option Instanz aus.
   4. Wählen Sie im Menü Aktive Messwerte die Option CPU-Auslastung aus und klicken Sie dann auf Übernehmen.

3. Verwenden Sie das Element Filter, um zu filtern, welche Zeitachsen angezeigt werden.

4. Verwenden Sie zum Kombinieren von Zeitachsen die Menüs im Element Aggregation. Wenn Sie beispielsweise die CPU-Auslastung für Ihre VMs basierend auf ihrer Zone anzeigen möchten, legen Sie das erste Menü auf Mittelwert und das zweite Menü auf Zone fest.

   Alle Zeitachsen werden angezeigt, wenn das erste Menü des Elements Aggregation auf Nicht aggregiert gesetzt ist. Die Standardeinstellungen für das Element Aggregation werden durch den ausgewählten Messwerttyp bestimmt.

Der Ressourcentyp und die Messwerte lauten:

CPU

Metrics Explorer

Ressourcentyp: gce_instance

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

Pub/Sub

Metrics Explorer

Ressourcentyp: pubsub_subscription

Messwert: pubsub.googleapis.com/subscription/num_undelivered_messages

Benutzerdefinierter Messwert

Metrics Explorer

Ressourcentyp: k8s_pod

Messwert: custom.googleapis.com/custom-metric

Prometheus (benutzerdefiniert)

Metrics Explorer

Ressourcentyp: gke_container

Messwert: custom.googleapis.com/custom_prometheus

Hinweis: Je nach Messwert werden im Cloud Monitoring Metrics Explorer möglicherweise noch nicht viele Aktivitäten angezeigt. Seien Sie nicht überrascht, wenn Ihr Messwert nicht aktualisiert wird.

HorizontalPodAutoscaler-Objekt erstellen

Wenn Sie den Messwert in Cloud Monitoring sehen, können Sie einen HorizontalPodAutoscaler bereitstellen, um die Größe des Deployments basierend auf dem Messwert anzupassen.

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/v2beta2
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

Benutzerdefinierter Messwert

apiVersion: autoscaling/v2beta2
kind: HorizontalPodAutoscaler
metadata:
  name: custom-metric-sd
  namespace: default
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: custom-metric-sd
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: Pods
    pods:
      metric:
        name: custom-metric
      target:
        type: AverageValue
        averageValue: 20

Prometheus (benutzerdefiniert)

apiVersion: autoscaling/v2beta2
kind: HorizontalPodAutoscaler
metadata:
  name: custom-prometheus-hpa
  namespace: default
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: custom-metric-prometheus-sd
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: Pods
    pods:
      metric:
        name: custom_prometheus
      target:
        type: AverageValue
        averageValue: 20

Stellen Sie den HorizontalPodAutoscaler in Ihrem Cluster bereit:

CPU

kubectl apply -f manifests/helloweb-hpa.yaml

Pub/Sub

kubectl apply -f deployment/pubsub-hpa.yaml

Benutzerdefinierter Messwert

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

Prometheus (benutzerdefiniert)

kubectl apply -f custom-metrics-prometheus-sd-hpa.yaml

Last generieren

Bei einigen Messwerten müssen Sie möglicherweise eine Last generieren, um das Autoscaling zu sehen:

CPU

Simulieren Sie 10.000 Anfragen an den helloweb-Server:

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

Pub/Sub

Veröffentlichen Sie 200 Nachrichten an das Pub/Sub-Thema:

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

Benutzerdefinierter Messwert

Nicht zutreffend: Der in diesem Beispiel verwendete Code exportiert für den benutzerdefinierten Messwert den konstanten Wert 40. Für den HorizontalPodAutoscaler ist der Zielwert 20 festgelegt, sodass er versucht, das Deployment automatisch vertikal zu skalieren.

Prometheus (benutzerdefiniert)

Nicht zutreffend: Der in diesem Beispiel verwendete Code exportiert für den benutzerdefinierten Messwert den konstanten Wert 40. Für den HorizontalPodAutoscaler ist der Zielwert 20 festgelegt, sodass er versucht, das Deployment automatisch vertikal zu skalieren.

Hinweis: Es kann einige Minuten dauern, bis der HorizontalPodAutoscaler auf die Messwertänderungen reagiert.

Hochskalieren von HorizontalPodAutoscaler beobachten

Mit folgendem Befehl können Sie die aktuelle Anzahl von Replikaten des Deployments prüfen:

kubectl get deployments

Nachdem die Ausführung des Messwerts einige Zeit in Anspruch genommen hat, erstellt das Deployment fünf Pods zur Verarbeitung des Rückstands.

Sie können auch den Status und die letzte Aktivität des HorizontalPodAutoscalers prüfen, indem Sie folgenden Befehl ausführen:

kubectl describe hpa

Bereinigen

Damit Ihrem Google Cloud-Konto die in dieser Anleitung verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie entweder das Projekt, das die Ressourcen enthält, oder Sie behalten das Projekt und löschen die einzelnen Ressourcen.

CPU

So löschen Sie den GKE-Cluster:

 gcloud container clusters delete metrics-autoscaling

Pub/Sub

1. Bereinigen Sie das Pub/Sub-Abo und -Thema:

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

2. So löschen Sie den GKE-Cluster:

   gcloud container clusters delete metrics-autoscaling
   

Benutzerdefinierter Messwert

So löschen Sie den GKE-Cluster:

 gcloud container clusters delete metrics-autoscaling

Prometheus (benutzerdefiniert)

So löschen Sie den GKE-Cluster:

 gcloud container clusters delete metrics-autoscaling

Nächste Schritte

• Benutzerdefinierte und externe Messwerte zur Skalierung von Arbeitslasten

• Weitere Kubernetes-Anleitungen