Container Service for Kubernetes:Dynamically modify pod resource parameters

Funcionamiento

ACK utiliza una definición de recurso personalizado (CRD) de tipo kind: Cgroups para transmitir los cambios de recursos a ack-koordinator. Al aplicar un recurso Cgroups, koordlet en el nodo escribe los nuevos valores directamente en los archivos de cgroup, sin pasar por el programador de Kubernetes ni el ciclo de reconciliación de kubelet. El PodSpec del pod permanece sin cambios; solo se actualizan los valores de cgroup en el nodo.

Utilice spec.pod para dirigirse a un pod específico, o spec.deployment para aplicar cambios a todos los pods de un Deployment.

Requisitos previos

Asegúrese de cumplir con lo siguiente:

• kubectl está conectado al clúster de ACK.

• ack-koordinator versión 0.5.0 o posterior está instalado.

Facturación

ack-koordinator es gratuito para su instalación y uso. Sin embargo, pueden generarse cargos adicionales en las siguientes situaciones:

• Recursos de nodos worker: ack-koordinator es un complemento no administrado que consume recursos en los nodos worker tras su instalación. Especifique las solicitudes de recursos para cada módulo al instalar el complemento.

• Métricas de monitoreo de Prometheus: Si habilita la opción Enable Prometheus monitoring metrics for ACK-Koordinator y utiliza Managed Service for Prometheus, las métricas se facturan como métricas personalizadas. Los costos dependen del tamaño del clúster y del número de aplicaciones. Revise la documentación sobre facturación de instancias de Prometheus y utilice la consulta de uso para supervisar el consumo antes de habilitar esta función.

Límites

Modificación del límite de memoria

Incremente el límite de memoria de un pod para evitar terminaciones por OOM sin necesidad de reiniciarlo. Este ejemplo eleva el límite de 1 GiB a 5 GiB.

1. Cree el archivo pod-demo.yaml con el siguiente contenido.

   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. Despliegue el pod.

   kubectl apply -f pod-demo.yaml

3. Compruebe el límite inicial de memoria. La ruta de cgroup se construye a partir del UID del pod y el ID del contenedor.

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

   Salida esperada:

   1073741824

   El valor 1073741824 equivale a 1 GiB, lo cual coincide con spec.containers.resources.limits.memory en la definición del pod.

4. Cree el archivo cgroups-sample.yaml para establecer el nuevo límite de memoria.

   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. Aplique el recurso Cgroups.

   kubectl apply -f cgroups-sample.yaml

6. Verifique el límite de memoria actualizado.

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

   Salida esperada:

   5368709120

   El valor 5368709120 equivale a 5 GiB, lo cual coincide con spec.pod.containers.memory en el recurso Cgroups.

7. Confirme que el pod no se reinició.

   kubectl describe pod pod-demo

   Confirme que no existen eventos de reinicio en la sección Events; solo deben aparecer los eventos originales de programación e inicio:

   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

   La ausencia de eventos de reinicio confirma que el límite de memoria se actualizó correctamente sin interrumpir el pod.

Modificación del alcance de vinculación de núcleos de CPU

Vincule un pod a núcleos de CPU específicos para lograr un aislamiento de recursos más estricto. Este ejemplo restringe un pod, que originalmente tenía acceso a los 32 núcleos (0–31), para que utilice únicamente los núcleos 2 y 3.

1. Cree el archivo pod-cpuset-demo.yaml con el siguiente contenido.

   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. Despliegue el pod.

   kubectl apply -f pod-cpuset-demo.yaml

3. Consulte la vinculación actual de núcleos de CPU. La ruta se genera a partir del UID del pod y el ID del contenedor.

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

   Salida esperada:

   0-31

   El valor 0-31 indica que el contenedor puede utilizar los 32 núcleos de CPU disponibles.

4. Cree el archivo cgroups-sample-cpusetpod.yaml para configurar la vinculación de 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. Aplique el recurso Cgroups.

   kubectl apply -f cgroups-sample-cpusetpod.yaml

6. Verifique la vinculación de CPU actualizada.

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

   Salida esperada:

   2-3

   El contenedor ahora está vinculado a los núcleos 2–3, tal como se especificó en spec.pod.containers.cpuset-cpus del recurso Cgroups.

7. Confirme que el pod no se reinició.

   kubectl describe pod pod-cpuset-demo

   La sección Events incluye un evento CPUSetBind generado por koordlet, pero no muestra eventos de reinicio:

   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

Modificación de parámetros de E/S de disco

Este ejemplo despliega una carga de trabajo fio y limita su throughput de escritura mediante un archivo de cgroup.

1. Cree el archivo fio-demo.yaml con el siguiente contenido. El directorio del host /mnt se monta en /data dentro del pod, asignado a /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. Despliegue la aplicación.

   kubectl apply -f fio-demo.yaml

3. Limite el throughput de escritura utilizando un archivo de cgroup.

   1. Cree el archivo cgroups-sample-fio.yaml para establecer un límite de escritura en bytes por segundo (BPS) en /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. Aplique el recurso Cgroups.

      kubectl apply -f cgroups-sample-fio.yaml

   3. Verifique el límite de E/S de disco actualizado. La ruta se construye a partir del UID del pod y el ID del contenedor.

      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

      Salida esperada:

      253:0 1048576

      El límite de BPS de escritura es 1048576 (1 MiB/s) para el dispositivo 253:0 (/dev/vda1). El pod no se reinició.

4. Para consultar los datos de monitoreo de disco en Prometheus, vaya a la consola y elija Operations > Prometheus Monitoring. En la pestaña Application Monitoring, filtre por la aplicación de ejemplo. Consulte Connect to and configure Alibaba Cloud Prometheus Monitoring.

Aplicación de cambios a nivel de Deployment

Todos los procedimientos anteriores también funcionan a nivel de Deployment; simplemente utilice spec.deployment en lugar de spec.pod. Este ejemplo aplica la vinculación de núcleos de CPU a un Deployment completo.

1. Cree el archivo go-demo.yaml con el siguiente contenido. Este Deployment ejecuta dos réplicas con 0.5 CPU cada una.

   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. Despliegue la aplicación.

   kubectl apply -f go-demo.yaml

3. Cree el archivo cgroups-cpuset-sample.yaml para vincular los pods del Deployment a núcleos de CPU específicos.

   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. Aplique el recurso Cgroups.

   kubectl apply -f cgroups-cpuset-sample.yaml

5. Verifique la vinculación de CPU en uno de los pods. La ruta se genera a partir del UID del pod y el ID del contenedor.

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

   Salida esperada:

   2-3

   El contenedor está vinculado a los núcleos 2–3, conforme a lo definido en spec.deployment.containers.cpuset-cpus del recurso Cgroups.

Siguientes pasos

• CPU Burst: Los contenedores acumulan intervalos de tiempo de CPU no utilizados y los aprovechan durante picos de tráfico, reduciendo la latencia y mejorando la calidad del servicio. Consulte Enable the CPU Burst policy.

• Programación consciente de la topología de CPU: Asigna pods a núcleos de CPU específicos durante la programación para eliminar la sobrecarga por cambio de contexto de CPU y el acceso a memoria entre nodos NUMA. Consulte Enable CPU topology-aware scheduling.

• Sobreventa dinámica de recursos: Recupera recursos asignados pero no utilizados y los pone a disposición de cargas de trabajo de menor prioridad. Combínese con directivas de QoS de nodo único para evitar interferencias de rendimiento entre aplicaciones. Consulte Enable dynamic resource overselling.

• Perfilado de recursos: Analiza datos históricos de uso para obtener recomendaciones de dimensionamiento adecuado para las solicitudes y límites de los contenedores. Consulte Resource profiling.