**Unterstützung für die Verbesserung dieser Seite beitragen**
Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
Um zu diesem Benutzerhandbuch beizutragen, wählen Sie den GitHub Link **Diese Seite bearbeiten auf**, der sich im rechten Bereich jeder Seite befindet.
Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Skalierung von Pod-Bereitstellungen mit Horizontal Pod Autoscaler
Der [Horizontal Pod Autoscaler](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/) von Kubernetes skaliert automatisch die Anzahl der Pods in einer Bereitstellung, einem Replikations-Controller oder einem Replikatsatz basierend auf der CPU-Auslastung dieser Ressource. Auf diese Weise können Ihre Anwendungen aufskalieren, um den erhöhten Bedarf zu erfüllen, oder abskalieren, wenn Ressourcen nicht benötigt werden, sodass Ihre Knoten für andere Anwendungen freigegeben werden. Wenn Sie einen CPU-Auslastungsprozentsatz festlegen, skaliert der Horizontal Pod Autoscaler Ihre Anwendung in beide Richtungen, um zu versuchen, dieses Ziel zu erreichen.
Der Horizontal Pod Autoscaler ist eine Standard-API-Ressource in Kubernetes, die einfach erfordert, dass eine Metrikquelle (z. B. der Kubernetes-Metrikserver) auf Ihrem Amazon-EKS-Cluster installiert ist. Sie müssen den Horizontal Pod Autoscaler nicht auf Ihrem Cluster bereitstellen oder installieren, um mit der Skalierung Ihrer Anwendungen zu beginnen. Weitere Informationen finden Sie unter [Horizontal Pod Autoscaler](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/) in der Kubernetes-Dokumentation.
Verwenden Sie dieses Thema, um den Horizontal Pod Autoscaler für Ihren Amazon-EKS-Cluster vorzubereiten und zu überprüfen, ob er mit einer Beispielanwendung funktioniert.
**Anmerkung**
Dieses Thema basiert auf der [Anleitung zum Horizontal Pod Autoscaler](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale-walkthrough/) in der Kubernetes-Dokumentation.
+ Sie haben einen vorhandenen Amazon-EKS-Cluster. Falls nicht, finden Sie weitere Informationen unter [Erste Schritte mit Amazon EKS](getting-started.md).
+ Sie haben den Kubernetes-Metrik-Server installiert. Weitere Informationen finden Sie unter [Anzeigen der Ressourcennutzung mit Kubernetes Metrics Server](metrics-server.md).
+ Sie verwenden einen `kubectl`-Client, der [für die Kommunikation mit Ihrem Amazon EKS-Cluster konfiguriert](getting-started-console.md#eks-configure-kubectl) ist.
## Ausführen einer Horizontal Pod Autoscaler-Testanwendung
In diesem Abschnitt stellen Sie eine Beispielanwendung bereit, um zu überprüfen, ob der Horizontal Pod Autoscaler funktioniert.
**Anmerkung**
Dieses Beispiel basiert auf der [Anleitung zum Horizontal Pod Autoscaler](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale-walkthrough/) in der Kubernetes-Dokumentation.
1. Stellen Sie mit dem folgenden Befehl eine einfache Apache-Webserveranwendung bereit.
```
kubectl apply -f https://k8s.io/examples/application/php-apache.yaml
```
Dieser Apache-Webserver-Pod verfügt über eine CPU-Begrenzung von 500 Millicpu und ist auf Port 80 erreichbar.
1. Erstellen Sie eine Horizontal Pod Autoscaler-Ressource für die `php-apache`-Bereitstellung.
```
kubectl autoscale deployment php-apache --cpu-percent=50 --min=1 --max=10
```
Dieser Befehl erstellt einen Autoscaler, der 50 Prozent CPU-Auslastung für die Bereitstellung anvisiert, mit mindestens einem Pod und maximal zehn Pods. Wenn die durchschnittliche CPU-Auslastung unter 50 Prozent liegt, versucht der Autoscaler, die Anzahl der Pods in der Bereitstellung auf minimal eins reduzieren. Wenn die Last größer als 50 Prozent ist, versucht der Autoscaler, die Anzahl der Pods in der Bereitstellung auf maximal zehn zu erhöhen. Weitere Informationen finden Sie unter [Wie funktioniert ein Horizontal Pod Autoscaler?](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/#how-does-a-horizontalpodautoscaler-work) in der Kubernetes-Dokumentation.
1. Beschreiben Sie den Autoscaler mit dem folgenden Befehl, um seine Details anzuzeigen.
```
kubectl get hpa
```
Eine Beispielausgabe sieht wie folgt aus.
```
NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache 0%/50% 1 10 1 51s
```
Wie Sie sehen, ist die aktuelle CPU-Last `0%`, weil es noch keine Last auf dem Server gibt. Die Pod-Anzahl befindet sich bereits an der untersten Grenze (eins), daher kann sie nicht weiter nach unten skaliert werden.
1. Erstellen Sie eine Last für den Webserver, indem Sie einen Container ausführen.
```
kubectl run -i \
--tty load-generator \
--rm --image=busybox \
--restart=Never \
-- /bin/sh -c "while sleep 0.01; do wget -q -O- http://php-apache; done"
```
1. Um die Skalierung der Bereitstellung zu beobachten, führen Sie in regelmäßigen Abständen den folgenden Befehl in einem anderen Terminal als demjenigen aus, in dem Sie den vorherigen Schritt ausgeführt haben.
```
kubectl get hpa php-apache
```
Eine Beispielausgabe sieht wie folgt aus.
```
NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache 250%/50% 1 10 5 4m44s
```
Es kann mehr als eine Minute dauern, bis die Anzahl der Replikate zunimmt. Solange der tatsächliche CPU-Prozentsatz höher als der Zielprozentsatz ist, erhöht sich die Replikatanzahl auf bis zu 10. In diesem Fall ist dies `250%`, so dass die Anzahl der `REPLICAS` weiter steigt.
**Anmerkung**
Es kann einige Minuten dauern, bis die Replikatanzahl ihr Maximum erreicht. Wenn beispielsweise nur 6 Replikate erforderlich sind, damit die CPU-Last bei oder unter 50 % bleibt, wird die Last nicht über 6 Replikate hinaus skaliert.
1. Stoppen Sie die Last. Halten Sie im Terminal-Fenster, in dem Sie die Last erzeugen, die Last an, indem Sie die `Ctrl+C`-Tasten gedrückt halten. Sie können beobachten, wie die Replikate auf 1 zurückskalieren, indem Sie den folgenden Befehl erneut in dem Terminal ausführen, in dem Sie die Skalierung beobachten.
```
kubectl get hpa
```
Eine Beispielausgabe sieht wie folgt aus.
```
NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS AGE
php-apache Deployment/php-apache 0%/50% 1 10 1 25m
```
**Anmerkung**
Der Standardzeitrahmen für das Zurückskalieren beträgt fünf Minuten. Es wird daher einige Zeit dauern, bis die Replikatanzahl wieder 1 erreicht, selbst wenn der aktuelle CPU-Prozentsatz 0 Prozent beträgt. Der Zeitrahmen ist veränderbar. Weitere Informationen finden Sie unter [Horizontal Pod Autoscaler](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale/) in der Kubernetes-Dokumentation.
1. Wenn Sie mit dem Experimentieren mit Ihrer Beispielanwendung fertig sind, löschen Sie die `php-apache`-Ressourcen.
```
kubectl delete deployment.apps/php-apache service/php-apache horizontalpodautoscaler.autoscaling/php-apache
```