Automatische Vertikale Skalierung (Vorschau) in Azure Kubernetes Service (AKS)

Artikel
10/12/2023

Dieser Artikel enthält eine Übersicht über den Vertical Pod Autoscaler (VPA) (Vorschau) in Azure Kubernetes Service (AKS), der auf der Open Source-Version für Kubernetes basiert. Bei der Konfiguration legt er automatisch Ressourcenanforderungen und Grenzwerte für Container pro Workload basierend auf der bisherigen Verwendung fest. VPA gibt CPU und Arbeitsspeicher für die anderen Pods frei und trägt dazu bei, Ihren AKS-Cluster effektiv zu nutzen.

Die automatische vertikale Podskalierung bietet Empfehlungen für die Ressourcennutzung im Zeitverlauf. Um plötzliche Zunahmen der Ressourcennutzung zu verwalten, verwenden Sie die automatische horizontale Podskalierung, mit der die Anzahl der Podreplikate nach Bedarf skaliert wird.

Vorteile

Vertical Pod Autoscaler bietet die folgenden Vorteile:

Es analysiert und passt Prozessor- und Arbeitsspeicherressourcen an, damit Ihre Anwendungen weder zu viel noch zu wenig davon erhalten. VPA ist nicht nur für die Hochskalierung verantwortlich, sondern auch für das Herunterskalieren basierend auf der Ressourcennutzung im Laufe der Zeit.
Wenn die Ressourcenanforderungen eines Pods geändert werden müssen und der Skalierungsmodus auf Automatisch oder Neu erstellen gestellt ist.
Festlegen von CPU- und Arbeitsspeichereinschränkungen für einzelne Container durch Spezifizieren einer Ressourcenrichtlinie
Stellt sicher, dass Knoten die richtige Ressourcen für die Podplanung haben
Konfigurierbare Protokollierung aller vorgenommenen Anpassungen an Prozessor- oder Speicherressourcen
Verbessert die Auslastung der Clusterressourcen und gibt CPU und Arbeitsspeicher für andere Pods frei.

Begrenzungen

Automatische Vertikale Pod-Skalierung unterstützt maximal 1,000 VerticalPodAutoscaler-Objekte pro Cluster.
VPA empfiehlt möglicherweise mehr Ressourcen als im Cluster verfügbar sind. Dadurch wird verhindert, dass der Pod einem Knoten zugewiesen und ausgeführt wird, da der Knoten nicht über ausreichende Ressourcen verfügt. Sie können diese Einschränkung umgehen, indem Sie LimitRange auf die maximal verfügbaren Ressourcen pro Namespace festlegen, wodurch sichergestellt wird, dass Pods nicht mehr Ressourcen als angegeben anfordern. Darüber hinaus können Sie maximal zulässige Ressourcenempfehlungen pro Pod in einem VerticalPodAutoscaler -Objekt festlegen. Beachten Sie, dass VPA ein Problem mit unzureichenden Knotenressourcen nicht vollständig beheben kann. Der Grenzwertbereich ist festgelegt, aber die Ressourcennutzung des Knotens wird dynamisch geändert.
Es wird nicht empfohlen, die automatische vertikale Podskalierung mit horizontaler Pod-Autoscaler-Instanz zu verwenden, die basierend auf denselben CPU- und Speicherauslastungsmetriken skaliert wird.
VPA Recommender speichert nur bis zu acht Tage historische Daten.
VPA unterstützt keine JVM-basierten Workloads, da die tatsächliche Speicherauslastung der Workload eingeschränkt ist.
Es wird nicht empfohlen oder unterstützt, ihre eigene VPA-Implementierung zusammen mit dieser verwalteten Implementierung von VPA auszuführen. Eine zusätzliche oder angepasste Empfehlung wird unterstützt.
Windows-Container werden derzeit nicht unterstützt.

Voraussetzungen

AKS-Cluster führt Kubernetes Version 1.24 und höher aus.
Version 2.52.0 oder höher der Azure-Befehlszeilenschnittstelle ist installiert und konfiguriert. Führen Sie az --version aus, um die Version zu ermitteln. Informationen zum Durchführen einer Installation oder eines Upgrades finden Sie bei Bedarf unter Installieren der Azure CLI.
kubectl sollte mit dem Cluster verbunden sein, auf dem Sie VPA installieren möchten.

Übersicht über MPA

Api-Objekt

Vertical Pod Autoscaler ist eine API-Ressource in der Gruppe „Kubernetes autoscaling API“. Die in dieser Vorschauversion unterstützte Version 0.11 finden Sie im Kubernetes Autoscaler-Repo.

Das VPA-Objekt besteht aus drei Komponenten:

Recommender - Es überwacht den aktuellen und vergangenen Ressourcenverbrauch und stellt basierend darauf empfohlene Werte für die CPU- und Arbeitsspeicheranforderungen/-grenzwerte der Container bereit. Der Empfehlungsmodul überwacht den Metrikverlauf, Ereignisse außerhalb des Arbeitsspeichers (OOM) und die VPA-Bereitstellungsspezifikation und schlägt faire Anforderungen vor. Durch die Bereitstellung einer ordnungsgemäßen Ressourcenanforderungs- und Begrenzungskonfiguration werden die Grenzwerte erhöht und gesenkt.
Updater : Überprüft, welche der verwalteten Pods die richtigen Ressourcen festgelegt haben, und beendet sie, falls nicht, damit sie von ihren Controllern mit den aktualisierten Anforderungen neu erstellt werden können.
VPA-Zulassungscontroller : Legt die richtigen Ressourcenanforderungen für neue Pods fest (entweder erstellt oder neu erstellt durch den Controller aufgrund der Aktivität des Updaters).

VPA-Zulassungscontroller

Der VPA-Zugangscontroller ist eine Binärdatei, die sich selbst als Mutating Admission Webhook registriert. Wenn jeder Pod erstellt wird, ruft er eine Anforderung vom apiserver ab und wertet aus, ob eine übereinstimmende VPA-Konfiguration vorhanden ist, oder sucht eine entsprechende, und verwendet die aktuelle Empfehlung, um Ressourcenanforderungen im Pod festzulegen.

Ein eigenständiger Auftrag wird außerhalb des VPA-Zugangscontrollers namens overlay-vpa-cert-webhook-checkausgeführt. Wird overlay-vpa-cert-webhook-check verwendet, um die Zertifikate zu erstellen und zu erneuern und den VPA-Zulassungscontroller als MutatingWebhookConfigurationzu registrieren.

Für Hochverfügbarkeit unterstützt AKS zwei Zugangscontrollerreplikate.

Vorgangsmodi für VPA-Objekte

Eine Vertical Pod Autoscaler-Ressource wird für jeden Controller eingefügt, für den Die Ressourcenanforderungen automatisch berechnet werden sollen. Dies ist am häufigsten eine Bereitstellung. Es gibt vier Modi, in denen VPAs betrieben werden:

Auto – VPA weist Ressourcenanforderungen während der Poderstellung zu und aktualisiert vorhandene Pods mithilfe des bevorzugten Updatemechanismus. Auto Derzeit entspricht Recreate, und ist auch der Standardmodus. Sobald das kostenlose ("direkte") Update von Podanforderungen neu gestartet wird, kann es vom Modus als bevorzugter Updatemechanismus Auto verwendet werden. Wenn der Modus verwendet Recreate wird, entfernt VPA einen Pod, wenn er seine Ressourcenanforderungen ändern muss. Dies kann dazu führen, dass die Pods auf einmal neu gestartet werden, was zu Anwendungsinkonsistenzen führt. Sie können Neustarts einschränken und in dieser Situation die Konsistenz beibehalten, indem Sie ein PodDisruptionBudget verwenden.
Recreate – VPA weist Ressourcenanforderungen während der Poderstellung zu und aktualisiert vorhandene Pods, indem sie entfernt werden, wenn sich die angeforderten Ressourcen erheblich von der neuen Empfehlung unterscheiden (unter Berücksichtigung des Podunterbrechungsbudgets, sofern definiert). Dieser Modus sollte nur selten verwendet werden, wenn Sie sicherstellen müssen, dass die Pods neu gestartet werden, wenn sich die Ressourcenanforderung ändert. Andernfalls wird der Auto Modus bevorzugt, der updates ohne Neustart nutzen kann, sobald sie verfügbar sind.
Initial – VPA weist Ressourcenanforderungen nur während der Poderstellung zu und ändert sich danach nie.
Off – VPA ändert nicht automatisch die Ressourcenanforderungen der Pods. Die Empfehlungen werden berechnet und können im VPA-Objekt überprüft werden.

Bereitstellungsmuster während der Anwendungsentwicklung

Ein gängiges Bereitstellungsmuster, das Ihnen empfohlen wird, wenn Sie mit VPA nicht vertraut sind, besteht darin, die folgenden Schritte während der Anwendungsentwicklung auszuführen, um die eindeutigen Eigenschaften der Ressourcennutzung zu identifizieren, VPA zu testen, um zu überprüfen, ob es ordnungsgemäß funktioniert, und tests zusammen mit anderen Kubernetes-Komponenten, um die Ressourcennutzung des Clusters zu optimieren.

Legen Sie UpdateMode = „Off“ in Ihrem Produktionscluster fest und führen Sie VPA im Empfehlungsmodus aus, damit Sie VPA testen und sich mit VPA vertraut machen können. UpdateMode = „Off“ kann eine Fehlkonfiguration vermeiden, die zu einem Ausfall führen kann.
Stellen Sie zuerst die Beobachtbarkeit her, indem Sie Telemetriedaten zur tatsächlichen Ressourcennutzung über einen bestimmten Zeitraum sammeln. Dies hilft Ihnen, das Verhalten und die Anzeichen von Symptomen oder Problemen von Container- und Podressourcen zu verstehen, die von den darauf ausgeführten Workloads beeinflusst werden.
Machen Sie sich mit den Überwachungsdaten vertraut, um die Leistungsmerkmale zu verstehen. Legen Sie basierend auf dieser Erkenntnis die gewünschten Anforderungen/Grenzwerte entsprechend fest und dann in der nächsten Bereitstellung oder beim nächsten Upgrade
Legen Sie den Wert abhängig von Ihren Anforderungen auf updateMode, Autooder Recreate festInitial.

Bereitstellen, Upgraden oder Deaktivieren von VPA auf einem Cluster

In diesem Abschnitt stellen Sie das Vertikale Pod Autoscaler in Ihrem Cluster bereit, aktualisieren oder deaktivieren es.

Um VPA für einen neuen Cluster zu aktivieren, verwenden Sie den Parameter --enable-vpa mit dem Befehl az aks create.
```
az aks create -n myAKSCluster -g myResourceGroup --enable-vpa
```
Nach wenigen Minuten ist die Ausführung des Befehls abgeschlossen, und es werden Informationen zum Cluster im JSON-Format zurückgegeben.
Verwenden Sie --enable-vpa optional den Befehl "[https://learn.microsoft.com/en-us/cli/azure/aks?view=azure-cli-latest#az-aks-update]", um VPA auf einem vorhandenen Cluster zu aktivieren.
```
az aks update -n myAKSCluster -g myResourceGroup --enable-vpa 
```
Nach wenigen Minuten ist die Ausführung des Befehls abgeschlossen, und es werden Informationen zum Cluster im JSON-Format zurückgegeben.
Verwenden Sie --disable-vpa optional den Befehl "[https://learn.microsoft.com/en-us/cli/azure/aks?view=azure-cli-latest#az-aks-update]", um VPA für einen vorhandenen Cluster zu deaktivieren.
```
az aks update -n myAKSCluster -g myResourceGroup --disable-vpa
```
Nach wenigen Minuten ist die Ausführung des Befehls abgeschlossen, und es werden Informationen zum Cluster im JSON-Format zurückgegeben.
Verwenden Sie den Befehl kubectl get, um zu überprüfen, ob die Vertical Pod Autoscaler-Pods erfolgreich erstellt wurden.

kubectl get pods -n kube-system

Die Ausgabe des Befehls enthält die folgenden Ergebnisse, die für die VPA-Pods spezifisch sind. Der Pod-Status sollte ausgeführt sein.

NAME                                        READY   STATUS    RESTARTS   AGE
vpa-admission-controller-7867874bc5-vjfxk   1/1     Running   0          41m
vpa-recommender-5fd94767fb-ggjr2            1/1     Running   0          41m
vpa-updater-56f9bfc96f-jgq2g                1/1     Running   0          41m

Testen der Vertical Pod Autoscaler-Installation

Die folgenden Schritte erstellen eine Bereitstellung mit zwei Pods mit jeweils einem einzelnen Container, der 100 Millicores anfordert und versucht, etwas mehr als 500 Millicores zu verwenden. Außerdem wird eine VPA-Konfiguration erstellt, die auf die Bereitstellung verweist. Der VPA beobachtet das Verhalten der Pods, und nach etwa fünf Minuten werden sie mit einer höheren CPU-Anforderung aktualisiert.

Erstellen Sie eine Datei namens hamster.yaml und kopieren Sie das folgende Manifest des Vertical Pod Autoscaler-Beispiels aus dem Kubernetes/autoscaler-GitHub-Repository hinein.
Stellen Sie das hamster.yaml-Vertical Pod Autoscaler-Beispiel über den Befehl kubectl apply bereit, und geben Sie den Namen Ihres YAML-Manifests an:
```
kubectl apply -f hamster.yaml
```
Nach wenigen Minuten ist die Ausführung des Befehls abgeschlossen, und es werden Informationen zum Cluster im JSON-Format zurückgegeben.

Führen Sie den folgenden kubectl get-Befehl aus, um die Pods aus der Hamster-Beispielanwendung abzurufen:

kubectl get pods -l app=hamster

Die Ausgabe des Beispiels ähnelt folgenem:

hamster-78f9dcdd4c-hf7gk   1/1     Running   0          24s
hamster-78f9dcdd4c-j9mc7   1/1     Running   0          24s

Verwenden Sie den kubectl describe-Befehl auf einem der Pods, um die CPU- und Arbeitsspeicherreservierung anzuzeigen. Ersetzen Sie „exampleID“ durch eine der Pod-IDs, die in der Ausgabe aus dem vorherigen Schritt zurückgegeben wurden.
```
kubectl describe pod hamster-exampleID
```
Die Beispielausgabe ist ein Ausschnitt der Informationen über den Cluster:
```
 hamster:
    Container ID:  containerd://
    Image:         k8s.gcr.io/ubuntu-slim:0.1
    Image ID:      sha256:
    Port:          <none>
    Host Port:     <none>
    Command:
      /bin/sh
    Args:
      -c
      while true; do timeout 0.5s yes >/dev/null; sleep 0.5s; done
    State:          Running
      Started:      Wed, 28 Sep 2022 15:06:14 -0400
    Ready:          True
    Restart Count:  0
    Requests:
      cpu:        100m
      memory:     50Mi
    Environment:  <none>
```
Der Pod in diesem Beispiel verfügt über 100 Millicpu und 50 Mibibyte Arbeitsspeicher an Reservierungen. Für diese Beispielanwendung benötigt der Pod weniger als 100 Millicpu, sodass keine CPU-Kapazität verfügbar ist. Der Pod reserviert auch viel weniger Arbeitsspeicher vor als erforderlich. Die Vertical Pod Autoscaler vpa-recommender-Bereitstellung analysiert die Pods, die die Hamster-Anwendung hosten, um festzustellen, ob die CPU- und Speicheranforderungen sinnvoll sind. Wenn Anpassungen erforderlich sind, startet der vpa-updater die Pods mit aktualisierten Werten neu.
Warten Sie, bis der vpa-updater einen neuen Hamster-Pod startet. Dies sollte einige Minuten dauern. Sie können die Pods mithilfe des kubectl get-Befehls überwachen.
```
kubectl get --watch pods -l app=hamster
```
Wenn ein neuer Hamster-Pod gestartet wird, beschreiben Sie den Pod mithilfe des kubectl describe-Befehls, und zeigen Sie die aktualisierten CPU- und Speicherreservierungen an.
```
kubectl describe pod hamster-<exampleID>
```
Die Beispielausgabe ist ein Ausschnitt der den Pod beschreibenden Informationen:
```
State:          Running
  Started:      Wed, 28 Sep 2022 15:09:51 -0400
Ready:          True
Restart Count:  0
Requests:
  cpu:        587m
  memory:     262144k
Environment:  <none>
```
In der vorherigen Ausgabe können Sie sehen, dass die CPU-Reservierung auf 587 Millicpu erhöht wurde, was mehr als fünf mal der ursprüngliche Wert ist. Der Arbeitsspeicher stieg auf 262.144 Kilobyte, also etwa 250 Mibibyte oder fünf mal der ursprüngliche Wert. Diesem Pod standen zu wenige Ressourcen zur Verfügung, und der Vertical Pod Autoscaler korrigierte die Schätzung durch einen viel geeigneteren Wert.
Um aktualisierte Empfehlungen von VPA anzuzeigen, führen Sie den Befehl kubectl describe aus, um die hamster-vpa-Ressourceninformationen zu beschreiben.
```
kubectl describe vpa/hamster-vpa
```
Die Beispielausgabe ist ein Ausschnitt der Informationen über die Ressourcenverwendung:
```
 State:          Running
  Started:      Wed, 28 Sep 2022 15:09:51 -0400
Ready:          True
Restart Count:  0
Requests:
  cpu:        587m
  memory:     262144k
Environment:  <none>
```

Automatisches Festlegen von Pod Autoscaler-Anforderungen

Bei der automatischen vertikalen Podskalierung wird das VerticalPodAutoscaler -Objekt verwendet, um Ressourcenanforderungen für Pods automatisch festzulegen, wenn updateMode auf Auto festgelegt ist. Sie können je nach Ihren Anforderungen und Tests einen anderen Wert festlegen. In diesem Beispiel ist updateMode auf Recreatefestgelegt.

Aktivieren Sie den VPA für Ihren Cluster durch Ausführen des folgenden Befehls: Ersetzen Sie den Clusternamen myAKSCluster durch den Namen Ihres AKS-Clusters, und ersetzen Sie myResourceGroup mit dem Namen der Ressourcengruppe, in der der Cluster gehostet wird.
```
az aks update -n myAKSCluster -g myResourceGroup --enable-vpa
```

Erstellen Sie eine Datei namens azure-autodeploy.yaml, und fügen Sie das folgende Manifest ein.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: vpa-auto-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: vpa-auto-deployment
  template:
    metadata:
      labels:
        app: vpa-auto-deployment
    spec:
      containers:
      - name: mycontainer
        image: mcr.microsoft.com/oss/nginx/nginx:1.15.5-alpine
        resources:
          requests:
            cpu: 100m
            memory: 50Mi
        command: ["/bin/sh"]
        args: ["-c", "while true; do timeout 0.5s yes >/dev/null; sleep 0.5s; done"]

Dieses Manifest beschreibt eine Bereitstellung mit zwei Pods. Jeder Pod verfügt über einen Container, der 100 milliCPU und 50 MiB Arbeitsspeicher anfordert.

Erstellen Sie den Pod mit dem Befehl kubectl create, wie im folgenden Beispiel gezeigt wird:
```
kubectl create -f azure-autodeploy.yaml
```
Nach wenigen Minuten ist die Ausführung des Befehls abgeschlossen, und es werden Informationen zum Cluster im JSON-Format zurückgegeben.

Führen Sie den folgenden kubectl get-Befehl aus, um die Pods abzurufen:

kubectl get pods

Die Ausgabe ähnelt dem folgenden Beispiel mit dem Namen und dem Status der Pods:

NAME                                   READY   STATUS    RESTARTS   AGE
vpa-auto-deployment-54465fb978-kchc5   1/1     Running   0          52s
vpa-auto-deployment-54465fb978-nhtmj   1/1     Running   0          52s

Erstellen Sie eine Datei namens azure-vpa-auto.yaml, und fügen Sie das folgende Manifest ein, das ein VerticalPodAutoscaler beschreibt.
```
apiVersion: autoscaling.k8s.io/v1
kind: VerticalPodAutoscaler
metadata:
  name: vpa-auto
spec:
  targetRef:
    apiVersion: "apps/v1"
    kind:       Deployment
    name:       vpa-auto-deployment
  updatePolicy:
    updateMode: "Recreate"
```
Der targetRef.name Wert gibt an, dass jeder Pod, der von einer Bereitstellung namens vpa-auto-deployment gesteuert wird, zu dieser VerticalPodAutoscaler gehört. Der updateMode-Wert von Recreate bedeutet, dass der Vertical Pod Autoscaler-Controller einen Pod löschen kann, die CPU- und Speicheranforderungen anpassen und dann einen neuen Pod starten kann.
Wenden Sie das Manifest auf den Cluster an, indem Sie den Befehl kubectl apply verwenden:
```
kubectl create -f azure-vpa-auto.yaml
```
Warten Sie einige Minute, und zeigen Sie die ausgeführten Pods erneut an, indem Sie den folgenden kubectl get-Befehl ausführen:
```
kubectl get pods
```
Die Ausgabe ähnelt dem folgenden Beispiel und zeigt, dass die Namen der Pods sich geändert haben, sowie den Status der Pods:
```
NAME                                   READY   STATUS    RESTARTS   AGE
vpa-auto-deployment-54465fb978-qbhc4   1/1     Running   0          2m49s
vpa-auto-deployment-54465fb978-vbj68   1/1     Running   0          109s
```

Rufen Sie mithilfe des Befehls kubectl get detaillierte Informationen zu einzelnen ausgeführten Pods ab. Ersetzen Sie podName durch den Namen eines Ihrer Pods, den Sie im vorherigen Schritt abgerufen haben.

kubectl get pod podName --output yaml

Die Ausgabe ähnelt dem folgenden Beispiel, das zeigt, dass der Vertikale Pod Autoscaler-Controller die Speicheranforderung auf 262144k und CPU-Anforderung auf 25 MilliCPU erhöht hat.

apiVersion: v1
kind: Pod
metadata:
  annotations:
    vpaObservedContainers: mycontainer
    vpaUpdates: 'Pod resources updated by vpa-auto: container 0: cpu request, memory
      request'
  creationTimestamp: "2022-09-29T16:44:37Z"
  generateName: vpa-auto-deployment-54465fb978-
  labels:
    app: vpa-auto-deployment

spec:
  containers:
  - args:
    - -c
    - while true; do timeout 0.5s yes >/dev/null; sleep 0.5s; done
    command:
    - /bin/sh
    image: mcr.microsoft.com/oss/nginx/nginx:1.15.5-alpine
    imagePullPolicy: IfNotPresent
    name: mycontainer
    resources:
      requests:
        cpu: 25m
        memory: 262144k

Verwenden Sie den Befehl kubectl get, um detaillierte Informationen zum Vertical Pod Autoscaler und seinen Empfehlungen für CPU und Arbeitsspeicher zu erhalten:
```
kubectl get vpa vpa-auto --output yaml
```
Die Ausgabe ähnelt dem folgenden Beispiel:
```
 recommendation:
  containerRecommendations:
  - containerName: mycontainer
    lowerBound:
      cpu: 25m
      memory: 262144k
    target:
      cpu: 25m
      memory: 262144k
    uncappedTarget:
      cpu: 25m
      memory: 262144k
    upperBound:
      cpu: 230m
      memory: 262144k
```
Die Ergebnisse zeigen das target-Attribut, welches angibt, dass zum optimalen Ausführen des Containers die Zielwerte für CPU oder Arbeitsspeicher nicht geändert werden müssen. Ihre Ergebnisse können variieren, sodass die Ziel-CPU- und Arbeitsspeicherempfehlung höher sein kann.

Der Vertical Pod Autoscaler verwendet die Attribute lowerBound und upperBound, um zu entscheiden, ob ein Pod gelöscht und durch einen neuen Pod ersetzt werden soll. Wenn ein Pod Anforderungen kleiner als die untere Grenze oder größer als die obere Grenze aufweist, löscht der Vertical Pod Autoscaler den Pod und ersetzt ihn durch einen Pod, der das Zielattribut erfüllt.

Zusätzliche Empfehlung für die automatische vertikale Podskalierung

In der VPA ist eine der Kernkomponenten der Recommender. Sie enthält Empfehlungen für die Ressourcennutzung basierend auf dem Ressourcenverbrauch in Echtzeit. AKS stellt eine Empfehlung bereit, wenn ein Cluster VPA aktiviert. Sie können eine benutzerdefinierte Empfehlung oder eine zusätzliche Empfehlung mit demselben Image wie das Standardimage bereitstellen. Der Vorteil einer benutzerdefinierten Empfehlung besteht darin, dass Sie Ihre Empfehlungslogik anpassen können. Mit einer zusätzlichen Empfehlung können Sie VPAs auf mehrere Empfehlungser partitionieren, wenn viele VPA-Objekte vorhanden sind.

Das folgende Beispiel ist eine zusätzliche Empfehlung, die Sie auf Ihren vorhandenen AKS-Cluster anwenden. Anschließend konfigurieren Sie das VPA-Objekt für die Verwendung des zusätzlichen Empfehlungsmoduls.

Erstellen Sie eine Datei namens extra_recommender.yaml, und fügen Sie das folgende Manifest ein:

apiVersion: apps/v1 
kind: Deployment 
metadata: 
  name: extra-recommender 
  namespace: kube-system 
spec: 
  replicas: 1 
  selector: 
    matchLabels: 
      app: extra-recommender 
  template: 
    metadata: 
      labels: 
        app: extra-recommender 
    spec: 
      serviceAccountName: vpa-recommender 
      securityContext: 
        runAsNonRoot: true 
        runAsUser: 65534 # nobody 
      containers: 
      - name: recommender 
        image: registry.k8s.io/autoscaling/vpa-recommender:0.13.0 
        imagePullPolicy: Always 
        args: 
          - --recommender-name=extra-recommender 
        resources: 
          limits: 
            cpu: 200m 
            memory: 1000Mi 
          requests: 
            cpu: 50m 
            memory: 500Mi 
        ports: 
        - name: prometheus 
          containerPort: 8942

Stellen Sie das extra-recomender.yaml-Vertical Pod Autoscaler-Beispiel über den Befehl kubectl apply bereit, und geben Sie den Namen Ihres YAML-Manifests an.
```
kubectl apply -f extra-recommender.yaml 
```
Nach wenigen Minuten ist die Ausführung des Befehls abgeschlossen, und es werden Informationen zum Cluster im JSON-Format zurückgegeben.

Erstellen Sie eine Datei namens hamnster_extra_recommender.yaml, und fügen Sie das folgende Manifest ein:

apiVersion: "autoscaling.k8s.io/v1" 
kind: VerticalPodAutoscaler 
metadata: 
  name: hamster-vpa 
spec: 
  recommenders:  
    - name: 'extra-recommender' 
  targetRef: 
    apiVersion: "apps/v1" 
    kind: Deployment 
    name: hamster 
  updatePolicy: 
    updateMode: "Auto" 
  resourcePolicy: 
    containerPolicies: 
      - containerName: '*' 
        minAllowed: 
          cpu: 100m 
          memory: 50Mi 
        maxAllowed: 
          cpu: 1 
          memory: 500Mi 
        controlledResources: ["cpu", "memory"] 
--- 
apiVersion: apps/v1 
kind: Deployment 
metadata: 
  name: hamster 
spec: 
  selector: 
    matchLabels: 
      app: hamster 
  replicas: 2 
  template: 
    metadata: 
      labels: 
        app: hamster 
    spec: 
      securityContext: 
        runAsNonRoot: true 
        runAsUser: 65534 # nobody 
      containers: 
        - name: hamster 
          image: k8s.gcr.io/ubuntu-slim:0.1 
          resources: 
            requests: 
              cpu: 100m 
              memory: 50Mi 
          command: ["/bin/sh"] 
          args: 
            - "-c" 
            - "while true; do timeout 0.5s yes >/dev/null; sleep 0.5s; done"

Wenn memory nicht in controlledResourcesangegeben ist, antwortet der Recommender nicht auf OOM-Ereignisse. In diesem Fall legen Sie nur die CPU in fest controlledValues. controlledValues ermöglicht Ihnen die Auswahl, ob die Ressourcenanforderungen RequestsOnly des Containers nach option oder sowohl Ressourcenanforderungen als auch Grenzwerte mithilfe der RequestsAndLimits Option aktualisiert werden sollen. Der Standardwert ist RequestsAndLimits. Wenn Sie die Option verwenden, werden RequestsAndLimitsAnforderungen basierend auf der tatsächlichen Nutzung berechnet, und Grenzwerte werden basierend auf dem Anforderungs- und Grenzwertverhältnis des aktuellen Pods berechnet.

Wenn Sie beispielsweise mit einem Pod beginnen, der 2 CPUs anfordert und auf 4 CPUs beschränkt ist, legt VPA den Grenzwert immer auf das Doppelte fest wie Anforderungen. Das gleiche Prinzip gilt für andere Aktionen. Wenn Sie den RequestsAndLimits Modus verwenden, kann er als Blaupause für Ihre anfänglichen Anwendungsressourcenanforderungen und -grenzwerte dienen.

Sie können das VPA-Objekt vereinfachen, indem Sie automodus- und Computeempfehlungen für CPU und Arbeitsspeicher verwenden.

Stellen Siehamster_extra-recomender.yaml die Anwendung über den Befehl kubectl apply bereit, und geben Sie den Namen Ihres YAML-Manifests an.
```
kubectl apply -f hamster_customized_recommender.yaml
```
Warten Sie, bis der vpa-updater einen neuen Hamster-Pod startet. Dies sollte einige Minuten dauern. Sie können die Pods mithilfe des kubectl get-Befehls überwachen.
```
kubectl get --watch pods -l app=hamster
```
Wenn ein neuer Hamster-Pod gestartet wird, beschreiben Sie den Pod mithilfe des kubectl describe-Befehls, und zeigen Sie die aktualisierten CPU- und Speicherreservierungen an.
```
kubectl describe pod hamster-<exampleID>
```
Die Beispielausgabe ist ein Ausschnitt der den Pod beschreibenden Informationen:
```
State:          Running
  Started:      Wed, 28 Sep 2022 15:09:51 -0400
Ready:          True
Restart Count:  0
Requests:
  cpu:        587m
  memory:     262144k
Environment:  <none>
```

Um aktualisierte Empfehlungen von VPA anzuzeigen, führen Sie den Befehl kubectl describe aus, um die hamster-vpa-Ressourceninformationen zu beschreiben.

kubectl describe vpa/hamster-vpa

Die Beispielausgabe ist ein Ausschnitt der Informationen über die Ressourcenverwendung:

State:          Running
 Started:      Wed, 28 Sep 2022 15:09:51 -0400
Ready:          True
Restart Count:  0
Requests:
  cpu:        587m
  memory:     262144k
Environment:  <none>
Spec:
  recommenders:
    Name: customized-recommender

Problembehandlung

Führen Sie die folgenden Schritte aus, um Probleme mit einer VPA-Installation zu diagnostizieren.

Überprüfen Sie mit dem folgenden Befehl, ob alle Systemkomponenten ausgeführt werden:
```
kubectl --namespace=kube-system get pods|grep vpa
```

Die Ausgabe sollte drei Pods auflisten: Recommender, Updater und Admission Controller, alle mit dem Status, der eine status zeigtRunning.

Überprüfen Sie, ob die Systemkomponenten Fehler protokollieren. Führen Sie für jeden der vom vorherigen Befehl zurückgegebenen Pods den folgenden Befehl aus:
```
kubectl --namespace=kube-system logs [pod name] | grep -e '^E[0-9]\{4\}'
```
Vergewissern Sie sich, dass die benutzerdefinierte Ressourcendefinition erstellt wurde, indem Sie den folgenden Befehl ausführen:
```
kubectl get customresourcedefinition | grep verticalpodautoscalers
```

Nächste Schritte

In diesem Artikel wurde gezeigt, wie Sie die Ressourcenauslastung, z. B. CPU und Arbeitsspeicher, automatisch skalieren, um den Anwendungsanforderungen zu entsprechen.

Außerdem können Sie mit der horizontalen automatischen Podskalierung automatisch die Anzahl von Pods anpassen, auf denen Ihre Anwendung ausgeführt wird. Die Schritte zum Verwenden der horizontalen automatischen Podskalierung finden Sie unter Skalieren von Anwendungen in Azure Kubernetes Service (AKS).
Weitere Informationen zu den Definitionen für verwandte VPA-Objekte finden Sie unter Vertical Pod Autoscaler [API-Referenz].