Regrouper les pods sur les nœuds avec des profils de planificateur dans Azure Kubernetes Service (AKS) (version préliminaire)

Dans cet article, vous apprendrez à regrouper les pods sur vos nœuds afin d’améliorer l’utilisation des nœuds dans les clusters Azure Kubernetes Service (AKS) à l’aide du plugin de planification intégré NodeResourcesFit. Le planificateur AKS par défaut fonctionne en NodeResourcesFit:LeastAllocated mode, ce qui privilégie les nœuds ayant une utilisation moindre lors de la planification des pods. Les profils planificateurs configurables sur AKS vous permettent de modifier ce comportement par défaut et d’ajuster la configuration pour hiérarchiser les nœuds avec une utilisation plus élevée. Cette documentation couvre trois profils de planificateur personnalisés différents tout en mettant en évidence la recommandation de bonne pratique pour améliorer l’utilisation tout en réduisant les points chauds des nœuds.

L'empaquetage de nœuds est une stratégie de planification qui optimise l'utilisation des ressources en augmentant la concentration des pods sur les nœuds, plutôt que de répartir les pods sur un pool de nœuds avant l'heure ou d'augmenter prématurément l'échelle des nœuds. Le bin packing aide à minimiser les ressources gaspillées et peut réduire le coût opérationnel du maintien des nœuds inactifs ou sous-utilisés. L’amélioration de l’utilisation des nœuds est essentielle, car les données montrent que le processeur et la mémoire sont généralement des ressources sur-demandées. En outre, à mesure que l’adoption du GPU augmente, l’utilisation efficace des accélérateurs devient tout aussi critique en raison de leur rareté relative et de leur coût.

Limites

  • AKS ne gère actuellement pas le déploiement de planificateurs tiers ou de plug-ins de planification hors arborescence.
  • AKS ne prend pas en charge les plug-ins de planification intégrés qui ciblent le planificateur aks-system. Cette restriction est en place pour empêcher les modifications inattendues apportées aux modules complémentaires AKS activés sur votre cluster. En outre, vous ne pouvez pas définir un profile appelé aks-system.

Prerequisites

Activer la configuration du profil du planificateur sur un cluster AKS

Vous pouvez activer la configuration de profil de planification sur un cluster AKS nouveau ou existant.

  1. Créez un cluster AKS avec la configuration du profil du planificateur activée à l’aide de la az aks create commande avec l’indicateur --enable-upstream-kubescheduler-user-configuration .

    # Set environment variables
export RESOURCE_GROUP=<resource-group-name>
export CLUSTER_NAME=<aks-cluster-name>

# Create an AKS cluster with schedule profile configuration enabled
az aks create \
--resource-group $RESOURCE_GROUP \ 
--name $CLUSTER_NAME \
--enable-upstream-kubescheduler-user-configuration \
--generate-ssh-keys

  2. Une fois le processus de création terminé, connectez-vous au cluster à l’aide de la az aks get-credentials commande.

    az aks get-credentials --resource-group $RESOURCE_GROUP --name $CLUSTER_NAME

Vérifier l’installation du contrôleur du planificateur

  • Après avoir activé la fonctionnalité sur votre cluster AKS, vérifiez que la définition de ressource personnalisée (CRD) du contrôleur du planificateur a été correctement installée à l’aide de la kubectl get commande.

    kubectl get crd schedulerconfigurations.aks.azure.com

    Note

    Cette commande ne réussit pas si la fonctionnalité n’a pas été activée correctement dans la section précédente.

Configurer le bin-packing des nœuds avec le module RequestedtoCapacity

Parmi les trois profils, RequestedToCapacityRatio offre le contrôle utilisateur le plus fin pour associer les nœuds à un niveau d’utilisation explicite. Par exemple, ce profil de planification a été configuré pour favoriser les nœuds au sein d’une bande d’utilisation de 50 à 85%, éviter les nœuds vides et déprioritiser sévèrement les nœuds presque complets à 90% utilisation ou plus, laissant une marge de travail supplémentaire. Compte tenu de ce niveau de précision, RequestedtoCapacity constitue la stratégie de scoring recommandée pour le regroupement des pods sur les nœuds dans les clusters AKS en production.

Cette configuration fait de l’utilisation du processeur le facteur dominant dans la sélection des nœuds, en empaquetant les nœuds tout en évitant la saturation excessive pour les applications gourmandes en CPU. Enfin, vous devez désactiver le PodTopologySpread plug-in, car, s'il est activé par défaut, il peut remplacer le score pondéré de NodeResourcesFit.

  • NodeResourcesFit contrôle la façon dont le planificateur évalue si un nœud a suffisamment de ressources pour exécuter un pod.
  • scoringStrategy: RequestedToCapacityRatio évalue les nœuds en fonction du ratio des ressources demandées par rapport à la capacité totale du nœud une fois que le pod est hypothétiquement placé.
  • Resources spécifie que CPU et Memory sont les ressources principales prises en compte pour l'évaluation. Avec un poids de 8, les nœuds avec une utilisation CPU sont notés 8 fois plus fortement que la mémoire pendant le cycle de planification des pods. Cela augmente la probabilité que les nœuds avec une utilisation élevée soient sélectionnés.
  • shape: associe l’utilisation du nœud au score du planificateur. Chaque point représente un pourcentage d’utilisation et son score correspondant, avec un score linéaire entre les points.
apiVersion: aks.azure.com/v1alpha1
kind: SchedulerConfiguration
metadata:
  name: upstream
spec:
  rawConfig: |
    apiVersion: kubescheduler.config.k8s.io/v1
    kind: KubeSchedulerConfiguration
    profiles:
      - schedulerName: cpu-binpack-scheduler-RtC
        plugins:
          multiPoint:
            enabled:
              - name: NodeResourcesFit
            disabled:
              - name: PodTopologySpread
        pluginConfig:
          - name: NodeResourcesFit
            args:
              apiVersion: kubescheduler.config.k8s.io/v1
              kind: NodeResourcesFitArgs
              scoringStrategy:
                type: RequestedToCapacityRatio
                resources:
                  - name: cpu
                    weight: 8
                  - name: memory
                    weight: 1
                requestedToCapacityRatio:
                  shape:
                    - utilization: 0
                      score: 0
                    - utilization: 30
                      score: 9
                    - utilization: 50
                      score: 10
                    - utilization: 85
                      score: 10
                    - utilization: 90
                      score: 5
                    - utilization: 100
                      score: 0

Configurer le regroupement des pods sur les nœuds avec le plugin MostAllocated

La configuration du planificateur avec MostAllocated hiérarchise exclusivement les nœuds en fonction de l’utilisation des ressources. Plus l’utilisation des ressources est élevée, plus un nœud obtient un score élevé, ce qui évite de laisser des nœuds inutilisés ou de déclencher une montée en charge avant que cela ne soit nécessaire. En cas d'isolation, cette configuration risque de saturer les nœuds au-delà des limites souhaitables, provoquant un étranglement ou des goulots d’étranglement supplémentaires.

Cette configuration rend l’utilisation du processeur le facteur dominant dans la sélection de nœuds. Pour garantir un comportement cohérent, vous devez désactiver le plugin PodTopologySpread, car il peut remplacer le score pondéré de NodeResourcesFit s’il reste activé par défaut.

  • NodeResourcesFit contrôle la façon dont le planificateur évalue si un nœud a suffisamment de ressources pour exécuter un pod.
  • scoringStrategy: MostAllocated calcule un score basé sur les demandes de ressources des pods. MostAllocated indique au planificateur de préférer les nœuds avec une utilisation élevée des ressources. Cette stratégie favorise le placement dense des pods et permet d’obtenir une meilleure utilisation des nœuds.
  • Resources spécifie que CPU et Memory sont les ressources principales prises en compte pour l'évaluation. Avec un poids de 8, les nœuds avec une utilisation CPU sont notés 8 fois plus fortement que la mémoire pendant le cycle de planification des pods. Cela augmente la probabilité que les nœuds avec une utilisation élevée soient sélectionnés.
apiVersion: aks.azure.com/v1alpha1
kind: SchedulerConfiguration
metadata:
  name: upstream
spec:
  rawConfig: |
    apiVersion: kubescheduler.config.k8s.io/v1
    kind: KubeSchedulerConfiguration
    profiles:
      - schedulerName: cpu-binpack-scheduler-mA
        plugins:
          multiPoint:
            enabled:
              - name: NodeResourcesFit
            disabled:
              - name: PodTopologySpread
        pluginConfig:
          # NodeResourcesFit configuration
          - name: NodeResourcesFit
            args:
              apiVersion: kubescheduler.config.k8s.io/v1
              kind: NodeResourcesFitArgs
              scoringStrategy:
                type: MostAllocated
                resources:
                  - name: cpu
                    weight: 8
                  - name: memory
                    weight: 1

calcule un score basé sur les demandes de ressources des pods.

Cette configuration cherche à ajouter des garde-fous à la stratégie MostAllocated simple et efficace en évaluant les nœuds en fonction de l’utilisation équilibrée des ressources ciblées. NodeResourcesBalancedAllocation encourage le positionnement des pods sur les nœuds avec une utilisation proportionnelle définie par l’utilisateur, ce qui augmente l’efficacité globale tout en évitant les goulots d’étranglement causés par la pression asymétrique des ressources. Par exemple, les nœuds liés au processeur avec une mémoire abondante inutilisée sont notés plus bas en faveur des nœuds avec un meilleur équilibre entre l’utilisation du processeur et de la mémoire.

  • NodeResourcesBalancedAllocation score les nœuds en fonction de la façon dont l’utilisation équilibrée des ressources est répartie sur plusieurs ressources. Au lieu d’optimiser l’utilisation d’une seule ressource, ce plug-in préfère les nœuds où la consommation de ressources est proportionnelle.
  • Resources spécifie les ressources prises en compte lors de l’évaluation de l’équilibre. Avec l’UC et la mémoire pondérées de manière égale, les nœuds reçoivent de meilleurs scores lorsque les deux ressources sont consommées à des niveaux similaires.
apiVersion: aks.azure.com/v1alpha1
kind: SchedulerConfiguration
metadata:
  name: upstream
spec:
  rawConfig: |
    apiVersion: kubescheduler.config.k8s.io/v1
    kind: KubeSchedulerConfiguration
    profiles:
      - schedulerName: cpu-binpack-scheduler-mA-BalancedAllocation
        plugins:
          multiPoint:
            enabled:
              - name: NodeResourcesFit
              - name: NodeResourcesBalancedAllocation
            disabled:
              - name: PodTopologySpread
        pluginConfig:
          # NodeResourcesFit configuration
          - name: NodeResourcesFit
            args:
              apiVersion: kubescheduler.config.k8s.io/v1
              kind: NodeResourcesFitArgs
              scoringStrategy:
                type: MostAllocated
                resources:
                  - name: cpu
                    weight: 8
                  - name: memory
                    weight: 1
          - name: NodeResourcesBalancedAllocation
            args:
              apiVersion: kubescheduler.config.k8s.io/v1
              kind: NodeResourcesBalancedAllocationArgs
              resources:
                - name: cpu
                  weight: 1
                - name: memory
                  weight: 1

Attribuer un profil de planificateur à un cluster AKS entier

  1. Créer un fichier nommé cpu-bin-packing-scheduler.yaml, avec le CRD nommé upstream

  2. Appliquez le manifeste de configuration de planification à l’aide de la kubectl apply commande.

    kubectl apply -f cpu-bin-packing-scheduler.yaml

  3. Pour cibler ce mécanisme de planification pour des charges de travail spécifiques, mettez à jour vos déploiements de pods avec les éléments suivants schedulerName:

    ...
...
    spec:
      schedulerName: binpacking-scheduler
...
...

Étapes suivantes

Pour en savoir plus sur le planificateur AKS, d’autres configurations et meilleures pratiques, consultez les ressources suivantes :

  • Last updated on