Modificar temporária e dinamicamente os parâmetros de isolamento de CPU, memória e E/S de disco de um pod usando arquivos Cgroups - Container Service for Kubernetes: Central de Documentação do Alibaba Cloud

Como funciona

O ACK utiliza uma definição de recurso personalizado (CRD) do tipo kind: Cgroups para transmitir alterações de recursos ao ack-koordinator. Ao aplicar um recurso Cgroups, o koordlet no nó grava novos valores diretamente nos arquivos cgroup, ignorando o agendador do Kubernetes e o ciclo de reconciliação do kubelet. O PodSpec do pod permanece inalterado; apenas os valores cgroup no nó são atualizados.

Utilize spec.pod para direcionar um pod específico ou spec.deployment para abranger todos os pods de um Deployment.

Pré-requisitos

Certifique-se de que:

O kubectl esteja conectado ao cluster ACK.
O ack-koordinator esteja instalado na versão 0.5.0 ou superior.

Faturamento

A instalação e o uso do ack-koordinator são gratuitos. No entanto, cobranças adicionais podem ocorrer nas seguintes situações:

Recursos de nós de trabalho: O ack-koordinator é um complemento não gerenciado que consome recursos nos nós de trabalho após a instalação. Especifique as solicitações de recursos para cada módulo durante a instalação do complemento.
Métricas de monitoramento do Prometheus: Caso ative a opção Enable Prometheus monitoring metrics for ACK-Koordinator e utilize o Managed Service for Prometheus, as métricas serão faturadas como métricas personalizadas. Os custos dependem do tamanho do cluster e da quantidade de aplicações. Consulte a documentação sobre Faturamento de instância do Prometheus e utilize a consulta de uso para monitorar o consumo antes de ativar este recurso.

Limitações

Restrição	Detalhe
Escopo	Apenas ajustes temporários. Não atualiza o PodSpec do pod nem persiste após reinicializações.
Versão do cluster (memória)	Clusters na versão 1,22 ou superior exigem ack-koordinator v1.5.0-ack1.14 ou posterior. Versões anteriores do complemento suportam somente clusters executando a versão 1,22 ou anterior.
E/S de disco	Os nós de trabalho devem executar Alibaba Cloud Linux (Alinux).
E/S bufferizada no cgroup v1	No cgroup v1, os limites blkio aplicam-se apenas à E/S direta. Para limitar E/S bufferizada, ative o recurso de writeback do cgroup no Alinux.
cgroup v2	O controle de taxa de E/S de disco via blkio não é suportado em ambientes cgroup v2.
Limite de CPU	Para ajustes temporários de limite de CPU, consulte Migrar do resource-controller para o ack-koordinator.

Modificar o limite de memória

Aumente o limite de memória de um pod para evitar encerramentos por OOM sem reiniciá-lo. Este exemplo eleva o limite de 1 GiB para 5 GiB.

Crie o arquivo pod-demo.yaml com o conteúdo abaixo.

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"]

Implante o pod.
```
kubectl apply -f pod-demo.yaml
```
Verifique o limite inicial de memória. O caminho do cgroup é construído a partir do UID do pod e do ID do contêiner.
```
cat /sys/fs/cgroup/memory/kubepods.slice/kubepods-burstable.slice/kubepods-burstable-podaf44b779_41d8_43d5_a0d8_8a7a0b17****.slice/memory.limit_in_bytes
```
Saída esperada:
```
1073741824
```
O valor 1073741824 equivale a 1 GiB, correspondendo a spec.containers.resources.limits.memory na definição do pod.

Crie o arquivo cgroups-sample.yaml para definir o novo limite de memória.

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

Aplique o recurso Cgroups.
```
kubectl apply -f cgroups-sample.yaml
```

Verifique o limite de memória atualizado.

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

Saída esperada:

5368709120

O valor 5368709120 corresponde a 5 GiB, alinhado com spec.pod.containers.memory no recurso Cgroups.

Confirme se o pod não foi reiniciado.

kubectl describe pod pod-demo

Certifique-se de que não há eventos de reinicialização na seção Events, constando apenas os eventos originais de agendamento e inicialização:

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

A ausência de eventos de reinicialização confirma que o limite de memória foi atualizado localmente.

Modificar o escopo de vinculação de núcleos de CPU

Vincule um pod a núcleos de CPU específicos para obter um isolamento de recursos mais rigoroso. Este exemplo restringe um pod de todos os 32 núcleos (0–31) para apenas os núcleos 2–3.

Nota

Para vinculação persistente de núcleos de CPU em produção, prefira utilizar o Agendamento com reconhecimento de topologia de CPU.

Crie o arquivo pod-cpuset-demo.yaml com o seguinte conteúdo.

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"]

Implante o pod.
```
kubectl apply -f pod-cpuset-demo.yaml
```

Verifique a vinculação atual de núcleos de CPU. O caminho é composto pelo UID do pod e pelo ID do contêiner.

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

Saída esperada:

0-31

O intervalo 0-31 indica que o contêiner pode utilizar todos os 32 núcleos de CPU.

Crie o arquivo cgroups-sample-cpusetpod.yaml para configurar a vinculação 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

Aplique o recurso Cgroups.

kubectl apply -f cgroups-sample-cpusetpod.yaml

Verifique a nova vinculação de CPU.

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

Saída esperada:

2-3

O contêiner está vinculado aos núcleos 2–3, conforme definido em spec.pod.containers.cpuset-cpus no recurso Cgroups.

Confirme se o pod não foi reiniciado.

kubectl describe pod pod-cpuset-demo

A seção Events exibe um evento CPUSetBind gerado pelo koordlet, mas nenhum evento de reinicialização:

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

Modificar parâmetros de E/S de disco

Nota

Os nós de trabalho precisam executar Alinux. No cgroup v1, os limites blkio afetam somente a E/S direta. Para limitar E/S bufferizada, ative o recurso de writeback do cgroup no Alinux. Sem suporte no cgroup v2.

Este exemplo implanta uma carga de trabalho fio e limita sua taxa de transferência de escrita por meio de um arquivo cgroup.

Crie o arquivo fio-demo.yaml com o conteúdo a seguir. O diretório do host /mnt é montado em /data dentro do pod, mapeado para /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

Implante a aplicação.
```
kubectl apply -f fio-demo.yaml
```
Limite a taxa de transferência de escrita usando um arquivo cgroup.
1. Crie o arquivo cgroups-sample-fio.yaml para estabelecer um limite de escrita em bytes por segundo (BPS) em /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 o recurso Cgroups.
```
kubectl apply -f cgroups-sample-fio.yaml
```
3. Verifique o limite de E/S de disco atualizado. O caminho deriva do UID do pod e do ID do contêiner.
```
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
```
  Saída esperada:
```
253:0 1048576
```
  O limite de BPS de escrita está definido como 1048576 (1 MiB/s) para o dispositivo 253:0 (/dev/vda1). O pod não foi reiniciado.
4. Para visualizar dados de monitoramento de disco no Prometheus, acesse o console e navegue até Operations > Prometheus Monitoring. Na aba Application Monitoring, filtre pela aplicação de exemplo. Consulte Conectar e configurar o Alibaba Cloud Prometheus Monitoring.
Aplicar alterações no nível do Deployment

Todos os procedimentos acima também funcionam no nível do Deployment — basta usar spec.deployment em vez de spec.pod. Este exemplo aplica vinculação de núcleos de CPU a um Deployment.
1. Crie o arquivo go-demo.yaml com o conteúdo seguinte. Este Deployment executa duas réplicas com 0,5 CPU cada.
```
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. Implante a aplicação.
```
kubectl apply -f go-demo.yaml
```
3. Crie o arquivo cgroups-cpuset-sample.yaml para vincular os pods do 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 o recurso Cgroups.
```
kubectl apply -f cgroups-cpuset-sample.yaml
```
5. Verifique a vinculação de CPU de um dos pods. O caminho é formado pelo UID do pod e pelo ID do contêiner.
```
cat /sys/fs/cgroup/cpuset/kubepods.slice/kubepods-burstable.slice/kubepods-burstable-pod06de7408_346a_4d00_ba25_02833b6c****.slice/cri-containerd-733a0dc93480eb47ac6c5abfade5c22ed41639958e3d304ca1f85959edc3****.scope/cpuset.cpus
```
  Saída esperada:
```
2-3
```
  O contêiner está vinculado aos núcleos 2–3, coincidindo com spec.deployment.containers.cpuset-cpus no recurso Cgroups.

Container Service for Kubernetes:Modificar dinamicamente parâmetros de recursos do pod

Como funciona

Pré-requisitos

Faturamento

Limitações

Modificar o limite de memória

Modificar o escopo de vinculação de núcleos de CPU

Modificar parâmetros de E/S de disco

Aplicar alterações no nível do Deployment

Próximos passos