Verwenden von PowerShell für die automatische Clusterkalierung in AKS, die von Azure Arc aktiviert sind

Artikel
06/28/2024

Gilt für: AKS auf Azure Stack HCI 22H2, AKS unter Windows Server

Sie können PowerShell verwenden, um die Autoskalierung zu aktivieren und die automatische Skalierung von Knotenpools in Ihren Zielclustern in AKS zu verwalten, die von Arc aktiviert sind. Sie können powerShell auch zum Konfigurieren und Verwalten der cluster automatischen Skalierung verwenden.

Erstellen eines neuen AksHciAutoScalerConfig-Objekts

Verwenden Sie den folgenden Befehl, um ein neues AksHciAutoScalerConfig-Objekt zu erstellen, das an den New-AksHciCluster Oder-Befehl Set-AksHciCluster übergeben werden soll:

New-AksHciAutoScalerProfile -Name asp1 -AutoScalerProfileConfig @{ "min-node-count"=2; "max-node-count"=7; 'scale-down-unneeded-time'='1m'}

Sie können das autoscalerconfig-Objekt beim Erstellen Ihres Clusters bereitstellen. Das Objekt enthält die Parameter für Ihre Autoskalierung. Informationen zu Parametern finden Sie unter Verwenden der AutoScaler-Profile.

Ändern eines vorhandenen AksHciAutoScalerConfig-Profilobjekts

Wenn Sie ein vorhandenes AksHciAutoScalerConfig-Profilobjekt aktualisieren, werden Cluster mit diesem Objekt aktualisiert, um die neuen Parameter zu verwenden:

Set-AksHciAutoScalerProfile -name myProfile -autoScalerProfileConfig @{ "max-node-count"=5; "min-node-count"=2 }

Sie können das Autoscalerconfig-Objekt aktualisieren, das die Parameter für die Autoscaler enthält. Informationen zu Parametern finden Sie unter Verwenden der AutoScaler-Profile.

Aktivieren der automatischen Skalierung für neue Cluster

Um die automatische Skalierung für alle neu erstellten Knotenpools automatisch zu aktivieren, verwenden Sie die folgenden Parameter mit dem New-AksHciCluster Befehl:

New-AksHciCluster -name mycluster -enableAutoScaler -autoScalerProfileName myAutoScalerProfile

Aktivieren der automatischen Skalierung für einen vorhandenen Cluster

Um die automatische Skalierung für jeden neu erstellten Knotenpool in einem vorhandenen Cluster automatisch zu aktivieren, verwenden Sie den enableAutoScaler Parameter mit dem Set-AksHciCluster Befehl:

Set-AksHciCluster -Name <string> [-enableAutoScaler <boolean>] [-autoScalerProfileName <String>]

Aktivieren der automatischen Skalierung in einem vorhandenen Knotenpool

Um die automatische Skalierung in einem vorhandenen Knotenpool zu aktivieren, verwenden Sie den autoScaler Parameter mit dem Set-AksHciNodePool Befehl:

Set-AksHciNodePool -clusterName <Your-Cluster-Name> -name <Your-NodePool-Name> -autoScaler $true

Deaktivieren der automatischen Skalierung

Wenn Sie die automatische Skalierung für alle vorhandenen und neu erstellten Knotenpools in einem vorhandenen Cluster deaktivieren möchten, legen enableAutoScaler Sie diesen Wert mithilfe des Set-AksHciCluster Befehls auf "false" fest:

Set-AksHciCluster -Name <string> -enableAutoScaler $false

Effektive Nutzung der horizontalen Autoskalierung

Da nun der Cluster- und Knotenpool für die automatische Skalierung konfiguriert ist, können Sie eine Workload so konfigurieren, dass sie auch auf eine Weise skaliert wird, die die horizontalen Autoskalierungsfunktionen nutzt.

Für die Workloadskalierung stehen zwei Methoden zur Verfügung:

Kubernetes Horizontal Pod Autoscaler: Basierend auf den Ladeeigenschaften skaliert der Horizontal Pod Autoscaler (auch als horizontale Autoscaler bezeichnet) die Pods einer Anwendungsbereitstellung auf verfügbare Knoten im Kubernetes-Cluster. Wenn keine weiteren Knoten für die Planung verfügbar sind, instanziiert die horizontale Autoskalierung einen neuen Knoten, auf den die Pods geplant werden sollen. Wenn die Anwendungslast heruntergeht, werden die Knoten wieder skaliert.
Kubernetes-Knoten-Antiaffinitätsregeln: Antiaffinitätsregeln für eine Kubernetes-Bereitstellung können angeben, dass eine Gruppe von Pods nicht auf demselben Knoten skaliert werden kann und ein anderer Knoten erforderlich ist, um die Workload zu skalieren. In Kombination mit ladeeigenschaften oder der Anzahl der Ziel pods für die Anwendungsinstanzen instanziiert der horizontale Autoscaler neue Knoten im Knotenpool, um Anforderungen zu erfüllen. Wenn die Anwendungsnachfrage abfällt, skaliert die horizontale Autoskalierung den Knotenpool erneut nach unten.

Dieser Abschnitt enthält einige Beispiele.

Horizontale automatische Podskalierung

Voraussetzungen:

AKS, die von Arc aktiviert sind, wird installiert.
Zielcluster wird installiert und mit Azure verbunden.
Ein Linux-Knotenpool wird mit mindestens einem aktiven Linux-Workerknoten bereitgestellt.
Die automatische Skalierung für horizontale Knoten ist auf dem Zielcluster und im Linux-Knotenpool aktiviert, wie zuvor beschrieben.

Wir verwenden das Beispiel "Kubernetes Horizontal Pod Autoscaler Walkthrough", um zu zeigen, wie der horizontale Pod Autoscaler funktioniert.

Damit die horizontale Pod-Autoskalierung funktioniert, müssen Sie die Metrikserverkomponente in Ihrem Zielcluster bereitstellen.

Führen Sie die folgenden Befehle aus, um den Metrikserver auf einem Zielcluster myclusterbereitzustellen:

Get-AksHciCredential -name mycluster
kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml

Nachdem der Kubernetes-Metrikserver bereitgestellt wurde, können Sie eine Anwendung im Knotenpool bereitstellen, den Sie zum Skalieren verwenden. Wir verwenden eine Testanwendung von der Kubernetes-Communitywebsite für dieses Beispiel:

kubectl apply -f https://k8s.io/examples/application/php-apache.yaml
deployment.apps/php-apache created
service/php-apache created

Dieser Befehl erstellt eine Bereitstellung einer Apache-Webserver-basierten PHP-Anwendung, die eine "OK"-Nachricht an einen aufrufenden Client zurückgibt.

Konfigurieren Sie als Nächstes die horizontale Pod-Autoskalierung, um einen neuen Pod zu planen, wenn die CPU-Auslastung des aktuellen Pods 50 Prozent erreicht und von 1 bis 50 Pods skaliert wird:

kubectl autoscale deployment php-apache --cpu-percent=50 --min=1 --max=10
horizontalpodautoscaler.autoscaling/php-apache autoscaled

Sie können den aktuellen Status des neu erstellten horizontalen Pod Autoscaler überprüfen, indem Sie den folgenden Befehl ausführen:

kubectl get hpa

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

Erhöhen Sie schließlich die Last auf dem Webserver, um zu sehen, dass sie skaliert wird. Öffnen Sie ein neues PowerShell-Fenster, und führen Sie den folgenden Befehl aus:

kubectl run -i --tty load-generator --rm --image=busybox:1.28 --restart=Never -- /bin/sh -c "while sleep 0.01; do wget -q -O- http://php-apache; done"

Wenn Sie zum vorherigen PowerShell-Fenster zurückkehren und den folgenden Befehl ausführen, sollte die Anzahl der Pods innerhalb eines kurzen Zeitraums geändert werden:

kubectl get hpa php-apache --watch

NAME         REFERENCE                     TARGET      MINPODS   MAXPODS   REPLICAS   AGE
php-apache   Deployment/php-apache/scale   305% / 50%  1         10        1          3m

In diesem Beispiel ändert sich die Anzahl der Pods von 1 bis 7, wie hier gezeigt:

NAME         REFERENCE                     TARGET      MINPODS   MAXPODS   REPLICAS   AGE
php-apache   Deployment/php-apache/scale   305% / 50%  1         10        7          3m

Wenn dies nicht ausreicht, um die Automatische Skalierung des Knotens auszulösen, da alle Pods auf einen Knoten passen, öffnen Sie weitere PowerShell-Fenster, und führen Sie weitere Ladegeneratorbefehle aus. Stellen Sie sicher, dass Sie den Namen des Pods ändern, den Sie bei jeder Ausführung des Befehls erstellen. Verwenden Sie load-generator-2 z. B. anstelle von load-generator, wie im folgenden Befehl dargestellt.

kubectl run -i --tty load-generator-2 --rm --image=busybox:1.28 --restart=Never -- /bin/sh -c "while sleep 0.01; do wget -q -O- http://php-apache; done"

Überprüfen Sie dann die Anzahl der Knoten, die mit dem folgenden Befehl instanziiert werden:

kubectl get nodes

NAME              STATUS   ROLES                  AGE    VERSION
moc-laondkmydzp   Ready    control-plane,master   3d4h   v1.22.4
moc-lorl6k76q01   Ready    <none>                 3d4h   v1.22.4
moc-lorl4323d02   Ready    <none>                   9m   v1.22.4
moc-lorl43bc3c3   Ready    <none>                   2m   v1.22.4

Um eine Skalierung zu überwachen, drücken Sie STRG-C, um die Ladegenerator-Pods zu beenden und die ihnen zugeordneten PowerShell-Fenster zu schließen. Nach etwa 30 Minuten sollte die Anzahl der Pods nach unten angezeigt werden. Etwa 30 Minuten später werden die Knoten aufgehoben.

Weitere Informationen zum Kubernetes Horizontal Pod Autoscaler finden Sie unter Horizontal Pod Autoscaling.

Knotenaffinitätsregeln

Sie können Knotenaffinitätsregeln verwenden, um dem Kubernetes-Scheduler das Ausführen von Pods nur auf einer bestimmten Gruppe von Knoten in einem Cluster oder Knotenpool basierend auf bestimmten Merkmalen des Knotens zu ermöglichen. Um die Funktion der horizontalen Knoten-Autoskaler anzuzeigen, können Sie dieselben Regeln verwenden, um sicherzustellen, dass nur eine Instanz eines bestimmten Pods auf jedem Knoten ausgeführt wird.

Voraussetzungen:

AKS Arc ist installiert.
Zielcluster wird installiert und mit Azure verbunden.
Ein Linux-Knotenpool wird mit mindestens einem aktiven Linux Worker-Knoten bereitgestellt.
Horizontaler Knoten autoscaler ist auf dem Zielcluster aktiviert, und der Linux-Knotenpool, wie zuvor beschrieben.

Erstellen Sie eine YAML-Datei mit dem folgenden Inhalt, und speichern Sie sie als node-anti-affinity.yaml in einem lokalen Ordner.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: redis-cache
spec:
  selector:
    matchLabels:
      app: store
  replicas: 4
  template:
    metadata:
      labels:
        app: store
    spec:
      nodeSelector:
        kubernetes.io/os: linux
      affinity:
        podAntiAffinity:
          requiredDuringSchedulingIgnoredDuringExecution:
          - labelSelector:
              matchExpressions:
              - key: app
                operator: In
                values:
                - store
            topologyKey: "kubernetes.io/hostname"
      containers:
      - name: redis-server
        image: redis:3.2-alpine

Öffnen Sie ein PowerShell-Fenster, und laden Sie die Anmeldeinformationen für Ihren Zielcluster. In diesem Beispiel heißt myclusterder Cluster :

Get-AksHciCredential -name mycluster

Wenden Sie nun die YAML-Datei auf den Zielcluster an:

kubectl apply -f node-anti-affinity.yaml

Nach ein paar Minuten können Sie den folgenden Befehl verwenden, um zu überprüfen, ob die neuen Knoten online sind:

kubectl get nodes

NAME              STATUS   ROLES                  AGE    VERSION
moc-laondkmydzp   Ready    control-plane,master   3d4h   v1.22.4
moc-lorl6k76q01   Ready    <none>                 3d4h   v1.22.4
moc-lorl4323d02   Ready    <none>                   9m   v1.22.4
moc-lorl43bc3c3   Ready    <none>                   9m   v1.22.4
moc-lorl44ef56c   Ready    <none>                   9m   v1.22.4

Um den Knoten zu entfernen, löschen Sie die Bereitstellung des Redis-Servers mit diesem Befehl:

kubectl delete -f node-anti-affinity.yaml

Weitere Informationen zu Kubernetes-Pod-Affinitätsregeln finden Sie unter Zuweisen von Pods zu Knoten.

Problembehandlung bei der horizontalen Autoskalierung

Wenn die horizontale Pod-Autoskalierung für einen Zielcluster aktiviert ist, wird eine neue Kubernetes-Bereitstellung <cluster_name>-cluster-autoscaler im Verwaltungscluster erstellt. Diese Bereitstellung überwacht den Zielcluster, um sicherzustellen, dass genügend Workerknoten vorhanden sind, um Pods zu planen.

Im Folgenden finden Sie einige verschiedene Möglichkeiten zum Debuggen von Problemen im Zusammenhang mit der Autoscaler:

Die auf dem Verwaltungscluster ausgeführten Cluster-Autoskalierungs-Pods sammeln nützliche Informationen dazu, wie skalierungsentscheidungen getroffen werden, die Anzahl der Knoten, die sie anzeigen oder entfernen muss, und alle allgemeinen Fehler, die auftreten können. Die Autoscaler speichert diese Informationen in Protokollen. Führen Sie den folgenden Befehl aus, um auf die Protokolle zuzugreifen:
```
kubectl --kubeconfig $(Get-AksHciConfig).Kva.kubeconfig logs -l app=<cluster_name>-cluster-autoscaler
```
Der Cloudoperator protokolliert Kubernetes-Ereignisse im Verwaltungscluster, was hilfreich sein kann, um zu verstehen, wann die Autoscaler für einen Cluster und einen Knotenpool aktiviert oder deaktiviert wurde. Diese können angezeigt werden, indem Sie den folgenden Befehl ausführen:
```
kubectl --kubeconfig $(Get-AksHciConfig).Kva.kubeconfig get events
```
Die Bereitstellung der Autoskalierung für Cluster erstellt ein configmap-Element im Zielcluster, den sie verwaltet. Dies configmap enthält Informationen zur clusterweiten Statusebene des Autoscalers und pro Knotenpool. Führen Sie den folgenden Befehl für den Zielcluster aus, um den Status anzuzeigen:

Hinweis

Vergewissern Sie sich, dass Sie Get-AksHciCredentials -Name <clustername> ausgeführt haben, um die kubeconfig-Informationen für den Zugriff auf den entsprechenden Zielcluster abzurufen.
```
kubectl --kubeconfig ~\.kube\config get configmap cluster-autoscaler-status -o yaml
```
Der Cluster autoscaler protokolliert Ereignisse im Cluster-Autoscaler-Status configmap , wenn er den Knotenpool eines Clusters skaliert. Sie können diese Protokolle anzeigen, indem Sie diesen Befehl für den Zielcluster ausführen:
```
kubectl --kubeconfig ~\.kube\config describe configmap cluster-autoscaler-status
```
Die Autoskalierung eines Clusters gibt Ereignisse in Pods im Zielcluster aus, wenn eine Skalierungsentscheidung getroffen wird, wenn der Pod nicht geplant werden kann. Führen Sie diesen Befehl aus, um die Ereignisse in einem Pod anzuzeigen:
```
kubectl --kubeconfig ~\.kube\config describe pod <pod_name>
```

PowerShell-Referenz

Weitere Informationen zu den PowerShell-Cmdlets, die die automatische Clusterkalierung unterstützen, finden Sie auf den folgenden Referenzseiten:

Freigeben über