Cgroups

Cgroups (abreviação de control groups, ou grupos de controle) são um mecanismo do Kernel Linux que permite organizar processos em grupos hierárquicos e gerenciar/limitar o acesso deles a recursos do sistema, como CPU, memória, largura de banda de rede e E/S de disco.

Instalação do cgroups-tools

cgroups-tools (Control Groups Tools) é um conjunto de utilitários no Linux para gerenciar cgroups

apt-get install cgroups-tools -y

Criando um novo Cgroup

cgcreate -g cpu,memory,io,pids:cgroup_toto

cgcreate: Utilitário para criar novos Cgroups no sistema.
-g: Flag que especifica os controladores (subsistemas) e o nome do cgroup a ser criado.
- cpu: Controla o tempo de CPU disponível para os processos. Permite definir quotas, períodos e prioridades de uso do processador.
- memory: Gerencia o uso de memória RAM. Possibilita estabelecer limites de consumo de memória, tanto física quanto swap, e monitorar o uso atual.
- io: Controla operações de I/O em dispositivos de bloco (discos). Permite limitar a largura de banda de leitura/escrita e definir pesos de prioridade para acesso ao disco.
- pids: Limita número de processos/threads.
- cgroup_toto: O nome que você está atribuindo a este cgroup específico. Ele será criado em /sys/fs/cgroup/[controlador]/cgroup_toto para cada controlador especificado.

Lista os diretórios associados ao cgroup CPU cgroup_toto

ls /sys/fs/cgroup/cgroup_toto/

O saída do comando será semelhante a que está abaixo:

cgroup.controllers      cgroup.subtree_control  cpu.weight           memory.high       memory.stat             pids.current
cgroup.events           cgroup.threads          cpu.weight.nice      memory.low        memory.swap.current     pids.events
cgroup.freeze           cgroup.type             io.max               memory.max        memory.swap.events      pids.events.local
cgroup.kill             cpu.idle                io.pressure          memory.min        memory.swap.high        pids.max
cgroup.max.depth        cpu.max                 io.stat              memory.numa_stat  memory.swap.max         pids.peak
cgroup.max.descendants  cpu.max.burst           io.weight            memory.oom.group  memory.swap.peak
cgroup.pressure         cpu.pressure            memory.current       memory.peak       memory.zswap.current
cgroup.procs            cpu.stat                memory.events        memory.pressure   memory.zswap.max
cgroup.stat             cpu.stat.local          memory.events.local  memory.reclaim    memory.zswap.writeback

Adiciona o ambiente isolado a um Cgroup

Primeiro, iremos executar o comando unshare para criar os Namespaces e acessar o ambiente isolado. Veja mais em Namespaces.

unshare --mount --uts --ipc --net --map-root-user --user --pid --fork chroot /debian bash

Abra outro terminal no Host (não encerre o comando unshare) e digite o comando abaixo para ver os processos em execução:

ps -ef

Na saída, procure pelo comando unshare e verá que logo abaixo o comando bash:

UID          PID    PPID  C STIME TTY          TIME CMD
root           1       0  0 16:27 ?        00:00:00 /sbin/init
...
root       11317    1155  0 19:29 pts/1    00:00:00 unshare --mount --pid --net --map-root-user --user --uts --fork --ipc chroot /debian bash
root       11318   11317  0 19:29 pts/1    00:00:00 bash
root       11335   11216  0 19:32 pts/3    00:00:00 ps -ef

Note que o PPID (Parent Process ID) do comando bash (11318) é o mesmo do PID (Process ID) do comando unshare. Isto indica que este processo bash foi criado pelo comando unshare.

Agora usaremos o PID do comando bash (11318) do passo anterior para adicionar o ambiente isolado ao Cgroup cgroup_toto:

cgclassify -g cpu,memory,io,pids:cgroup_toto 11318

cgclassify: Utilitário que move processos já em execução para um cgroup específico.
-g: - Flag que especifica os controladores e o Cgroup de destino onde o processo será movido.
cpu,memory,io,pids: Lista dos controladores (subsistemas) nos quais o processo será classificado. O processo será movido para o Cgroup cgroup_toto em cada um desses controladores.
cgroup_toto: O nome do cgroup de destino que você criou anteriormente com o cgcreate.
11318: O PID do processo (bash) que você quer mover para o Cgroup.

Especificar a quota de uso do CPU

Especifica a quota de uso do CPU ao Cgroups cgroup_toto

cgset -r cpu.max="1000 100000" cgroup_toto

cgset: Utilitário para definir/modificar parâmetros de recursos em um cgroup existente.
-r: - Flag que especifica o recurso (resource) e seu valor a ser configurado.
cpu.max: Parâmetro do controlador CPU que controla a largura de banda de CPU disponível para o Cgroup.
1000 100000: String contendo dois valores separados por espaço. Explicação logo abaixo.
cgroup_toto: O nome doCgroup onde este limite será aplicado.

Sobre o parâmetro cpu.max="1000 100000"

Primeiro valor: 1000 (quota)

Quantidade de tempo de CPU alocada em microssegundos

1000 microssegundos = 1 milissegundo

É o tempo máximo de CPU que o cgroup pode usar por período

Segundo valor: 100000 (period)

Janela de tempo em microssegundos na qual a quota se aplica

100000 microssegundos = 100 milissegundos

É o intervalo de tempo que o agendador usa para distribuir CPU

Percentual de CPU disponível:
Percentual de CPU disponível
% CPU = (quota / period) × 100
% CPU = (1000 / 100000) × 100 = 1%
Isso significa que os processos no cgroup_toto poderão usar:

1ms de CPU a cada 100ms

Equivalente a 1% de uma única CPU core

Em um sistema com 8 cores, isso é 0,125% do total

Mais exemplos

Limitar 50% de uma CPU

cgset -r cpu.max="50000 100000" cgroup_toto

2 CPUs completas (200%):

cgset -r cpu.max="200000 100000" cgroup_toto

Sem limites

cgset -r cpu.max="max 100000" cgroup_toto

Verificação

Para ver o valor configurado:

cat /sys/fs/cgroup/cgroup_toto/cpu.max

Para monitorar o uso real:

cgset -r cpu.max="200000 100000" cgroup_toto

Sem limites

cat /sys/fs/cgroup/cgroup_toto/cpu.stat

Limitar o uso de memória

Limita o uso do memória RAM à 56MB ao Cgroups cgroup_toto

cgset -r memory.max=56M cgroup_toto

cgset: Utilitário para definir/modificar parâmetros de recursos em um Cgroup existente.
-r: - Flag que limita o recurso (resource) e seu valor a ser configurado.
memory.max: Parâmetro do controlador de memória que define o limite máximo absoluto de memória RAM que os processos do cgroup podem usar.
- É um limite hard (rígido) - não pode ser ultrapassado
- Inclui toda memória usada: anônima, cache de página, buffers, etc.
- Quando atingido, aciona mecanismos de recuperação de memória
56M: O valor do limite sendo atribuído.
cgroup_toto: O nome doCgroup onde este limite será aplicado.

Ao executar este comando:

Todos os processos dentro de cgroup_toto compartilharão no máximo 56 MB de RAM.
Se tentarem alocar mais memória, o kernel iniciará ações de recuperação:
- Libera cache de página
- Força swap (se disponível)
- Como último recurso, invoca o OOM killer para matar processos

Saiba mais

Red Hat - Introduction to Control Groups (Cgroups)
What Are Namespaces and cgroups, and How Do They Work?