Bereitstellungen mit GKE-Arbeitslastmesswerten automatisch skalieren

In dieser Anleitung wird gezeigt, wie Sie Ihre GKE-Arbeitslasten in Google Kubernetes Engine automatisch basierend auf benutzerdefinierten Messwerten skalieren, die von Ihrer Anwendung ausgegeben werden (z. B. die Anzahl der aktiv angemeldeten Konten oder die Anzahl der HTTP-Anfragen).

Sie erfassen mit der GKE-Pipeline für Arbeitslastmesswerte Messwerte, die von Ihrer Anwendung ausgegeben werden, senden sie an Cloud Monitoring und verwenden sie dann für das horizontale Pod-Autoscaling (HPA).

Ziele

In dieser Anleitung werden die folgenden Aufgaben behandelt:

  1. Eine Beispielanwendung bereitstellen, die Messwerte im Prometheus-Stil ausgibt
  2. PodMonitor-Ressource bereitstellen, um die Messwerte durch Scraping aus Ihrer Anwendung zu extrahieren und in Cloud Monitoring zu veröffentlichen.
  3. Adapter für benutzerdefinierte Messwerte bereitstellen
  4. Arbeitslastmesswerte mit der Kubernetes Custom Metrics API abfragen
  5. HPA-Ressource (horizontales Pod-Autoscaling) bereitstellen, um Ihre Anwendung basierend auf den durch Scraping aus Ihrer Anwendung extrahierten Arbeitslastmesswerten zu skalieren

Hinweis

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.

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. Gehen Sie zur Google Cloud Console.
  2. Klicken Sie im oberen Bereich des Cloud Console-Fensters auf Cloud Shell aktivieren Schaltfläche zum Aktivieren von Cloud Shell.

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

    Cloud Shell-Sitzung

Umgebung einrichten

  1. Erstellen Sie mit dem folgenden Befehl einen neuen Cluster mit aktivierten Arbeitslastmesswerten:

    gcloud beta container clusters create CLUSTER_NAME \
        --project=PROJECT_ID \
        --zone=ZONE \
        --monitoring=SYSTEM,WORKLOAD
    

    Dabei gilt:

    • CLUSTER_NAME ist der Name Ihres Clusters.
    • PROJECT_ID ist die ID Ihres Google Cloud-Projekts.
    • ZONE: Wählen Sie eine Zone aus, die geografisch möglichst nahe bei Ihnen liegt.

    Für diese Aktion ist die Berechtigung container.clusters.create für das Projekt erforderlich.

  2. Ändern Sie den Cluster mit dem folgenden Befehl, um Arbeitslastmesswerte für einen vorhandenen Standard- oder Autopilot-Cluster zu aktivieren:

    gcloud beta container clusters update CLUSTER_NAME \
        --project=PROJECT_ID \
        --zone=ZONE \
        --monitoring=SYSTEM,WORKLOAD
    

Beispielanwendung bereitstellen, die Messwerte im Prometheus-Stil ausgibt

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

  git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples.git
  cd kubernetes-engine-samples/workload-metrics

Die Beispielanwendung für diese Anleitung generiert zwei Messwerte und stellt sie über einen integrierten Prometheus-Endpunkt unter localhost:1234/metrics bereit:

  • example_requests_total: ein Zähler für die von der Anwendung generierten Anfragen
  • example_random_numbers: ein Histogramm von zufällig generierten Zahlen

Das Repository enthält ein Kubernetes-Manifest für die Bereitstellung der Anwendung in Ihrem Cluster:

# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    app: workload-metrics
  name: workload-metrics
  namespace: gke-workload-metrics
spec:
  selector:
    matchLabels:
      app: workload-metrics
  template:
    metadata:
      labels:
        app: workload-metrics
    spec:
      containers:
      - image: us-docker.pkg.dev/google-samples/containers/workload-metrics:1.0
        imagePullPolicy: Always
        name: workload-metrics
        ports:
        - name: metrics-port
          containerPort: 1234
        command:
        - "/workload-metrics"
        - "--process-metrics"
        - "--go-metrics"
Stellen Sie die Anwendung in Ihrem Cluster bereit:

  kubectl create namespace gke-workload-metrics
  kubectl apply -f manifests/workload-metrics-deployment.yaml

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

  kubectl -n gke-workload-metrics get pods

Ausgabe:

  NAME                                READY   STATUS    RESTARTS   AGE
  workload-metrics-74fb6c56df-9djq7   1/1     Running   0          1m

PodMonitor-Ressource bereitstellen, um die Messwerte durch Scraping aus der Beispielanwendung zu extrahieren

Zum Erfassen der aus der Beispielanwendung ausgegebenen Messwerte müssen Sie eine benutzerdefinierte PodMonitor-Ressource erstellen.

Das Repository enthält ein Kubernetes-Manifest zum Bereitstellen von PodMonitor in Ihrem Cluster:

# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# Note that this PodMonitor is in the monitoring.gke.io domain,
# rather than the monitoring.coreos.com domain used with the
# Prometheus Operator
apiVersion: monitoring.gke.io/v1alpha1
kind: PodMonitor
metadata:
  name: workload-metrics-podmon
# spec describes how to monitor a set of pods in a cluster.
spec:
  # namespaceSelector determines which namespace is searched for pods. Required
  namespaceSelector:
    matchNames:
    - gke-workload-metrics
  # selector determines which pods are monitored.  Required
  # This example matches pods with the `app: workload-metrics-example` label
  selector:
    matchLabels:
      app: workload-metrics
  podMetricsEndpoints:
    # port is the name of the port of the container to be scraped.
  - port: metrics-port
    # path is the path of the endpoint to be scraped.
    # Default /metrics
    path: /metrics
    # scheme is the scheme of the endpoint to be scraped.
    # Default http
    scheme: http
    # interval is the time interval at which metrics should
    # be scraped. Default 60s
    interval: 20s
Stellen Sie den PodMonitor in Ihrem Cluster bereit:

  kubectl apply -f manifests/workload-metrics-podmon.yaml

Adapter für benutzerdefinierte Messwerte bereitstellen

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

  1. 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)"
    
  2. Wenn Sie einen Autopilot-Cluster oder einen Cluster mit aktivierter Workload Identity verwenden, gehen Sie so vor:

    1. Erstellen Sie einen Namespace für den Adapter:

      kubectl create namespace custom-metrics
      
    2. Erstellen Sie ein Kubernetes-Dienstkonto für den Adapter:

      kubectl create serviceaccount --namespace custom-metrics \
      custom-metrics-stackdriver-adapter
      
    3. Erstellen Sie ein Google-Dienstkonto mit der Berechtigung zum Aufrufen von Monitoring-Messwerten:

      gcloud iam service-accounts create GSA_NAME
      
      gcloud projects add-iam-policy-binding PROJECT_ID \
          --member "serviceAccount:GSA_NAME@PROJECT_ID.iam.gserviceaccount.com" \
          --role "roles/monitoring.viewer"
      

      Dabei gilt:

      • PROJECT_ID ist Ihre Google Cloud-Projekt-ID.
      • GSA_NAME: der Name Ihres Google-Dienstkontos
    4. Erlauben Sie dem Kubernetes-Dienstkonto, die Identität des Google-Dienstkontos zu übernehmen. Erstellen Sie dazu eine IAM-Richtlinienbindung:

      gcloud iam service-accounts add-iam-policy-binding \
        --role roles/iam.workloadIdentityUser \
        --member "serviceAccount:PROJECT_ID.svc.id.goog[custom-metrics/custom-metrics-stackdriver-adapter]" \
        GSA_NAME@PROJECT_ID.iam.gserviceaccount.com
      
    5. Annotieren Sie das Kubernetes-Dienstkonto, um die Bindung anzugeben:

      kubectl annotate serviceaccount \
        --namespace custom-metrics custom-metrics-stackdriver-adapter \
        iam.gke.io/gcp-service-account=GSA_NAME@PROJECT_ID.iam.gserviceaccount.com
      
  3. Stellen Sie für Ihren Cluster den Adapter für das neue Ressourcenmodell bereit:

    kubectl apply -f manifests/adapter_new_resource_model.yaml
    
  4. Prüfen Sie, ob der Adapter für benutzerdefinierte Messwerte bereitgestellt wurde und sich im Status Ready befindet:

    kubectl -n custom-metrics get pods
    

    Ausgabe:

    NAME                                                 READY   STATUS    RESTARTS   AGE
    custom-metrics-stackdriver-adapter-6d4fc94699-zqndq  1/1     Running   0          2m
    

Arbeitslastmesswerte mithilfe der Kubernetes Custom Metrics API abfragen

Mit der Kubernetes Custom Metrics API können Sie prüfen, ob Ihre Arbeitslastmesswerte für GKE sichtbar sind.

GKE-Arbeitslastmesswerte werden mit dem Präfix workload.googleapis.com nach Monitoring exportiert. Der Kubernetes Custom Metrics API-Server für unterstützt in Messwertpfaden nicht das Zeichen /. Daher müssen Sie alle /-Zeichen durch | ersetzen. Darum müssen Sie workload.googleapis.com|example_request_total als Messwertnamen verwenden.

Warten Sie einen Moment, bis die Anwendungsmesswerte an Monitoring gesendet wurden. Führen Sie den folgenden Befehl aus, um den Messwert workload.googleapis.com|example_request_total abzufragen:

   kubectl get --raw  \
   "/apis/custom.metrics.k8s.io/v1beta2/namespaces/gke-workload-metrics/pods/*/workload.googleapis.com|example_requests_total"

Ausgabe:

  {"kind":"MetricValueList","apiVersion":"custom.metrics.k8s.io/v1beta2",
  "metadata":{"selfLink":"/apis/custom.metrics.k8s.io/v1beta2/namespaces/
  gke-workload-metrics/pods/%2A/workload.googleapis.com%7Cexample_requests_total"},
  "items":[{"describedObject":{"kind":"Pod","namespace":"gke-workload-metrics",
  "name":"prom-example-74fb6c56df-9djq7","apiVersion":"/__internal"},"metric":
  {"name":"workload.googleapis.com|example_requests_total","selector":null},"timestamp ":
  "2021-08-23T10:48:45Z","value":"1199m"}]}

HorizontalPodAutoscaler-Objekt bereitstellen

Sobald Sie im vorherigen Schritt den Messwert workload.googleapis.com|example_requests_total in der Antwortnutzlast der Custom Metrics API sehen, können Sie ein horizontales Pod-Autoscaling (HPA) bereitstellen, um die Größe Ihrer Bereitstellung basierend auf diesem Messwert anzupassen.

Das Repository enthält ein Kubernetes-Manifest zur Bereitstellung des HPA in Ihrem Cluster:

# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
apiVersion: autoscaling/v2beta2
kind: HorizontalPodAutoscaler
metadata:
  name: workload-metrics-hpa
  namespace: gke-workload-metrics
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: workload-metrics
  minReplicas: 1
  maxReplicas: 5
  metrics:
  - type: Pods
    pods:
      metric:
        name: workload.googleapis.com|example_requests_total
      target:
        type: AverageValue
        averageValue: 1
In diesem HPA wird die Mindestanzahl der Pod-Replikate auf 1 und das Maximum auf 5 festgelegt. Es skaliert Ihre Bereitstellung, damit der durchschnittliche Wert von workload.googleapis.com|example_request_total in allen Pods 1 ist.

Stellen Sie den HorizontalPodAutoscaler in Ihrem Cluster bereit:

  kubectl apply -f manifests/workload-metrics-hpa.yaml

Hochskalieren von HorizontalPodAutoscaler beobachten

Mit dem folgenden Befehl können Sie die Anzahl der Replikate in Ihrer Bereitstellung regelmäßig prüfen und beobachten, wie sie auf 5 Replikate skaliert werden:

  kubectl -n gke-workload-metrics get pods

Ausgabe:

  NAME                                READY   STATUS    RESTARTS   AGE
  workload-metrics-74fb6c56df-9djq7   1/1     Running   0          5m
  workload-metrics-74fb6c56df-frzbv   1/1     Running   0          7m
  workload-metrics-74fb6c56df-h26rw   1/1     Running   0          8m
  workload-metrics-74fb6c56df-kwvx9   1/1     Running   0          10m
  workload-metrics-74fb6c56df-vvtnn   1/1     Running   0          11m

Sie können auch den Status und die Aktivität des horizontalen Pod-Autoscaling mit dem folgenden Befehl prüfen:

  kubectl -n gke-workload-metrics describe hpa workload-metrics-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.

Nächste Schritte