Utiliser PowerShell pour la mise à l’échelle automatique du cluster dans AKS activé par Azure Arc

Article
06/28/2024

S’applique à : AKS sur Azure Stack HCI 22H2, AKS sur Windows Server

Vous pouvez utiliser PowerShell pour activer la mise à l’échelle automatique et gérer la mise à l’échelle automatique des pools de nœuds dans vos clusters cibles dans AKS activé par Arc. Vous pouvez également utiliser PowerShell pour configurer et gérer la mise à l’échelle automatique du cluster.

Créer un objet AksHciAutoScalerConfig

Pour créer un objet AksHciAutoScalerConfig à transmettre à la ou Set-AksHciCluster la New-AksHciCluster commande, utilisez cette commande :

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

Vous pouvez fournir l’objet autoscalerconfig lors de la création de votre cluster. L’objet contient les paramètres de votre autoscaler. Pour plus d’informations sur les paramètres, consultez Comment utiliser les profils de mise à l’échelle automatique.

Modifier un objet de profil AksHciAutoScalerConfig existant

Lorsque vous mettez à jour un objet de profil AksHciAutoScalerConfig existant, les clusters utilisant cet objet sont mis à jour pour utiliser les nouveaux paramètres :

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

Vous pouvez mettre à jour l’objet de mise à l’échelle automatique, qui contient les paramètres de votre autoscaler. Pour plus d’informations sur les paramètres, consultez Comment utiliser les profils de mise à l’échelle automatique.

Activer la mise à l’échelle automatique pour les nouveaux clusters

Pour activer la mise à l’échelle automatique automatiquement sur tous les pools de nœuds nouvellement créés, utilisez les paramètres suivants avec la New-AksHciCluster commande :

New-AksHciCluster -name mycluster -enableAutoScaler -autoScalerProfileName myAutoScalerProfile

Activer la mise à l’échelle automatique sur un cluster existant

Pour activer la mise à l’échelle automatique automatiquement sur chaque pool de nœuds nouvellement créé sur un cluster existant, utilisez le paramètre avec la enableAutoScaler Set-AksHciCluster commande :

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

Activer la mise à l’échelle automatique sur un pool de nœuds existant

Pour activer la mise à l’échelle automatique sur un pool de nœuds existant, utilisez le autoScaler paramètre avec la Set-AksHciNodePool commande :

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

Désactiver la mise à l’échelle automatique

Pour désactiver la mise à l’échelle automatique sur tous les pools de nœuds existants et nouvellement créés sur un cluster existant, définissez la enableAutoScaler valeur false à l’aide de la Set-AksHciCluster commande :

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

Utilisation efficace de la mise à l’échelle automatique horizontale

Maintenant que le cluster et le pool de nœuds sont configurés pour être mis à l’échelle automatiquement, vous pouvez configurer une charge de travail pour qu’elle soit également mise à l’échelle de manière à utiliser les fonctionnalités de mise à l’échelle automatique horizontale.

Deux méthodes sont disponibles pour la mise à l’échelle de la charge de travail :

Mise à l’échelle automatique des pods horizontaux Kubernetes : en fonction des caractéristiques de charge, l’autoscaler de pod horizontal (également appelé autoscaler horizontal) met à l’échelle les pods d’un déploiement d’application vers les nœuds disponibles dans le cluster Kubernetes. Si aucun autre nœud n’est disponible pour être planifié, l’autoscaler horizontal instancie un nouveau nœud auquel planifier les pods. Si la charge de l’application tombe en panne, les nœuds sont redimensionné.
Règles d’anti-affinité des nœuds Kubernetes : les règles d’anti-affinité pour un déploiement Kubernetes peuvent spécifier qu’un ensemble de pods ne peut pas être mis à l’échelle sur le même nœud et qu’un autre nœud est nécessaire pour mettre à l’échelle la charge de travail. En combinaison avec les caractéristiques de charge ou le nombre de pods cibles pour les instances d’application, le mise à l’échelle automatique horizontale instancie de nouveaux nœuds dans le pool de nœuds pour répondre aux demandes. Si la demande d’application diminue, l’autoscaler horizontal effectue une nouvelle mise à l’échelle vers le bas du pool de nœuds.

Cette section contient quelques exemples.

Autoscaler de pods horizontaux

Configuration requise :

AKS activé par Arc est installé.
Le cluster cible est installé et connecté à Azure.
Un pool de nœuds Linux est déployé, avec au moins un nœud Worker Linux actif.
L’autoscaler de nœud horizontal est activé sur le cluster cible et le pool de nœuds Linux, comme décrit précédemment.

Nous utilisons l’exemple de procédure pas à pas de la mise à l’échelle automatique des pods horizontaux Kubernetes pour montrer comment fonctionne l’autoscaler de pod horizontal.

Pour que l’autoscaler de pod horizontal fonctionne, vous devez déployer le composant Metrics Server dans votre cluster cible.

Pour déployer le serveur de métriques sur un cluster cible appelé mycluster, exécutez les commandes suivantes :

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

Une fois le serveur de métriques Kubernetes déployé, vous pouvez déployer une application sur le pool de nœuds, que vous utilisez pour effectuer une mise à l’échelle. Nous utilisons une application de test à partir du site web de la communauté Kubernetes pour cet exemple :

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

Cette commande crée un déploiement d’une application PHP basée sur un serveur web Apache qui renvoie un message « OK » à un client appelant.

Ensuite, configurez l’autoscaler de pod horizontal pour planifier un nouveau pod lorsque l’utilisation du processeur du pod actuel atteint 50 pour cent et passez de 1 à 50 pods :

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

Vous pouvez vérifier l’état actuel de l’autoscaler de pod horizontal nouvellement créé en exécutant la commande suivante :

kubectl get hpa

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

Enfin, augmentez la charge sur le serveur web pour la voir monter en puissance. Ouvrez une nouvelle fenêtre PowerShell et exécutez la commande suivante :

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"

Si vous revenez à la fenêtre PowerShell précédente et exécutez la commande suivante, vous devez voir le nombre de pods changer dans une courte période :

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

Dans cet exemple, le nombre de pods passe de 1 à 7, comme illustré ici :

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

Si cela n’est pas suffisant pour déclencher la mise à l’échelle automatique du nœud, car tous les pods s’adaptent à un nœud, ouvrez plus de fenêtres PowerShell et exécutez plus de commandes de générateur de charge. Veillez à modifier le nom du pod que vous créez chaque fois que vous exécutez la commande. Par exemple, utilisez load-generator-2 plutôt load-generatorque , comme indiqué dans la commande suivante.

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"

Vérifiez ensuite le nombre de nœuds instanciés avec la commande suivante :

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

Pour regarder un scale-down, appuyez sur Ctrl-C pour mettre fin aux pods du générateur de charge et fermer les fenêtres PowerShell associées à ces pods. Après environ 30 minutes, vous devriez voir le nombre de pods descendre. Environ 30 minutes plus tard, les nœuds sont déprovisionnés.

Pour plus d’informations sur la mise à l’échelle automatique des pods horizontaux Kubernetes, consultez la mise à l’échelle automatique des pods horizontaux.

Règles d’affinité des nœuds

Vous pouvez utiliser des règles d’affinité de nœud pour permettre au planificateur Kubernetes d’exécuter des pods uniquement sur un ensemble spécifique de nœuds dans un cluster ou un pool de nœuds en fonction de certaines caractéristiques du nœud. Pour afficher la fonction de mise à l’échelle automatique de nœud horizontal, vous pouvez utiliser les mêmes règles pour vous assurer qu’une seule instance d’un pod donné s’exécute sur chaque nœud.

Configuration requise :

AKS Arc est installé.
Le cluster cible est installé et connecté à Azure.
Un pool de nœuds Linux est déployé, avec au moins un nœud Worker Linux actif.
La mise à l’échelle automatique de nœud horizontal est activée sur le cluster cible et le pool de nœuds Linux, comme décrit précédemment.

Créez un fichier YAML avec le contenu suivant, puis enregistrez-le en tant que node-anti-affinity.yaml dans un dossier local.

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

Ouvrez une fenêtre PowerShell et chargez les informations d’identification de votre cluster cible. Dans cet exemple, le cluster est nommé mycluster:

Get-AksHciCredential -name mycluster

À présent, appliquez le fichier YAML au cluster cible :

kubectl apply -f node-anti-affinity.yaml

Après quelques minutes, vous pouvez utiliser la commande suivante pour vérifier que les nouveaux nœuds sont en ligne :

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

Pour supprimer le nœud, supprimez le déploiement du serveur redis avec cette commande :

kubectl delete -f node-anti-affinity.yaml

Pour plus d’informations sur les règles d’affinité des pods Kubernetes, consultez Affectation de pods à des nœuds.

Résoudre les problèmes d’autoscaler horizontal

Lorsque l’autoscaler de pod horizontal est activé pour un cluster cible, un nouveau déploiement Kubernetes appelé <cluster_name>-cluster-autoscaler est créé dans le cluster de gestion. Ce déploiement surveille le cluster cible pour s’assurer qu’il y a suffisamment de nœuds Worker pour planifier des pods.

Voici différentes façons de déboguer les problèmes liés à la mise à l’échelle automatique :

Les pods de mise à l’échelle automatique de cluster s’exécutant sur le cluster de gestion collectent des informations utiles sur la façon dont il prend des décisions de mise à l’échelle, le nombre de nœuds dont il a besoin pour afficher ou supprimer, et toutes les erreurs générales qu’il peut rencontrer. Le générateur de mise à l’échelle automatique enregistre ces informations dans les journaux. Exécutez la commande suivante pour accéder aux journaux :
```
kubectl --kubeconfig $(Get-AksHciConfig).Kva.kubeconfig logs -l app=<cluster_name>-cluster-autoscaler
```
Les journaux des opérateurs cloud enregistrent les événements Kubernetes dans le cluster de gestion, ce qui peut être utile pour comprendre quand le générateur de mise à l’échelle automatique a été activé ou désactivé pour un cluster et un pool de nœuds. Celles-ci peuvent être consultées en exécutant la commande suivante :
```
kubectl --kubeconfig $(Get-AksHciConfig).Kva.kubeconfig get events
```
Le déploiement de l’autoscaler de cluster crée un configmap dans le cluster cible qu’il gère. Cela configmap contient des informations sur le niveau de cluster d’état de l’autoscaler et sur chaque pool de nœuds. Exécutez la commande suivante sur le cluster cible pour afficher l’état :

Remarque

Vérifiez que vous avez exécuté Get-AksHciCredentials -Name <clustername> pour récupérer les informations kubeconfig permettant d’accéder au cluster cible en question.
```
kubectl --kubeconfig ~\.kube\config get configmap cluster-autoscaler-status -o yaml
```
Le générateur de mise à l’échelle automatique du cluster journalise les événements sur l’état configmap de mise à l’échelle automatique du cluster lorsqu’il met à l’échelle le pool de nœuds d’un cluster. Vous pouvez afficher ces journaux en exécutant cette commande sur le cluster cible :
```
kubectl --kubeconfig ~\.kube\config describe configmap cluster-autoscaler-status
```
Le programme d’autoscaler du cluster émet des événements sur les pods du cluster cible lorsqu’il prend une décision de mise à l’échelle si le pod ne peut pas être planifié. Exécutez cette commande pour afficher les événements sur un pod :
```
kubectl --kubeconfig ~\.kube\config describe pod <pod_name>
```

Informations de référence sur PowerShell

Consultez les pages de référence suivantes pour les applets de commande PowerShell qui prennent en charge la mise à l’échelle automatique du cluster :

Partager via