Container Service for Kubernetes:Dynamically modify pod resource parameters

Fonctionnement

ACK utilise une définition de ressource personnalisée (CRD) de type kind: Cgroups pour transmettre les modifications de ressources à ack-koordinator. Lorsque vous appliquez une ressource Cgroups, koordlet sur le nœud écrit directement les nouvelles valeurs dans les fichiers cgroup, en contournant l'ordonnanceur Kubernetes et la boucle de réconciliation kubelet. Le PodSpec du pod reste inchangé ; seules les valeurs cgroup sur le nœud sont mises à jour.

Utilisez spec.pod pour cibler un pod spécifique, ou spec.deployment pour cibler tous les pods d'un déploiement.

Prérequis

Assurez-vous que :

• kubectl est connecté au cluster ACK.

• La version ack-koordinator 0.5.0 ou ultérieure est installée.

Facturation

L'installation et l'utilisation d'ack-koordinator sont gratuites. Des frais supplémentaires peuvent s'appliquer dans les situations suivantes :

• Ressources des nœuds de travail : ack-koordinator est un module complémentaire non géré qui consomme des ressources sur les nœuds de travail après l'installation. Spécifiez les demandes de ressources pour chaque module lors de l'installation du module complémentaire.

• Métriques de surveillance Prometheus : Si vous activez l'option Enable Prometheus monitoring metrics for ACK-Koordinator et utilisez Managed Service for Prometheus, les métriques sont facturées en tant que métriques personnalisées. Les frais dépendent de la taille du cluster et du nombre d'applications. Consultez la documentation relative à la facturation des instances Prometheus et utilisez la fonction requête d'utilisation pour surveiller la consommation avant d'activer cette fonctionnalité.

Limites

Modification de la limite de mémoire

Augmentez la limite de mémoire d'un pod pour éviter les arrêts OOM (Out Of Memory) sans le redémarrer. Cet exemple augmente la limite de 1 GiB à 5 GiB.

1. Créez le fichier pod-demo.yaml avec le contenu suivant.

   apiVersion: v1
   kind: Pod
   metadata:
     name: pod-demo
   spec:
     containers:
     - name: pod-demo
       image: registry-cn-beijing.ack.aliyuncs.com/acs/stress:v1.0.4
       resources:
         requests:
           cpu: 1
           memory: "50Mi"
         limits:
           cpu: 1
           memory: "1Gi" # Initial memory limit: 1 GiB
       command: ["stress"]
       args: ["--vm", "1", "--vm-bytes", "256M", "-c", "2", "--vm-hang", "1"]

2. Déployez le pod.

   kubectl apply -f pod-demo.yaml

3. Vérifiez la limite de mémoire initiale. Le chemin cgroup est construit à partir de l'UID du pod et de l'ID du conteneur.

   cat /sys/fs/cgroup/memory/kubepods.slice/kubepods-burstable.slice/kubepods-burstable-podaf44b779_41d8_43d5_a0d8_8a7a0b17****.slice/memory.limit_in_bytes

   Résultat attendu :

   1073741824

   1073741824 = 1 GiB, ce qui correspond à spec.containers.resources.limits.memory dans la définition du pod.

4. Créez le fichier cgroups-sample.yaml pour définir la nouvelle limite de mémoire.

   apiVersion: resources.alibabacloud.com/v1alpha1
   kind: Cgroups
   metadata:
     name: cgroups-sample
   spec:
     pod:
       name: pod-demo
       namespace: default
       containers:
       - name: pod-demo
         memory: 5Gi  # New memory limit: 5 GiB

5. Appliquez la ressource Cgroups.

   kubectl apply -f cgroups-sample.yaml

6. Vérifiez la limite de mémoire mise à jour.

   cat /sys/fs/cgroup/memory/kubepods.slice/kubepods-burstable.slice/kubepods-burstable-podaf44b779_41d8_43d5_a0d8_8a7a0b17****.slice/memory.limit_in_bytes

   Résultat attendu :

   5368709120

   5368709120 = 5 GiB, ce qui correspond à spec.pod.containers.memory dans la ressource Cgroups.

7. Confirmez que le pod n'a pas été redémarré.

   kubectl describe pod pod-demo

   Confirmez l'absence d'événements de redémarrage dans la section Events — seuls les événements de planification et de démarrage d'origine sont présents :

   Events:
     Type    Reason          Age   From               Message
     ----    ------          ----  ----               -------
     Normal  Scheduled       36m   default-scheduler  Successfully assigned default/pod-demo to cn-hangzhou.192.168.0.50
     Normal  AllocIPSucceed  36m   terway-daemon      Alloc IP 192.XX.XX.51/24 took 4.490542543s
     Normal  Pulling         36m   kubelet            Pulling image "registry-cn-beijing.ack.aliyuncs.com/acs/stress:v1.0.4"
     Normal  Pulled          36m   kubelet            Successfully pulled image "registry-cn-beijing.ack.aliyuncs.com/acs/stress:v1.0.4" in 2.204s (2.204s including waiting). Image size: 7755078 bytes.
     Normal  Created         36m   kubelet            Created container pod-demo
     Normal  Started         36m   kubelet            Started container pod-demo

   L'absence d'événements de redémarrage confirme que la limite de mémoire a été mise à jour directement.

Modification de l'étendue de liaison des cœurs CPU

Lie un pod à des cœurs CPU spécifiques pour une isolation plus stricte des ressources. Cet exemple restreint un pod, initialement autorisé sur les 32 cœurs (0–31), aux cœurs 2–3.

1. Créez le fichier pod-cpuset-demo.yaml avec le contenu suivant.

   apiVersion: v1
   kind: Pod
   metadata:
     name: pod-cpuset-demo
   spec:
     containers:
     - name: pod-cpuset-demo
       image: registry-cn-beijing.ack.aliyuncs.com/acs/stress:v1.0.4
       resources:
         requests:
           memory: "50Mi"
         limits:
           memory: "1000Mi"
           cpu: 0.5
       command: ["stress"]
       args: ["--vm", "1", "--vm-bytes", "556M", "-c", "2", "--vm-hang", "1"]

2. Déployez le pod.

   kubectl apply -f pod-cpuset-demo.yaml

3. Vérifiez la liaison actuelle des cœurs CPU. Le chemin est construit à partir de l'UID du pod et de l'ID du conteneur.

   cat /sys/fs/cgroup/cpuset/kubepods.slice/kubepods-burstable.slice/kubepods-burstable-podf9b79bee_eb2a_4b67_befe_51c270f8****.slice/cri-containerd-aba883f8b3ae696e99c3a920a578e3649fa957c51522f3fb00ca943dc2c7****.scope/cpuset.cpus

   Résultat attendu :

   0-31

   0-31 signifie que le conteneur peut utiliser les 32 cœurs CPU.

4. Créez le fichier cgroups-sample-cpusetpod.yaml pour définir la liaison CPU.

   apiVersion: resources.alibabacloud.com/v1alpha1
   kind: Cgroups
   metadata:
     name: cgroups-sample-cpusetpod
   spec:
     pod:
       name: pod-cpuset-demo
       namespace: default
       containers:
       - name: pod-cpuset-demo
         cpuset-cpus: 2-3  # Restrict the pod to CPU cores 2 and 3

5. Appliquez la ressource Cgroups.

   kubectl apply -f cgroups-sample-cpusetpod.yaml

6. Vérifiez la liaison CPU mise à jour.

   cat /sys/fs/cgroup/cpuset/kubepods.slice/kubepods-burstable.slice/kubepods-burstable-podf9b79bee_eb2a_4b67_befe_51c270f8****.slice/cri-containerd-aba883f8b3ae696e99c3a920a578e3649fa957c51522f3fb00ca943dc2c7****.scope/cpuset.cpus

   Résultat attendu :

   2-3

   Le conteneur est lié aux cœurs 2–3, ce qui correspond à spec.pod.containers.cpuset-cpus dans la ressource Cgroups.

7. Confirmez que le pod n'a pas été redémarré.

   kubectl describe pod pod-cpuset-demo

   La section Events inclut un événement CPUSetBind de koordlet, mais aucun événement de redémarrage :

   Events:
     Type    Reason          Age   From               Message
     ----    ------          ----  ----               -------
     Normal  Scheduled       7m7s  default-scheduler  Successfully assigned default/pod-cpuset-demo to cn-hangzhou.192.XX.XX.50
     Normal  AllocIPSucceed  7m5s  terway-daemon      Alloc IP 192.XX.XX.56/24 took 2.060752512s
     Normal  Pulled          7m5s  kubelet            Container image "registry-cn-beijing.ack.aliyuncs.com/acs/stress:v1.0.4" already present on machine
     Normal  Created         7m5s  kubelet            Created container pod-cpuset-demo
     Normal  Started         7m5s  kubelet            Started container pod-cpuset-demo
     Normal  CPUSetBind      84s   koordlet           set cpuset 2-3 to container pod-cpuset-demo success

Modification des paramètres d'E/S disque

Cet exemple déploie une charge de travail fio et limite son débit d'écriture via un fichier cgroup.

1. Créez le fichier fio-demo.yaml avec le contenu suivant. Le répertoire hôte /mnt est monté sur /data dans le pod, mappé sur /dev/vda1.

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: fio-demo
     labels:
       app: fio-demo
   spec:
     selector:
       matchLabels:
         app: fio-demo
     template:
       metadata:
         labels:
           app: fio-demo
       spec:
         containers:
         - name: fio-demo
           image: registry.cn-zhangjiakou.aliyuncs.com/acs/fio-for-slo-test:v0.1
           command: ["sh", "-c"]
           # Run a sequential write test on disk I/O using fio
           args: ["fio -filename=/data/test -direct=1 -iodepth 1 -thread -rw=write -ioengine=psync -bs=16k -size=2G -numjobs=10 -runtime=12000 -group_reporting -name=mytest"]
           volumeMounts:
             - name: pvc
               mountPath: /data
         volumes:
           - name: pvc
             hostPath:
               path: /mnt

2. Déployez l'application.

   kubectl apply -f fio-demo.yaml

3. Limitez le débit d'écriture à l'aide d'un fichier cgroup.

   1. Créez le fichier cgroups-sample-fio.yaml pour définir une limite d'écriture en octets par seconde (BPS) sur /dev/vda1.

      apiVersion: resources.alibabacloud.com/v1alpha1
      kind: Cgroups
      metadata:
        name: cgroups-sample-fio
      spec:
        deployment:
          name: fio-demo
          namespace: default
          containers:
          - name: fio-demo
            blkio:
              # BPS limit in bytes per second (e.g., 1048576 = 1 MiB/s)
              device_write_bps: [{device: "/dev/vda1", value: "1048576"}]

   2. Appliquez la ressource Cgroups.

      kubectl apply -f cgroups-sample-fio.yaml

   3. Vérifiez la limite d'E/S disque mise à jour. Le chemin est construit à partir de l'UID du pod et de l'ID du conteneur.

      cat /sys/fs/cgroup/blkio/kubepods.slice/kubepods-besteffort.slice/kubepods-besteffort-pod0840adda_bc26_4870_adba_f193cd00****.slice/cri-containerd-9ea6cc97a6de902d941199db2fcda872ddd543485f5f987498e40cd706dc****.scope/blkio.throttle.write_bps_device

      Résultat attendu :

      253:0 1048576

      La limite BPS d'écriture est de 1048576 (1 MiB/s) pour le périphérique 253:0 (/dev/vda1). Le pod n'a pas été redémarré.

4. Pour afficher les données de surveillance du disque dans Prometheus, accédez à la console et choisissez Operations > Prometheus Monitoring. Dans l'onglet Application Monitoring, filtrez pour l'application exemple. Consultez la rubrique Connexion et configuration de la surveillance Alibaba Cloud Prometheus.

Application des modifications au niveau du déploiement

Toutes les procédures ci-dessus fonctionnent également au niveau du déploiement : utilisez spec.deployment au lieu de spec.pod. Cet exemple applique la liaison des cœurs CPU à un déploiement.

1. Créez le fichier go-demo.yaml avec le contenu suivant. Ce déploiement exécute deux répliques avec 0,5 CPU chacune.

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: go-demo
     labels:
       app: go-demo
   spec:
     replicas: 2
     selector:
       matchLabels:
         app: go-demo
     template:
       metadata:
         labels:
           app: go-demo
       spec:
         containers:
         - name: go-demo
           image: registry-cn-beijing.ack.aliyuncs.com/acs/stress:v1.0.4
           command: ["stress"]
           args: ["--vm", "1", "--vm-bytes", "556M", "-c", "1", "--vm-hang", "1"]
           imagePullPolicy: Always
           resources:
             requests:
               cpu: 0.5
             limits:
               cpu: 0.5

2. Déployez l'application.

   kubectl apply -f go-demo.yaml

3. Créez le fichier cgroups-cpuset-sample.yaml pour lier les pods du déploiement à des cœurs CPU spécifiques.

   apiVersion: resources.alibabacloud.com/v1alpha1
   kind: Cgroups
   metadata:
     name: cgroups-cpuset-sample
   spec:
     deployment: # Targets a Deployment, not a single pod
       name: go-demo
       namespace: default
       containers:
       - name: go-demo
         cpuset-cpus: 2,3 # Bind to CPU cores 2 and 3

4. Appliquez la ressource Cgroups.

   kubectl apply -f cgroups-cpuset-sample.yaml

5. Vérifiez la liaison CPU pour l'un des pods. Le chemin est construit à partir de l'UID du pod et de l'ID du conteneur.

   cat /sys/fs/cgroup/cpuset/kubepods.slice/kubepods-burstable.slice/kubepods-burstable-pod06de7408_346a_4d00_ba25_02833b6c****.slice/cri-containerd-733a0dc93480eb47ac6c5abfade5c22ed41639958e3d304ca1f85959edc3****.scope/cpuset.cpus

   Résultat attendu :

   2-3

   Le conteneur est lié aux cœurs 2–3, ce qui correspond à spec.deployment.containers.cpuset-cpus dans la ressource Cgroups.

Étapes suivantes

• CPU Burst : Les conteneurs accumulent les tranches de temps CPU inutilisées et les dépensent lors des pics de trafic, réduisant ainsi la latence et améliorant la qualité de service. Consultez la rubrique Activation de la stratégie CPU Burst.

• Ordonnancement conscient de la topologie CPU : Épinglez les pods à des cœurs CPU spécifiques au moment de l'ordonnancement pour éliminer la surcharge des commutations de contexte CPU et l'accès mémoire cross-NUMA. Consultez la rubrique Activation de l'ordonnancement conscient de la topologie CPU.

• Survente dynamique des ressources : Récupérez les ressources allouées mais inutilisées et rendez-les disponibles pour les charges de travail de priorité inférieure. Combinez cette approche avec des politiques QoS à nœud unique pour éviter les interférences de performances entre les applications. Consultez la rubrique Activation de la survente dynamique des ressources.

• Profilage des ressources : Analysez les données d'utilisation historiques pour obtenir des recommandations de dimensionnement correct pour les demandes et les limites des conteneurs. Consultez la rubrique Profilage des ressources.