Deployments mit benutzerdefinierten Messwerten automatisch skalieren

In dieser Anleitung erfahren Sie, wie Sie Ihre Arbeitslasten in GKE auf Basis von benutzerdefinierten Messwerten, die von Kubernetes-Pods aus Stackdriver exportiert werden, automatisch skalieren. Informationen zum automatischen Skalieren von Arbeitslasten anhand anderer in Stackdriver verfügbarer Messwerte finden Sie unter Deployments mit externen Messwerten automatisch skalieren.

Ziele

Bevor Sie Autoscaling mit benutzerdefinierten Messwerten in GKE einrichten können, erledigen Sie Folgendes:

  1. Stellen Sie den Stackdriver-Adapter für benutzerdefinierte Messwerte bereit.
  2. Exportieren Sie benutzerdefinierte Messwerte zu Stackdriver.
  3. Stellen Sie die Ressource "HorizontalPodAutoscaler" (HPA) zur Skalierung Ihres Deployments auf Basis der benutzerdefinierten Messwerte bereit.

Hinweise

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 Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für Ihr Projekt aktiviert ist.

Installieren Sie die folgenden Befehlszeilentools, die in dieser Anleitung verwendet werden:

  • Mit gcloud werden Kubernetes Engine-Cluster erstellt und gelöscht. gcloud ist im Google Cloud SDK enthalten.
  • kubectl wird zur Verwaltung von Kubernetes verwendet, dem Cluster-Orchestrierungssystem von Kubernetes Engine. Sie können kubectl mit gcloud installieren:
    gcloud components install kubectl

Standards für das gcloud-Befehlszeilentool festlegen

Wenn Sie die Projekt-ID und die Optionen für die Compute Engine-Zone nicht immer wieder neu in das gcloud-Befehlszeilentool eingeben möchten, können Sie die Standardwerte festlegen:
gcloud config set project project-id
gcloud config set compute/zone compute-zone

Cluster erstellen und Monitoring einrichten

Benutzerdefinierte Messwerte auswählen

Zum automatischen Skalieren mit benutzerdefinierten Messwerten haben Sie zwei Möglichkeiten:

  • Sie können einen benutzerdefinierten Messwert aus jedem Pod im Deployment exportieren und sich nach dem Durchschnittswert pro Pod richten.
  • Wenn sich der Pod außerhalb des Deployments befindet und nicht Teil eines anderen Deployments ist, können Sie einen benutzerdefinierten Messwert aus jedem Pod exportieren und sich nach der Summe dieser Messwerte richten.

Innerhalb der angegebenen Limits kann ein Deployment ihre replizierten Pods auf Basis des Messwerts skalieren. Messwerte mit einem Gesamtzielwert sollten immer so definiert werden, dass die Skalierung den Messwert näher an den Zielwert bringt.

Angenommen, Sie skalieren eine Front-End-Anwendung auf Basis des Messwerts "Abfragen pro Sekunde". Wenn sich der Messwert erhöht, sollte die Anzahl der Pods erhöht werden und jeder Pod eine ähnliche Menge an Traffic wie zuvor verarbeiten. Sie erreichen dies, indem Sie einen Wert von "Abfragen pro Sekunde" für jeden Pod exportieren und einen gewünschten Durchschnittszielwert festlegen. Das Exportieren der Gesamtanzahl der Abfragen pro Sekunde und das Festlegen eines Gesamtzielwerts für diesen Messwert führt hier dagegen nicht zum gewünschten Verhalten, da eine Erhöhung der Anzahl von Pods den Gesamttraffic nicht verringert.

Je nach Anwendungsfall können andere Messwerte wie die durchschnittliche Anfragelatenz direkt mit dem Gesamtzielwert zum Skalieren von Deployments verwendet werden.

Schritt 1: Stackdriver-Adapter für benutzerdefinierte Messwerte bereitstellen

Damit GKE-Objekte Zugriff auf in Stackdriver gespeicherte Messwerte erhalten, muss der Stackdriver-Adapter für benutzerdefinierte Messwerte bereitgestellt werden. Bevor der Adapter ausgeführt werden kann, müssen Sie Ihrem Nutzer jedoch zuerst die Berechtigung erteilen, erforderliche Autorisierungsrollen zu erstellen. Führen Sie dazu den folgenden Befehl aus:

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

Führen Sie zum Bereitstellen des Adapters in Ihrem Cluster folgenden Befehl aus:

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

Schritt 2: Messwert zu Stackdriver exportieren

Sie können Messwerte entweder direkt aus Ihrer Anwendung zu Stackdriver exportieren oder im Prometheus-Format zur Verfügung stellen und den Prometheus-to-Stackdriver-Adapter in die Container Ihres Pods aufnehmen.

Zum Aufrufen der exportierten Messwerte aus Metrics Explorer suchen Sie nach custom/[METRIC_NAME] (z. B. custom/foo).

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

  1. Wechseln Sie in der Google Cloud Console zu Monitoring oder verwenden Sie die folgende Schaltfläche:
    Zu Monitoring
  2. Klicken Sie im Navigationsbereich von Monitoring auf Metrics Explorer .
  3. Geben Sie den Namen der überwachten Ressource in das Textfeld Ressourcentyp und Messwert finden ein.

Messwerte aus der Anwendung exportieren

Sie können benutzerdefinierte Messwerte erstellen und direkt aus Ihrem Anwendungscode zu Stackdriver exportieren. Weitere Informationen finden Sie unter Benutzerdefinierte Messwerte erstellen in der Dokumentation zu Stackdriver Monitoring. Darüber hinaus steht Ihnen das Stackdriver-Feature zum automatischen Erstellen von benutzerdefinierten Messwerten zur Verfügung.

Ihr Messwert muss folgende Anforderungen erfüllen:

  • Die Messwertart muss GAUGE sein.
  • Der Messwerttyp muss entweder DOUBLE oder INT64 sein.
  • Der Messwertname muss mit dem Präfix custom.googleapis.com/ beginnen, gefolgt von einem einfachen Namen.
  • Ressourcentyp muss "gke_container" sein.
  • Die Ressourcenlabels müssen Folgendes umfassen:
    • pod_id, die auf die auf Pod-UID festgelegt ist. Sie erhalten die ID über die Downward API.
    • container_name = ""
    • project_id, zone, cluster_name. Diese kann Ihre Anwendung über den Metadatenserver abrufen. Zum Abrufen von Werten können Sie den Compute-Metadatenclient von Google Cloud verwenden.
    • namespace_id, instance_id, die auf einen beliebigen Wert gesetzt werden können.

Die folgende Manifestdatei beschreibt ein Deployment, das eine einzelne Instanz einer Go-Anwendung ausführt, die Messwerte mithilfe von Stackdriver-Clientbibliotheken exportiert:

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: ["./direct-to-sd"]
        args: ["--metric-name=foo", "--metric-value=40", "--pod-id=$(POD_ID)"]
        image: gcr.io/google-samples/sd-dummy-exporter:latest
        name: sd-dummy-exporter
        resources:
          requests:
            cpu: 100m
        env:
          - name: POD_ID
            valueFrom:
              fieldRef:
                apiVersion: v1
                fieldPath: metadata.uid

Mit Prometheus exportieren

Sie können Messwerte in Ihrer Anwendung im Prometheus-Format zur Verfügung stellen und den Prometheus-to-Stackdriver-Adapter bereitstellen, der die Messwerte abruft und zu Stackdriver exportiert. Beispiele für das Verfügbarmachen von Messwerten im Prometheus-Format finden Sie im Leitfaden zur Kubernetes-Instrumentierung.

Ihr Messwert muss folgende Anforderungen erfüllen:

  • Die Messwertart muss Gauge sein.
  • Der Messwertname darf das Präfix custom.googleapis.com nicht enthalten.

Stellen Sie den Prometheus-to-Stackdriver-Adapter als Container in dem Pod bereit, aus dem Sie Messwerte exportieren, und übergeben Sie folgende Flags an den Container:

  • pod-id und namespace-id: Setzen Sie diese auf die Pod- bzw. Namespace-UID, die Sie über die Downward API abgerufen haben.
  • source=http://localhost:[PORT], wobei [PORT] der Port ist, für den Ihre Messwerte zur Verfügung gestellt werden.
  • stackdriver-prefix=custom.googleapis.com

Die folgende Manifestdatei beschreibt einen Pod mit einer Go-Anwendung, die Messwerte mithilfe der Prometheus-Clientbibliotheken und eines Adaptercontainers zur Verfügung stellt:

apiVersion: v1
kind: Pod
metadata:
  name: custom-metric-prometheus-sd
spec:
  containers:
  - command:
    - /bin/sh
    - -c
    - ./prometheus-dummy-exporter --metric-name=foo --metric-value=40 --port=8080
    image: gcr.io/google-samples/prometheus-dummy-exporter:latest
    imagePullPolicy: Always
    name: prometheus-dummy-exporter
    resources:
      requests:
        cpu: 100m
  - name: prometheus-to-sd
    image: gcr.io/google-containers/prometheus-to-sd:v0.5.0
    command:
    - /monitor
    - --source=:http://localhost:8080
    - --stackdriver-prefix=custom.googleapis.com
    - --pod-id=$(POD_ID)
    - --namespace-id=$(POD_NAMESPACE)
    env:
    - name: POD_ID
      valueFrom:
        fieldRef:
          apiVersion: v1
          fieldPath: metadata.uid
    - name: POD_NAMESPACE
      valueFrom:
        fieldRef:
          fieldPath: metadata.namespace

Schritt 3: HorizontalPodAutoscaler-Objekt erstellen

Nachdem Sie Messwerte zu Stackdriver exportiert haben, können Sie ein HPA-Objekt bereitstellen, um Ihr Deployment auf Basis der Messwerte zu skalieren.

Die folgenden Schritte variieren in Abhängigkeit von der Methode, mit der Sie Messwerte erfasst und exportiert haben.

Auf Basis von Messwerten aus allen Pods automatisch skalieren

Das HPA-Objekt berechnet anhand der Messwerte einen Durchschnitt und vergleicht ihn mit dem Durchschnittszielwert.

Im Beispiel für den Export aus einer Anwendung zu Stackdriver enthält ein Deployment Pods, die Messwerte exportieren. Die folgende Manifestdatei beschreibt ein HorizontalPodAutoscaler-Objekt, das ein Deployment basierend auf dem Durchschnittszielwert für den Messwert skaliert:

apiVersion: autoscaling/v2beta1
kind: HorizontalPodAutoscaler
metadata:
  name: custom-metric-sd
  namespace: default
spec:
  scaleTargetRef:
    apiVersion: apps/v1beta1
    kind: Deployment
    name: custom-metric-sd
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: Pods
    pods:
      metricName: foo
      targetAverageValue: 20

Auf Basis von Messwerten aus einem einzelnen Pod automatisch skalieren

Das HPA-Objekt vergleicht den von einem einzelnen Pod zur Verfügung gestellten Wert direkt mit dem angegebenen Zielwert. Dieser Pod muss nicht an den skalierten Workflow gebunden sein.

Im Beispiel für den Export aus Prometheus zu Stackdriver exportiert ein einzelner Pod die Messwerte. Die folgende Manifestdatei beschreibt ein Deployment und ein HPA-Objekt, das ein Deployment basierend auf dem Zielwert für den Messwert skaliert:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: dummy-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      k8s-app: dummy-deployment
  template:
    metadata:
      labels:
        k8s-app: dummy-deployment
    spec:
      containers:
      - name: long
        image: busybox
        command: ["/bin/sh",  "-c", "sleep 180000000"]
---
apiVersion: autoscaling/v2beta1
kind: HorizontalPodAutoscaler
metadata:
  name: dummy-deployment-hpa
  namespace: default
spec:
  scaleTargetRef:
    apiVersion: apps/v1beta1
    kind: Deployment
    name: dummy-deployment
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: Object
    object:
      target:
        kind: Pod
        name: custom-metric-prometheus-sd
      metricName: foo
      targetValue: 20

Bereinigen

So vermeiden Sie, dass Ihrem Google Cloud Platform-Konto die in dieser Anleitung verwendeten Ressourcen in Rechnung gestellt werden:

Führen Sie den folgenden Befehl aus, um Ihren GKE-Cluster zu löschen:

gcloud container clusters delete [CLUSTER_NAME]

Fehlerbehebung

Wenn im Rahmen dieser Anleitung Probleme auftreten, folgen Sie diesen Schritten zum Debugging:

  1. Führen Sie kubectl api-versions aus und prüfen Sie, ob die custom.metrics.k8s.io/v1beta1 API registriert ist. Wenn die API nicht in der Liste angezeigt wird, sorgen Sie dafür, dass der in Schritt 1 bereitgestellte Adapter für benutzerdefinierte Messwerte im Cluster ausgeführt wird.
  2. Rufen Sie den Metrics Explorer auf und prüfen Sie, ob Ihre benutzerdefinierten Messwerte zu Stackdriver exportiert werden. Suchen Sie dabei nach Messwerten, die mit custom.googleapis.com/[NAME] beginnen. Falls Ihre Messwerte nicht angezeigt werden:

    • Überprüfen Sie, ob das in Schritt 2 bereitgestellte Deployment zum Exportieren ausgeführt wird.
    • Wenn Sie das Dienstkonto Ihrer Knoten mit --service-account angepasst haben, prüfen Sie, ob die Cloud-IAM-Rolle Monitoring-Messwert-Autor (roles/monitoring.metricWriter) zugewiesen wurde.
    • Wenn Sie den Bereich Ihrer Knoten mit --scopes angepasst haben, prüfen Sie, ob die Knoten den Bereich monitoring haben.

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

    1. Wechseln Sie in der Google Cloud Console zu Monitoring oder verwenden Sie die folgende Schaltfläche:
      Zu Monitoring
    2. Klicken Sie im Navigationsbereich von Monitoring auf Metrics Explorer .
    3. Geben Sie den Namen der überwachten Ressource in das Textfeld Ressourcentyp und Messwert finden ein.
  3. Führen Sie kubectl describe hpa [DEPLOYMENT_NAME] aus und überprüfen Sie, ob Ihr benutzerdefinierter Messwert vom HPA gelesen wird. Wenn Fehler angezeigt werden, gehen Sie folgendermaßen vor:

    • Überprüfen Sie, ob das in Schritt 2 bereitgestellte skalierte Deployment ausgeführt wird.
    • Wenn Sie das Dienstkonto Ihrer Knoten mit "--service-account" angepasst haben, prüfen Sie, ob die Cloud-IAM-Rolle Monitoring-Betrachter (roles/monitoring.viewer) zugewiesen ist.

Weitere Informationen