Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Horizontales Pod-Autoscaling konfigurieren

Mit dem horizontalen Pod-Autoscaling können Sie die Anzahl der ausgeführten Pods für vorhandene zustandslose Arbeitslasten in Ihrem Cluster automatisch an den Echtzeitbedarf anpassen. Der Autoscaler fügt Pods hinzu, wenn die Last steigt, und entfernt sie, wenn die Nachfrage sinkt. So können Sie die Anwendungsverfügbarkeit aufrechterhalten, Ressourcen effizient nutzen und Kosten ohne manuelles Eingreifen kontrollieren. Sie können die Skalierung anhand von Standardressourcenmesswerten wie der CPU-Auslastung oder anhand von benutzerdefinierten Anwendungsmesswerten aus Prometheus wie HTTP-Anfrageraten vornehmen.

Deployment skalieren

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

Pods eines Deployments automatisch skalieren

Kubernetes bietet Autoscaling, sodass Sie Ihr Deployment nicht manuell aktualisieren müssen, wenn sich die Anforderungen ändern. Führen Sie die folgenden Schritte aus, um die Pods Ihres Deployments automatisch zu skalieren:

Damit das horizontale Pod-Autoscaling den CPU-Prozentsatz richtig messen kann, legen Sie die CPU-Ressourcenanfrage 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 anzufordernde durchschnittliche CPU-Zielauslastung in Prozent über alle Pods hinweg.
- MIN_NUMBER_REPLICAS: die Untergrenze für die Anzahl der Pods, die das Autoscaling bereitstellen kann.
- MAX_NUMBER_REPLICAS: die Obergrenze für die Anzahl der Pods, die das Autoscaling bereitstellen kann.

Prü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 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 des Deployments, in dem das Autoscaling erfolgen soll.
DEPLOYMENT_NAME: Die Anzahl der replizierten Pod-Objekte im Deployment.

Benutzerdefinierte Messwerte von Prometheus für das Autoscaling verwenden

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

Wenn Sie horizontales Pod-Autoscaling mit benutzerdefinierten Messwerten von Prometheus verwenden, können Sie Arbeitslasten anhand anwendungsspezifischer Messwerte 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 und über das Netzwerk innerhalb des Clusters zugänglich sein. Der HPA-Controller verwaltet die Prometheus-Instanz nicht selbst. Weitere Informationen finden Sie unter Prometheus Operator in Kubernetes bereitstellen und konfigurieren.
Administratorberechtigungen: Sie müssen die erforderlichen Berechtigungen haben, um die benutzerdefinierte Cluster-Ressource zu ändern.
Keine API-Konflikte: Bei einer Preflight-Prüfung wird geprüft, ob bereits eine andere Komponente einen APIService für custom.metrics.k8s.io registriert hat. Wenn ein Konflikt vorliegt, kann der Adapter nicht aktiviert werden.

Prometheus aktivieren und konfigurieren

Dazu müssen Messwertregeln definiert und die Clusterkonfiguration aktualisiert werden:

Erstellen Sie eine oder mehrere ConfigMaps für Messwertregeln.

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 Konfiguration der Messwerterkennung und -präsentation 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 Ihr Prometheus-Server eine Authentifizierung erfordert, 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 Cluster-Ressource:

Fügen Sie der metadata für die benutzerdefinierte Clusterressource die Annotation preview.baremetal.cluster.gke.io/metrics-adapter: "true" 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 Ihre Prometheus-Instanz keine Authentifizierung erfordert, 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 abzielt, die in den rules-Feldern der ConfigMaps definiert sind.

Im ConfigMap-Beispiel aus einem früheren Schritt wurde der benutzerdefinierte Messwert http_requests_per_second definiert. Wenn Sie diesen Messwert verwenden möchten, 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 Cluster-Ressource.

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