Horizontales Pod-Autoscaling konfigurieren

In diesem Dokument wird beschrieben, wie Sie horizontales Pod-Autoscaling für vorhandene zustandslose Arbeitslasten einrichten, die in Ihrem Cluster ausgeführt werden. Das horizontale Pod-Autoscaling passt die Anzahl der ausgeführten Pods (Replikate) für eine Anwendung automatisch an den Echtzeitbedarf an. Pods werden entfernt, wenn die Last sinkt, und hinzugefügt, wenn die Last steigt. Diese Skalierung ist entscheidend, um die Verfügbarkeit der Anwendung, die effiziente Nutzung von Ressourcen und Kosteneinsparungen zu gewährleisten, indem die Kapazität ohne manuellen Eingriff genau an den Nutzer-Traffic angepasst wird. Wenn sich die Anforderungen an die Containerarbeitslast ändern, müssen Operatoren dank der automatischen Pod-Skalierung die Leistung nicht ständig überwachen und die Anzahl der Pods nicht manuell anpassen.

Diese Seite richtet sich an Administratoren, Architekten und Betreiber, die den Lebenszyklus der zugrunde liegenden technischen Infrastruktur verwalten. Weitere Informationen zu gängigen Rollen und Beispielaufgaben, auf die wir in Google Cloud -Inhalten verweisen, finden Sie unter Häufig verwendete GKE Enterprise-Nutzerrollen und -Aufgaben.

Deployment skalieren

Verwenden Sie die Skalierungsfunktion von Kubernetes, um die Anzahl der in Ihrem Deployment ausgeführten Pods entsprechend zu skalieren.

Pods einer Bereitstellung automatisch skalieren

Kubernetes bietet Autoscaling, sodass Sie Ihre Bereitstellung nicht manuell aktualisieren müssen, wenn sich die Nachfrage ändert. Führen Sie die folgenden Schritte aus, um die Pods Ihres Deployments automatisch zu skalieren:

Damit der horizontale Pod-Autoscaler den CPU-Prozentsatz richtig messen kann, legen Sie die CPU-Ressourcenanforderung für Ihr Deployment fest.
Legen Sie das horizontale Pod-Autoscaling in Ihrem Deployment fest:
```
kubectl --kubeconfig CLUSTER_KUBECONFIG \
    -n NAMESPACE \
    autoscale deployment DEPLOYMENT_NAME \
    --cpu-percent=CPU_PERCENT \
    --min=MIN_NUMBER_REPLICAS \
    --max=MAX_NUMBER_REPLICAS
```
Ersetzen Sie Folgendes:
- CLUSTER_KUBECONFIG: die kubeconfig-Datei für den Cluster.
- NAMESPACE: der Namespace. Bei freigegebenen Clustern muss dies ein Projekt-Namespace sein. Bei Standardclustern kann es sich um einen beliebigen Namespace handeln.
- DEPLOYMENT_NAME: Der Name der Bereitstellung, die automatisch skaliert werden soll.
- CPU_PERCENT: Die durchschnittliche Ziel-CPU-Auslastung, die als Prozentsatz über alle Pods hinweg angefordert werden soll.
- MIN_NUMBER_REPLICAS: Das untere Limit für die Anzahl der Pods, die vom Autoscaling bereitgestellt werden können.
- MAX_NUMBER_REPLICAS: Die Obergrenze für die Anzahl der Pods, die das Autoscaling bereitstellen kann.

Überprüfen Sie den aktuellen Status des horizontalen Pod-Autoscalers:

kubectl get hpa

Die Ausgabe sieht etwa so aus:

NAME              REFERENCE                          TARGET    MINPODS   MAXPODS   REPLICAS   AGE
DEPLOYMENT_NAME   Deployment/DEPLOYMENT_NAME/scale   0% / 50%  1         10        1          18s

Pods eines Deployments manuell skalieren

Wenn Sie ein Deployment lieber manuell skalieren möchten, führen Sie folgenden Befehl aus:

kubectl --kubeconfig CLUSTER_KUBECONFIG \
    -n NAMESPACE \
    scale deployment DEPLOYMENT_NAME \
    --replicas NUMBER_OF_REPLICAS

Ersetzen Sie Folgendes:

CLUSTER_KUBECONFIG: die kubeconfig-Datei für den Cluster.
NAMESPACE: der Namespace. Bei freigegebenen Clustern muss dies ein Projekt-Namespace sein. Bei Standardclustern kann es sich um einen beliebigen Namespace handeln.
DEPLOYMENT_NAME: Der Name der Bereitstellung, in der das Autoscaling erfolgen soll.
DEPLOYMENT_NAME: Die Anzahl der replizierten Pod-Objekte im Deployment.

Benutzerdefinierte Messwerte aus Prometheus für Autoscaling verwenden

Beim horizontalen Pod-Autoscaling werden standardmäßig Ressourcenmesswerte wie CPU- und Arbeitsspeicherauslastung verwendet. Standardmesswerte eignen sich für die allgemeine Skalierung, sind aber für spezielle Anwendungsanforderungen nicht hilfreich.

Wenn Sie horizontales Pod-Autoscaling mit benutzerdefinierten Messwerten aus Prometheus verwenden, können Sie Arbeitslasten anhand von anwendungsspezifischen Messwerten wie HTTP-Anfrageraten, Warteschlangentiefe und Verarbeitungslatenz skalieren. Ihr Cluster kann genauer auf die tatsächliche Nachfrage reagieren, indem er die umfangreichen Daten nutzt, die bereits von Ihrem Prometheus-Monitoring-Stack erfasst wurden.

Voraussetzungen für die Verwendung von Prometheus mit horizontalem Pod-Autoscaling

Bevor Sie die Funktion aktivieren, müssen die folgenden Bedingungen erfüllt sein:

Vorhandener Prometheus-Server: Ein Prometheus-Server muss bereits bereitgestellt sein und über das Netzwerk vom Cluster aus zugänglich sein. Der HPA-Controller verwaltet die Prometheus-Instanz selbst nicht. Weitere Informationen finden Sie unter Prometheus-Operator in Kubernetes bereitstellen und konfigurieren.
Administratorberechtigungen: Sie benötigen die erforderlichen Berechtigungen, um die benutzerdefinierte Clusterressource zu ändern.
Keine API-Konflikte: Bei einer Preflight-Prüfung wird geprüft, ob für custom.metrics.k8s.io bereits ein APIService von einer anderen Komponente registriert wurde. Wenn ein Konflikt vorliegt, kann der Adapter nicht aktiviert werden.

Prometheus aktivieren und konfigurieren

Dazu müssen Sie Messwertregeln definieren und die Clusterkonfiguration aktualisieren:

Erstellen Sie eine oder mehrere ConfigMaps für Messregel.

Definieren Sie die PromQL-basierten Regeln für Ihre benutzerdefinierten Messwerte in einer oder mehreren ConfigMaps im Namespace des Zielclusters. Der Controller überwacht diese ConfigMaps, führt sie zusammen und wendet sie automatisch auf den Adapter an.

Weitere Informationen zum Definieren von Regeln finden Sie unter Metrics Discovery and Presentation Configuration in kubernetes-sigs/prometheus-adapter.

Das folgende Beispiel zeigt eine ConfigMap mit Regeln, die für http_requests_per_second im Feld data definiert sind:
```
apiVersion: v1
kind: ConfigMap
metadata:
  name: my-app-rules
  namespace: <cluster-namespace>
data:
  config.yaml: |
    rules:
    - seriesQuery: 'http_requests_total'
      resources:
        overrides:
          namespace_name: {resource: "namespace"}
          pod_name: {resource: "pod"}
      name:
        matches: "^(.*)_total$"
        as: "${1}_per_second"
      metricsQuery: 'sum(rate(<<.Series>>{<<.LabelMatchers>>}[5m])) by (<<.GroupBy>>)'
```
Wenn für Ihren Prometheus-Server eine Authentifizierung erforderlich ist, z. B. gegenseitige Transport Layer Security (mTLS), erstellen Sie ein Kubernetes-Secret im kubeconfig-Format, das die erforderlichen Anmeldedaten enthält.

Das folgende Beispiel zeigt ein Secret, das die Basisauthentifizierung unterstützt:
```
apiVersion: v1
kind: Secret
metadata:
  name: prometheus-auth-secret
  namespace: <cluster-namespace>
  annotations:
    baremetal.cluster.gke.io/mark-source: "true"
type: Opaque
stringData:
  config: authentication-credentials
```

Aktualisieren Sie die benutzerdefinierte Clusterressource:

Fügen Sie der benutzerdefinierten Clusterressource die Annotation preview.baremetal.cluster.gke.io/metrics-adapter: "true" für metadata hinzu.

Fügen Sie den Abschnitt spec.metricsAdapter hinzu, um die Prometheus-URL zu definieren und auf Ihre Regel-ConfigMaps zu verweisen.

apiVersion: baremetal.cluster.gke.io/v1
kind: Cluster
metadata:
  name: <cluster-name>
  namespace: <cluster-namespace>
  annotations:
    preview.baremetal.cluster.gke.io/metrics-adapter: "true"
spec:
  # ... other existing cluster configurations ...
  metricsAdapter:
    prometheus:
      url: "http://prometheus-k8s.monitoring.svc.cluster.local:9090"
      orgID: "production-environment"
      auth:
        configSecretRef:
          name: prometheus-auth-secret
          key: config # This is the key within the Secret's 'data' field
    rules:
      configMapKeyRefs:
        - name: my-app-rules
          key: config.yaml # This is the key within the ConfigMap's 'data' field
        # - name: base-system-rules
        #   key: config.yaml

Wenn für Ihre Prometheus-Instanz keine Authentifizierung erforderlich ist, können Sie den Abschnitt metricsAdapter.prometheus.auth aus der Clusterspezifikation weglassen.

Wenden Sie die aktualisierte benutzerdefinierte Clusterressource an.

Der Controller stellt den Prometheus-Adapter automatisch im Namespace kube-system bereit.

Verwenden Sie die benutzerdefinierten Messwerte für das horizontale Pod-Autoscaling, indem Sie eine HorizontalPodAutoscaler-Ressource erstellen, die auf die benutzerdefinierten Messwerte in den Feldern rules der ConfigMaps ausgerichtet ist.

Im ConfigMap-Beispiel aus einem früheren Schritt wurde der benutzerdefinierte Messwert http_requests_per_second definiert. Damit Sie diesen Messwert verwenden können, sollte die HorizontalPodAutoscaler-Ressource in etwa so aussehen:

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: <name>
  namespace: <namespace>
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: <workload-name>
  minReplicas: 1
  maxReplicas: 10
  metrics:
  - type: Pods
    pods:
      metric:
        name: http_requests_per_second
      target:
        type: AverageValue
        averageValue: 10

Prometheus deaktivieren

Wenn Sie die Verwendung von Prometheus mit horizontalem Pod-Autoscaling deaktivieren möchten, entfernen Sie den Abschnitt spec.metricsAdapter aus der benutzerdefinierten Clusterressource.

Horizontales Pod-Autoscaling konfigurieren Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.