Enable the cgroup writeback feature - Alibaba Cloud Linux: Central de Documentação do Alibaba Cloud

No Alibaba Cloud Linux 2 (versão do kernel 4.19.36-12.al7 e posteriores) e no Alibaba Cloud Linux 3, o recurso cgroup writeback está disponível para a interface de kernel cgroup v1. Esse recurso permite limitar a taxa de I/O em buffer.

Informações básicas

Os grupos de controle, chamados de cgroups neste tópico, são um recurso do kernel Linux que permite alocar recursos. Os cgroups estão disponíveis em duas versões: cgroup v1 e cgroup v2. Para obter mais informações, consulte a seção What are Control Groups no Resource Management Guide. Este tópico descreve como ativar o recurso cgroup writeback para o cgroup v1 a fim de limitar a taxa de I/O em buffer dos processos.

Limites

Após ativar o recurso cgroup writeback, garanta que o mapeamento entre o subsistema de memória (memcg) e o subsistema de I/O (blkcg) siga as regras descritas nesta seção. Isso é necessário para limitar a taxa de I/O em buffer dos processos.

O recurso cgroup writeback exige que o memcg e o blkcg trabalhem em conjunto para limitar a taxa de I/O em buffer. Por padrão, os subsistemas de controle do cgroup v1 não funcionam juntos. Portanto, conecte o memcg e o blkcg com base em uma regra específica: cada memcg deve ser mapeado para um único blkcg. O mapeamento pode ser de um para um ou de muitos para um, mas nunca de um para muitos ou de muitos para muitos.

Por exemplo, para limitar a taxa de I/O em buffer dos processos A e B, aplicam-se as seguintes restrições.

Se A e B pertencerem a memcgs diferentes, eles poderão ser mapeados para blkcgs distintos em uma relação de um para um. Por exemplo, A pertence a memcg1 e blkcg1, enquanto B pertence a memcg2 e blkcg0.
Caso A e B pertençam a memcgs diferentes, também é possível mapeá-los para o mesmo blkcg. Por exemplo, A pertence a memcg1 e B pertence a memcg2, mas ambos pertencem ao blkcg2.
Quando A e B pertencem ao mesmo memcg, devem ser mapeados para o mesmo blkcg. Por exemplo, tanto A quanto B podem pertencer ao memcg0 e ao blkcg3.

Para evitar problemas inesperados após ativar o cgroup writeback, defina a interface cgroup.procs do blkcg antes de limitar a taxa de I/O em buffer. Escreva um ID de processo nessa interface para garantir um mapeamento exclusivo do blkcg. Também é possível usar ferramentas para visualizar o mapeamento entre o memcg e o blkcg. Para obter mais informações, consulte Confirm the mapping between memcg and blkcg.

Durante operações e manutenção (O&M), um processo pode ser movido para outro cgroup. Com base na regra de mapeamento, nenhum problema ocorre se um processo for movido entre memcgs. No entanto, se um processo for movido entre blkcgs, ocorrerá um problema. Para evitar isso, o código do recurso inclui uma regra: se um processo em um blkcg ativo for movido para outro blkcg, o mapeamento será redefinido para o blkcg raiz. O recurso de limitação de taxa deixa então de ser eficaz, pois geralmente não há um limiar de limite de taxa definido no blkcg raiz.

Importante

Embora o código do kernel inclua uma regra para evitar problemas inesperados, evite mover processos entre blkcgs durante as operações.

Ative o recurso cgroup writeback

O recurso cgroup writeback vem desativado por padrão na interface cgroup v1. Siga estas etapas para ativá-lo.

Adicione o campo cgwb_v1 usando o comando grubby para ativar o recurso.
Neste exemplo, a versão do kernel é 4.19.36-12.al7.x86_64. Substitua este valor pela sua versão real do kernel. Execute o comando uname -r para verificar a versão do seu kernel.
```
sudo grubby --update-kernel="/boot/vmlinuz-4.19.36-12.al7.x86_64" --args="cgwb_v1"
```
Reinicie o sistema para que as alterações entrem em vigor.
```
sudo reboot
```
Execute o comando a seguir para ler o arquivo de kernel /proc/cmdline e confirme se os parâmetros da linha de comando do kernel incluem o campo cgwb_v1. Isso ativa as interfaces blkio.throttle.write_bps_device e blkio.throttle.write_iops_device no blkcg para limitar a taxa de I/O em buffer.
```
cat /proc/cmdline | grep cgwb_v1
```

Nota

Em um ambiente Kubernetes (k8s), após ativar o recurso cgroup writeback, você também deve mesclar os subsistemas de cgroup memory e blkio. Isso evita falhas na limitação de taxa caso um processo seja movido.

Mescle os subsistemas de cgroup memory e blkio.
1. Edite o arquivo system.conf.
```
sudo vim /etc/systemd/system.conf
```
2. Modifique a configuração JoinControllers. Por exemplo:
```
JoinControllers=cpu,cpuacct net_cls,net_prio memory,blkio
```
3. Pressione a tecla Esc para sair do modo de edição. Em seguida, insira :wq para salvar e sair.
Execute o comando a seguir para reconstruir a imagem inicial do disco RAM. Isso garante que as alterações de configuração do systemd entrem em vigor.
```
sudo dracut /boot/initramfs-4.19.36-12.al7.x86_64.img 4.19.36-12.al7.x86_64 --force
```
Execute o comando a seguir para reiniciar o sistema.
```
sudo reboot
```
Execute o comando a seguir para verificar se os subsistemas memory e blkio foram mesclados.
```
ls /sys/fs/cgroup
```

Verifique se o cgroup writeback está eficaz

Este exemplo simula dois processos geradores de I/O para verificar se o recurso cgroup writeback está eficaz.

Nota

O comando dd fornece feedback rápido. Use o comando iostat para visualizar os resultados.
O comando dd grava dados sequencialmente. Durante uma atualização de I/O sequencial, o sistema grava os dados de volta em blocos de 1 MB. Portanto, defina o limiar de blkio.throttle.write_bps_device com um valor de pelo menos 1 MB (1048576). Se você definir um valor inferior a 1 MB, o processo de I/O poderá travar.

Simule dois processos geradores de I/O. Conforme exigido pelos limites, primeiro defina a interface cgroup.procs do blkcg.

sudo mkdir /sys/fs/cgroup/blkio/blkcg1
sudo mkdir /sys/fs/cgroup/memory/memcg1
sudo bash -c "echo $$ > /sys/fs/cgroup/blkio/blkcg1/cgroup.procs"    # $$ is your process ID
sudo bash -c "echo $$ > /sys/fs/cgroup/memory/memcg1/cgroup.procs"    # $$ is your process ID

Use a interface blkio.throttle.write_bps_device no blkcg para limitar a taxa de I/O em buffer.

sudo bash -c "echo 254:48 10485760 > /sys/fs/cgroup/blkio/blkcg1/blkio.throttle.write_bps_device"    # Set the disk write-back rate limit to 10 MB/s based on the device number.

Use o comando dd sem o parâmetro oflag=sync para gerar I/O assíncrono em cache.
```
sudo dd if=/dev/zero of=/mnt/vdd/testfile bs=4k count=10000
```
Utilize a ferramenta iostat para consultar os resultados. Verifique a coluna wMB/s na saída. Se a taxa estiver limitada a aproximadamente 10 MB/s, o recurso cgroup writeback estará funcionando corretamente.
```
iostat -xdm 1 vdd
```

Confirme o mapeamento entre memcg e blkcg

Use um dos métodos a seguir para confirmar se o mapeamento entre memcg e blkcg é de um para um ou de muitos para um.

Visualize o mapeamento entre memcg e blkcg.
```
sudo cat /sys/kernel/debug/bdi/bdi_wb_link
```
A saída de exemplo a seguir mostra que o memcg e o blkcg possuem um mapeamento de um para um.
```
memory     <--->     blkio
memcg1:   35 <---> blkcg1:   48
```
Utilize a ferramenta de monitoramento de kernel ftrace.
1. Ative a ferramenta ftrace.
```
sudo bash -c "echo 1 > /sys/kernel/debug/tracing/events/writeback/insert_memcg_blkcg_link/enable"
```
2. Visualize as informações de saída.
```
sudo cat /sys/kernel/debug/tracing/trace_pipe
```
  A saída de exemplo a seguir mostra memcg_ino=35 blkcg_ino=48. Isso indica que o memcg e o blkcg possuem um mapeamento de um para um.
```
<...>-1537  [006] ....    99.511327: insert_memcg_blkcg_link: memcg_ino=35 blkcg_ino=48 old_blkcg_ino=0
```