Partager via

Utiliser PowerShell pour la mise à l’échelle automatique du cluster dans AKS sur Windows Server

S’applique à : 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 sur Windows Server. 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 nouvel objet AksHciAutoScalerConfig à transmettre à la commande New-AksHciCluster ou Set-AksHciCluster, 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 autoscalerconfig, qui contient les paramètres de votre autoscalage. 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 automatiquement la mise à l'échelle sur chaque pool de nœuds nouvellement créé dans un cluster existant, utilisez le paramètre enableAutoScaler avec la commande Set-AksHciCluster :

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

Utiliser efficacement l'autoscaler horizontal

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 :

  • Kubernetes Horizontal Pod Autoscaler : en fonction des caractéristiques de charge, Horizontal Pod Autoscaler (également appelé « horizontal autoscaler ») adapte les pods d'un déploiement d'application aux 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 sur lequel planifier les pods. Si la charge de l'application diminue, les nœuds sont de nouveau redimensionnés.
  • 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, l'autoscaler horizontal instancie de nouveaux nœuds dans le pool de nœuds afin de satisfaire les requêtes. 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 sur Windows Server 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 Kubernetes Horizontal Pod Autoscaler Walkthrough pour montrer comment fonctionne la mise à l’échelle automatique des pods horizontaux.

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 ne suffit pas pour déclencher l'autoscaler de nœuds parce que tous les pods tiennent sur un seul nœud, ouvrez d'autres fenêtres PowerShell et exécutez d'autres commandes du 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 observer une réduction d'échelle, appuyez sur Ctrl-C pour arrêter les pods du générateur de charge et fermer les fenêtres PowerShell qui leur sont associées. 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 le Kubernetes Horizontal Pod Autoscaler, consultez Horizontal Pod Autoscaling.

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 du cluster s’exécutant sur le cluster de gestion collectent des informations utiles sur la façon dont ils prennent des décisions de mise à l’échelle, le nombre de nœuds qu'ils ont besoin d'ajouter ou de supprimer, et les erreurs générales qu’ils pourraient rencontrer. L'autoscaler enregistre ces informations dans les journaux d'activité. 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. Ce configmap contient des informations sur l'état de l'autoscaler au niveau global du cluster et pour 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 cluster autoscaler consigne les événements dans le journal d'activité du cluster autoscaler configmap lorsqu'il redimensionne 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 :

Étapes suivantes