Kubernetes Horizontal Pod Autoscaler verwenden

Erfahren Sie, wie Sie mit Kubernetes Horizontal Pod Autoscaler die Anzahl der Pods in einem Cluster, das Sie mit der Kubernetes Engine (OKE) erstellt haben, automatisch skalieren.

Mit Kubernetes Horizontal Pod Autoscaler können Sie die Anzahl der Pods in einem Deployment, Replikationscontroller, Replikatset oder zustandsbehafteten Set je nach der CPU- oder Speicherauslastung dieser Ressource oder anderen Metriken automatisch skalieren. Mit Horizontal Pod Autoscaler können Sie Anwendungen horizontal skalieren, um erhöhte Anforderungen zu erfüllen, oder herunterskalieren, wenn Ressourcen nicht mehr benötigt werden. Sie können einen Zielprozentsatz festlegen, den Horizontal Pod Autoscaler bei der Skalierung von Anwendungen erreichen soll. Weitere Informationen finden Sie unter Horizontal Pod Autoscaler in der Kubernetes-Dokumentation.

Horizontal Pod Autoscaler ist eine API-Standardressource in Kubernetes, für die die Installation einer Metrikquelle (z.B. Kubernetes-Metrikserver) im Cluster erforderlich ist. Weitere Informationen finden Sie unter Kubernetes-Metrikserver auf einem Cluster bereitstellen.

Hinweise zu Horizontal Pod Autoscaler

Beachten Sie Folgendes:

Der Kubernetes-Metrikserver unterstützt nur eine Skalierung basierend auf CPU- und Speicherauslastung. Andere Implementierungen der Kubernetes-Metrik-API unterstützen die Skalierung basierend auf benutzerdefinierten Metriken. In der Kubernetes-Dokumentation finden Sie eine Liste alternativer Implementierungen (siehe Implementierungen) sowie weitere Informationen zur Skalierung basierend auf benutzerdefinierten Metriken (siehe Autoscaling für mehrere Metriken und benutzerdefinierte Metriken).
Sie können Anwendungen manuell skalieren, indem Sie Manifestdateien aktualisieren, ohne Horizontal Pod Autoscaler zu verwenden.
Sie können Kubernetes Horizontal Pod Autoscaler sowohl mit verwalteten Knotenpools als auch mit virtuellen Knotenpools verwenden.

Mit Horizontal Pod Autoscaler arbeiten

Die nachfolgenden Anweisungen basieren auf dem Thema Horizontal Pod Autoscaler - Walkthrough in der Kubernetes-Dokumentation. Sie beschreiben folgende Aufgaben:

Prüfen, ob der Kubernetes-Metrikserver auf einem Cluster installiert wurde.
Php-apache-Beispielwebserver bereitstellen.
Horizontal Pod Autoscaler-Ressource erstellen, die basierend auf der CPU-Auslastung skaliert wird.
Generierung einer Beispiellast starten.
Skalierungsvorgang in Aktion anzeigen.
Beispiellastgenerierung stoppen.
Bereinigung durchführen, indem der php-apache-Webserver und Horizontal Pod Autoscaler entfernt werden.

Schritt 1: Installation des Kubernetes-Metrikservers prüfen

Falls noch nicht geschehen, führen Sie die Schritte zum Einrichten der kubeconfig-Konfigurationsdatei des Clusters aus, und legen Sie (gegebenenfalls) die Umgebungsvariable KUBECONFIG so fest, dass sie auf die Datei verweist. Beachten Sie, dass Sie Ihre eigene kubeconfig-Datei einrichten müssen. Sie können nicht mit einer kubeconfig-Datei, die von einem anderen Benutzer eingerichtet wurde, auf ein Cluster zugreifen. Siehe Clusterzugriff einrichten.
Stellen Sie sicher, dass der Kubernetes-Metrikserver erfolgreich auf dem Cluster bereitgestellt wurde und verfügbar ist, indem Sie Folgendes eingeben:
```
kubectl -n kube-system get deployment/metrics-server
```
Wenn der Befehl einen Fehler "Nicht gefunden" zurückgibt, müssen Sie den Kubernetes-Metrikserver auf dem Cluster bereitstellen, bevor Sie fortfahren. Siehe Kubernetes-Metrikserver auf einem Cluster bereitstellen.

Schritt 2: Beispielanwendung bereitstellen

Stellen Sie eine einfache Apache-Webserveranwendung bereit, indem Sie Folgendes eingeben:

kubectl apply -f https://k8s.io/examples/application/php-apache.yaml

In der Ausgabe des obigen Befehls wird das Deployment bestätigt:

deployment.apps/php-apache created
service/php-apache created

Der Apache-Webserverpod, der aus der Manifestdatei erstellt wird:

hat einen CPU-Grenzwert von 500 m, das heißt, dass der Container niemals mehr als 500 Millicore oder 1/2 Core verwendet.
hat eine CPU-Anforderungszuteilung von 200 m, das heißt, dass der Container 200 Millicore an CPU-Ressourcen oder 1/5 Core verwenden darf.

Schritt 3: Horizontal Pod Autoscaler-Ressource erstellen

Erstellen Sie eine Horizontal Pod Autoscaler-Ressource mit mindestens 1 und maximal 10 Replikaten und einer durchschnittlichen CPU-Auslastung von 50 %, indem Sie Folgendes eingeben:
```
kubectl autoscale deployment php-apache --cpu-percent=50 --min=1 --max=10
```
Die Ausgabe des obigen Befehls bestätigt, dass der Horizontal Pod Autoscaler erstellt wurde.
```
horizontalpodautoscaler.autoscaling/php-apache autoscaled
```
Der Befehl erstellt einen Horizontal Pod Autoscaler für das Apache-Webserver-Deployment, der:
- die Anzahl der Replikate der zuvor erstellten Pods, die vom Apache-Webserver-Deployment gesteuert werden, auf 1 bis 10 begrenzt.
- die Anzahl der Replikate des Deployments erhöht und verringert, um eine durchschnittliche CPU-Auslastung von 50 % in allen Pods zu erhalten.
Wenn die durchschnittliche CPU-Auslastung unter 50 % liegt, versucht Horizontal Pod Autoscaler, die Anzahl der Pods im Deployment auf das Minimum zu reduzieren (in diesem Fall 1). Wenn die durchschnittliche CPU-Auslastung über 50 % liegt, versucht Horizontal Pod Autoscaler, die Anzahl der Pods im Deployment auf das Maximum zu erhöhen (in diesem Fall 10). Weitere Informationen finden Sie unter Wie funktioniert der Horizontal Pod Autoscaler? in der Kubernetes-Dokumentation.

Weitere Informationen zum Befehl kubectl autoscale finden Sie unter autoscale in der Kubernetes-Dokumentation.
Nach einer Minute können Sie den aktuellen Status von Horizontal Pod Autoscaler prüfen, indem Sie Folgendes eingeben:
```
kubectl get hpa
```
Die Ausgabe des obigen Befehls zeigt den aktuellen Status an:
```
NAME       REFERENCE             TARGETS MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache 0%/50%  1       10      1        10s
```
In der Spalte TARGETS wird die durchschnittliche CPU-Auslastung in allen Pods angezeigt, die vom Apache-Webserver-Deployment gesteuert werden. Da keine Anforderungen an den Server gesendet werden, zeigt das obige Beispiel eine aktuelle CPU-Auslastung von 0 % an, verglichen mit einer Zielauslastung von 50 %. Möglicherweise werden bei Ihnen andere Zahlen angezeigt. Das hängt davon ab, wie lange Sie warten, bevor Sie den Befehl ausführen.

Schritt 4: Beispiellastgenerierung starten

Führen Sie einen Container mit einem Busybox-Image aus, um eine Last für den Apache-Webserver zu erstellen, indem Sie Folgendes eingeben:
```
kubectl run -it --rm load-generator --image=busybox /bin/sh
```
Generieren Sie eine Last für den Apache-Webserver, die dazu führt, dass der Horizontal Pod Autoscaler das Deployment horizontal skaliert, indem Sie Folgendes eingeben:
```
while true; do wget -q -O- http://php-apache; done
```

Schritt 5: Skalierungsvorgang anzeigen

Öffnen Sie nach einer Minute ein neues Terminalfenster, und prüfen Sie den aktuellen Status des Horizontal Pod Autoscalers, indem Sie Folgendes eingeben:
```
kubectl get hpa
```
Die Ausgabe des obigen Befehls zeigt den aktuellen Status an:
```
NAME       REFERENCE             TARGETS  MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache 250%/50% 1       10      1        1m
```
Im obigen Beispiel sehen Sie, dass die aktuelle CPU-Auslastung auf 250 % gestiegen ist, verglichen mit einer Zielauslastung von 50 %. Möglicherweise werden bei Ihnen andere Zahlen angezeigt. Das hängt davon ab, wie lange Sie warten, bevor Sie den Befehl ausführen.

Um das Auslastungsziel von 50 % zu erreichen, muss Horizontal Pod Autoscaler die Anzahl der Replikate erhöhen, um das Deployment horizontal zu skalieren.
Nach einigen Minuten können Sie die erhöhte Anzahl von Replikaten anzeigen, indem Sie Folgendes erneut eingeben:
```
kubectl get hpa
```
Die Ausgabe des obigen Befehls zeigt den aktuellen Status an:
```
NAME       REFERENCE             TARGETS  MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache 50%/50%  1       10      5        5m
```
Im obigen Beispiel sehen Sie, dass Horizontal Pod Autoscaler das Deployment auf 5 Replikate skaliert hat und das Auslastungsziel von 50 % erreicht wurde. Möglicherweise werden bei Ihnen andere Zahlen angezeigt. Das hängt davon ab, wie lange Sie warten, bevor Sie den Befehl ausführen.
Prüfen Sie, ob das Deployment horizontal skaliert wurde, indem Sie Folgendes eingeben:
```
kubectl get deployment php-apache
```
Die Ausgabe des obigen Befehls zeigt den aktuellen Status an:
```
NAME       READY UP-TO-DATE AVAILABLE AGE
php-apache 5/5   5          5         5m
```
Möglicherweise werden bei Ihnen andere Zahlen angezeigt. Das hängt davon ab, wie lange Sie warten, bevor Sie den Befehl ausführen.

Schritt 6: Beispiellastgenerierung stoppen

Führen Sie in dem Terminalfenster, in dem Sie den Container mit dem Busybox-Image erstellt und die Last für den Apache-Webserver generiert haben, die folgenden Schritte aus:
1. Beenden Sie die Lastgenerierung, indem Sie Ctrl+C drücken.
2. Schließen Sie die Eingabeaufforderung, indem Sie Folgendes eingeben:
```
exit
```
  Die Ausgabe des obigen Befehls bestätigt, dass die Session beendet wurde:
```
Session ended, resume using 'kubectl attach load-generator -c load-generator -i -t' command when the pod is running
pod "load-generator" deleted
```
Nach einer Minute können Sie den aktuellen Status von Horizontal Pod Autoscaler prüfen, indem Sie Folgendes eingeben:
```
kubectl get hpa
```
Die Ausgabe des obigen Befehls zeigt den aktuellen Status an:
```
NAME       REFERENCE             TARGETS MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache 0%/50%  1       10      5        10m
```
Im obigen Beispiel sehen Sie, dass die aktuelle CPU-Auslastung auf 0 % reduziert wurde, verglichen mit einer Zielauslastung von 50 %. Es sind jedoch immer noch 5 Replikate im Deployment vorhanden. Möglicherweise werden bei Ihnen andere Zahlen angezeigt. Das hängt davon ab, wie lange Sie warten, bevor Sie den Befehl ausführen.
Nach einigen Minuten können Sie die reduzierte Anzahl von Replikaten anzeigen, indem Sie Folgendes erneut eingeben:
```
kubectl get hpa
```
Die Ausgabe des obigen Befehls zeigt den aktuellen Status an:
```
NAME       REFERENCE             TARGETS  MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache 0%/50%   1       10      1        15m
```
Im obigen Beispiel sehen Sie, dass Horizontal Pod Autoscaler das Deployment auf 1 Replikat skaliert hat.

Beachten Sie, dass es eine gewisse Zeit dauert, bis die Anzahl der Replikate auf 1 reduziert wurde. Der Standardzeitrahmen für eine vertikale Skalierung beträgt fünf Minuten. Möglicherweise werden bei Ihnen andere Zahlen angezeigt. Das hängt davon ab, wie lange Sie warten, bevor Sie den Befehl ausführen.
Prüfen Sie, ob das Deployment skaliert wurde, indem Sie Folgendes eingeben:
```
kubectl get deployment php-apache
```
Die Ausgabe des obigen Befehls zeigt den aktuellen Status an:
```
NAME       READY UP-TO-DATE AVAILABLE AGE
php-apache 1/1   1          1         15m
```
Möglicherweise werden bei Ihnen andere Zahlen angezeigt. Das hängt davon ab, wie lange Sie warten, bevor Sie den Befehl ausführen.

Schritt 7: Bereinigung durchführen

Löschen Sie Horizontal Pod Autoscaler, indem Sie Folgendes eingeben:
```
kubectl delete horizontalpodautoscaler.autoscaling/php-apache
```
Hinweis: Wenn Sie Horizontal Pod Autoscaler löschen, bleibt die Anzahl der Replikate gleich. Ein Deployment wird nicht automatisch auf den Status vor Erstellung des Horizontal Pod Autoscalers zurückgesetzt.
Löschen Sie das Apache-Webserver-Deployment, indem Sie Folgendes eingeben:
```
kubectl delete deployment.apps/php-apache service/php-apache
```

Oracle Cloud Infrastructure - Dokumentation