Planification prioritaire personnalisée des ressources - Container Compute Service

ACS fournit des ressources via des nœuds virtuels, ce qui rend la disponibilité des instances dynamique. Lorsqu'une classe de calcul ou un niveau de QoS spécifique est en rupture de stock, les pods restent à l'état Pending en l'absence de stratégie de repli. La planification prioritaire personnalisée permet de définir une liste ordonnée de combinaisons de classes de calcul et de QoS. Le planificateur teste chaque option séquentiellement jusqu'à obtenir un résultat positif. Il utilise ce même ordre, inversé, pour déterminer quels pods supprimer en priorité lors d'une réduction de capacité.

Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants :

kube-scheduler installé dans une version répondant aux exigences suivantes :

Version du cluster ACS	Version minimale du planificateur
1.31	v1.31.0-aliyun-1.2.0
1.30	v1.30.3-aliyun-1.1.1
1.28	v1.28.9-aliyun-1.1.0

acs-virtual-node installé en version v2.12.0-acs.4 ou ultérieure.

Fonctionnement

Une ResourcePolicy est une ressource personnalisée (CRD) qui s'interpose entre le cluster et les charges de travail individuelles. Elle sélectionne un groupe de pods par libellé et définit une liste ordonnée de propriétés de ressources. Lorsqu'un pod correspondant au sélecteur doit être planifié, le planificateur parcourt chaque entrée de la liste dans l'ordre défini. Si le stock d'une entrée est insuffisant, il passe à la suivante. En cas de rupture de stock sur toutes les entrées, le pod reste à l'état Pending et le planificateur réessaie continuellement jusqu'à ce que des ressources se libèrent.

Les modifications apportées à une ResourcePolicy ne concernent que les pods créés après la mise à jour. Les pods en cours d'exécution ne sont pas replanifiés.

Ordre de réduction de capacité

ACS utilise la fonctionnalité Kubernetes de coût de suppression de pod pour contrôler l'ordre de réduction de capacité. En théorie, le pod avec le coût de suppression le plus faible est supprimé en premier. Toutefois, l'algorithme de réduction prend en compte divers facteurs dépendant de l'implémentation du contrôleur de pod.

ACS définit automatiquement l'annotation controller.kubernetes.io/pod-deletion-cost en fonction de la priorité de planification de chaque pod. Si vos pods portent déjà cette annotation, ACS en écrase la valeur.

Classes de calcul prises en charge

Pour consulter les classes de calcul compatibles avec la planification prioritaire personnalisée, reportez-vous à la rubrique Classes de calcul.

Avertissement

N'utilisez pas alibabacloud.com/compute-class ni alibabacloud.com/compute-qos dans le champ spec.selector.matchLabels d'une charge de travail (comme un Deployment). ACS peut modifier ces libellés pendant la planification, ce qui force le contrôleur à recréer les pods de manière répétée et déstabilise l'application.

Créer une ResourcePolicy

Créez un fichier nommé resource-policy.yaml avec le contenu suivant. L'exemple ci-dessous définit une politique pour les pods portant le libellé app: stress. Il tente d'abord d'allouer general-purpose + best-effort, puis se rabat sur general-purpose + default.

apiVersion: scheduling.alibabacloud.com/v1alpha1
kind: ResourcePolicy
metadata:
  name: rp-demo
  namespace: default
spec:
  selector:
    app: stress        # Applies to pods with this label
  units:
  - resource: acs      # First choice: general-purpose, best-effort
    podLabels:
      alibabacloud.com/compute-class: general-purpose
      alibabacloud.com/compute-qos: best-effort
  - resource: acs      # Fallback: general-purpose, default
    podLabels:
      alibabacloud.com/compute-class: general-purpose
      alibabacloud.com/compute-qos: default

Appliquez la ResourcePolicy au cluster.
```
kubectl apply -f resource-policy.yaml
```

Créez une charge de travail. Définissez les libellés des pods pour qu'ils correspondent au champ selector de la ResourcePolicy. L'exemple suivant utilise un Job. Le modèle de pod porte le libellé app: stress, ce qui l'associe à la politique définie précédemment.

apiVersion: batch/v1
kind: Job
metadata:
  name: demo-job
  namespace: default
spec:
  parallelism: 3
  template:
    metadata:
      labels:
        app: stress    # Must match spec.selector in the ResourcePolicy
    spec:
      containers:
      - name: demo-job
        image: registry.cn-hangzhou.aliyuncs.com/acs/stress:v1.0.4
        args:
          - 'infinity'
        command:
          - sleep
        resources:
          requests:
            cpu: "1"
            memory: "1Gi"
          limits:
            cpu: "1"
            memory: "1Gi"
      restartPolicy: Never
  backoffLimit: 4

Configuration avancée

Le YAML annoté suivant présente la structure complète d'une ResourcePolicy pour les clusters ACS.

Remarque

Cette page couvre les configurations ACS courantes. Pour consulter la référence complète des champs ResourcePolicy, reportez-vous à la rubrique Planification prioritaire personnalisée des ressources élastiques.

apiVersion: scheduling.alibabacloud.com/v1alpha1
kind: ResourcePolicy
metadata:
  name: rp-demo
  namespace: default
spec:
  # Selector: identifies which pods follow this policy
  selector:
    app: stress

  # Units: ordered list of resource options
  units:
  - resource: acs        # Must be set to "acs"
    podLabels:
      alibabacloud.com/compute-class: general-purpose
      alibabacloud.com/compute-qos: best-effort
    nodeSelector:        # Optional: restrict to a specific zone
      topology.kubernetes.io/zone: cn-hangzhou-i
  - resource: acs
    podLabels:
      alibabacloud.com/compute-class: general-purpose
      alibabacloud.com/compute-qos: default
  # Fields not listed here apply to non-ACS clusters and can be ignored.

Configuration de l'application

Champ	Type	Description	Exemple
`selector`	`map[string]string`	Les pods portant tous les libellés listés suivent cette ResourcePolicy.	`app: stress`

Configuration des ressources

Chaque entrée du tableau units décrit une option de ressource. Le planificateur teste ces entrées dans l'ordre.

Champ	Type	Description	Valeurs autorisées
`resource`	string	Type de ressource. Obligatoire.	`acs`
`nodeSelector`	`map[string]string`	Filtre les nœuds virtuels par libellé, par exemple par zone. Consultez la rubrique Planification par affinité de nœud.	`topology.kubernetes.io/zone: cn-hangzhou-i`
`podLabels[alibabacloud.com/compute-class]`	string	Classe de calcul pour le pod.	`general-purpose` (par défaut), `performance`
`podLabels[alibabacloud.com/compute-qos]`	string	Niveau de QoS de calcul pour le pod.	`default` (par défaut), `best-effort`

Exemple : repli prioritaire avec mise à l'échelle horizontale

Cet exemple illustre l'utilisation d'une ResourcePolicy pour demander en priorité des ressources performance + default, puis se rabattre sur general-purpose + best-effort lors de la montée en charge.

Créez le fichier resource-policy.yaml contenant une politique initiale à unité unique.

apiVersion: scheduling.alibabacloud.com/v1alpha1
kind: ResourcePolicy
metadata:
  name: stress-demo
  namespace: default
spec:
  selector:
    app: stress
  units:
  - resource: acs
    podLabels:
      alibabacloud.com/compute-class: performance
      alibabacloud.com/compute-qos: default

Appliquez la ResourcePolicy.
```
kubectl apply -f resource-policy.yaml
```

Créez le fichier stress-dep.yaml pour le Deployment.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: stress
spec:
  replicas: 1
  selector:
    matchLabels:
      app: stress
  template:
    metadata:
      labels:
        app: stress    # Keep this consistent with the ResourcePolicy selector
    spec:
      containers:
      - name: stress
        image: registry-cn-hangzhou.ack.aliyuncs.com/acs/stress:v1.0.4
        command:
        - "sleep"
        - "infinity"
        resources:
          limits:
            cpu: '1'
            memory: 1Gi
          requests:
            cpu: '1'
            memory: 1Gi

Déployez l'application.
```
kubectl apply -f stress-dep.yaml
```

Vérifiez que le pod s'exécute avec la classe de calcul et le niveau de QoS attendus.

kubectl get pod -L alibabacloud.com/compute-class,alibabacloud.com/compute-qos

Sortie attendue :

# Actual output depends on resource availability.
NAME               READY   STATUS    RESTARTS   AGE   COMPUTE-CLASS   COMPUTE-QOS
stress-xxxxxxxx1   1/1     Running   0          53s   performance     default

Mettez à jour le fichier resource-policy.yaml pour ajouter une unité de repli. La politique mise à jour tente d'abord general-purpose + best-effort, puis se rabat sur performance + default.

apiVersion: scheduling.alibabacloud.com/v1alpha1
kind: ResourcePolicy
metadata:
  name: stress-demo
  namespace: default
spec:
  selector:
    app: stress
  units:
  - resource: acs
    podLabels:
      alibabacloud.com/compute-class: general-purpose
      alibabacloud.com/compute-qos: best-effort
  - resource: acs
    podLabels:
      alibabacloud.com/compute-class: performance
      alibabacloud.com/compute-qos: default

Appliquez la ResourcePolicy mise à jour. La modification prend effet pour les pods créés ultérieurement.
```
kubectl apply -f resource-policy.yaml
```

Passez le Deployment à deux réplicas.

kubectl scale deployment stress --replicas=2

Vérifiez que les deux pods s'exécutent et que le nouveau réplica utilise les ressources de premier choix.

kubectl get pod -L alibabacloud.com/compute-class,alibabacloud.com/compute-qos

Sortie attendue :

# Actual output depends on resource availability.
NAME                     READY   STATUS    RESTARTS   AGE     COMPUTE-CLASS     COMPUTE-QOS
stress-xxxxxxxx1         1/1     Running   0          2m14s   performance       default
stress-xxxxxxxx2         1/1     Running   0          33s     general-purpose   best-effort

Le nouveau réplica utilise general-purpose + best-effort, ce qui confirme que la politique mise à jour s'applique bien au pod nouvellement créé.

Étapes suivantes

Planification prioritaire personnalisée des ressources élastiques — Référence complète des champs ResourcePolicy
Planification par affinité de nœud — Libellés pris en charge pour nodeSelector
Classes de calcul — Classes de calcul disponibles pour la planification prioritaire personnalisée