docker ------- Método de configuração de recurso Cgroup

Prefácio

Por padrão, não há limite de recursos para um contêiner, porque é um processo em si. Quando um contêiner ocupa muitos recursos, ele afetará outros contêineres. Portanto, a alocação razoável de recursos do contêiner é um problema ao qual os administradores devem prestar atenção .
docker passa Cgroup Para controlar a cota de recursos usada pelo contêiner, incluindo os três aspectos principais de CPU, memória e disco, basicamente cobrindo cotas de recursos comuns e controle de uso

1. Configuração de recursos Cgroup

Cgroup é a abreviatura de Control Groups. É um mecanismo fornecido pelo kernel do Linux para limitar, registrar e isolar os recursos físicos (como CPU, memória, disco 10, etc.) usados ​​por grupos de processos. É usado por muitos projetos como LXC e docker Realize o controle de recursos do processo O próprio Cgroup é uma estrutura básica que fornece funções e interfaces para agrupar processos. O gerenciamento de recursos específicos, como E / S ou controle de alocação de memória, é realizado por meio desta função. Essas funções específicas de gerenciamento de recursos são chamadas de subsistemas Cgroup., Existem os seguintes subsistemas principais :

• blkio: defina para limitar o controle de entrada e saída de cada dispositivo, como: disco, CD, usb, etc.
• CPU: Use o agendador para fornecer acesso à CPU para tarefas cgroup
• cpuacct: Gera relatórios de recursos de CPU para tarefas cgroup
• cpuset: Se for uma CPU multi-core, este subsistema irá alocar CPU e memória separadas para tarefas cgroup
• dispositivos: permitir ou negar acesso a dispositivos por tarefas cgroup
• freezer: Pause e retome as tarefas do cgroup
• memória: Defina o limite de memória de cada cgroup e gere um relatório de recurso de memória
• net_cls: marque cada pacote de rede para uso conveniente do cgroup
• ns: Subsistema de namespace
• perf_event: aumenta os recursos de monitoramento e rastreamento de cada grupo, que pode monitorar todos os threads pertencentes a um grupo específico e permitir threads em uma CPU específica

Dois, teste a CPU e a memória

Use o Dockerfile para criar uma imagem de ferramenta de estresse baseada em centos

mkdir /opt/stress
cd /opt/stress

vim Dockerfile
FROM centos:7
MAINTAINER HZH<397615552@qq.com>
RUN yum install -y wget
RUN wget -O /etc/yum.repos.d/epel.repo http://mirrors.aliyun.com/repo/epel-7.repo
RUN yum install -y stress

docker build -t centos:stress .

Use o seguinte comando para criar um contêiner. O valor do parâmetro -cpu-shares no comando não garante que você possa obter 1 vcpu ou quantos GHz de recursos de CPU, é apenas um valor ponderado flexível

docker run -itd --cpu-shares 100 centos:stress

说明:默认情况下，每个Docker容器的CPU份额都是1024。 单独一个容器的份额是没有意义的。只有在同时运行多个容器时，容器的CPU加权的效果才能体现出来。
Por exemplo: inicie 2 contêineres e permita ver a porcentagem de uso da CPU

docker run -itd --name cpu512 --cpu-shares 512 centos:stress stress -c 10  #容器产生10个子函数进程
docker exec -it xxxxxxxx bash  		#进入容器使用top查看cpu使用情况

再开一个容器做比较
docker run -itd ---name cpu1024 --cpu-shares 1024 centos:stress stress -c 10
docker exec -it xxxxxxxxx bash      #进入容器使用top对比两个容器的%CPU,比例是1：2

Três, limite de ciclo de CPU

1. O Docker fornece dois parâmetros --cpu-period e --cpu-quota para controlar os ciclos de clock da CPU que o contêiner pode alocar

• --Cpu-period: é usado para especificar por quanto tempo o uso da CPU do contêiner deve ser redistribuído
• --Cpu-quota: é usado para especificar o tempo máximo que pode ser usado para executar o contêiner neste ciclo
• Ao contrário de –cpu-share, esta configuração é um valor absoluto especificado e o uso de recursos da CPU pelo contêiner nunca excederá o valor configurado
  . A unidade de –cpu-period e –cpu-quota é de microssegundos.
• O valor mínimo de -cpu-period é 1000 microssegundos, o valor máximo é 1 segundo e o padrão é 0,1 segundo
• O valor padrão de –cpu-quota é -1, o que significa nenhum controle. Os parâmetros –cpu-period e –cpu-quota são geralmente usados ​​em combinação

Por exemplo: o processo de contêiner precisa usar uma única CPU por 0,2 segundos a cada 1 segundo. Você pode definir o período da CPU para 100.000 (ou seja, 0,1 segundos) e a cpu-cota para 200.000 (0,2 segundos). Claro, no caso de multi-core, se permitido. Se o processo do contêiner ocupar completamente duas CPUs, você pode definir o período da cpu para 100.000 (ou seja, 0,1 segundo) e a cpu-quota para 200000 (0,2 segundo)

docker run -itd --cpu-period 100000 --cpu-quota 200000 centos:stress
docker exec -it xxxxxxxxxx
cat /sys/fs/cgroup/cpu/cpu.cfs_period_us
cat /sys/fs/cgroup/cpu/cpu.cfs_quota_us

Quatro, controle do núcleo da CPU

Para servidores com CPUs de vários núcleos, o Docker também pode controlar quais núcleos de CPU o contêiner tem permissão para usar, ou seja, usar o parâmetro -cpuset-cpus.
Isso é especialmente útil para servidores com várias CPUs e pode configurar o melhor desempenho para contêineres que requerem computação de alto desempenho.

docker run -itd --name cpu1 --cpuset-cpus 2-3 centos:stress			#2-3表示创建容器只能使用第2、3这两个内核，
docker exec -it xxxxxxxxxxx bash
cat /sys/fs/cgroup/cpuset/cpuset.cpus

docker exec xxxxxx taskset -c -p 1
pid 1's current affinity list: 2,3

5. Uso misto de parâmetros de controle de cota de CPU

Use o parâmetro cpuset-cpus para especificar que o contêiner A usa CPU core 0 e o contêiner B usa apenas CPU core 3.
No host, apenas esses dois contêineres usam os núcleos de CPU correspondentes. Cada um deles ocupa todos os recursos principais, e cpu- compartilhamentos não têm efeito óbvio
. -cpus, os parâmetros cpuset-mems são válidos apenas em servidores em nós de múltiplos núcleos e multi-memória e devem corresponder à configuração física real, caso contrário, o objetivo do controle de recursos não pode ser alcançado.
No caso de vários núcleos de CPU no sistema, ele precisa ser passado O parâmetro cpuset-cpus é definir o núcleo de CPU do contêiner para facilitar o teste

docker run -itd --name cpu3 --cpuset-cpus 1 --cpu-shares 512 centos:stress stress -c 1 
docker exec -it xxxxxxxxxxx bash
exit 
top #按1查看每个核心的占用

docker run -itd --name cpu4 --cpuset-cpus 3 --cpu-shares 1024 centos:stress stress -c 1 
docker exec -it xxxxxxx bash    

总结：上面的centos:stress镜像安装了stress工具，用来测试CPU和内存的负载，通过在两个容器上分别执行stress -c 1命令，将会给系统一个随机负载，产生1个进程，这个进程都会反复不停的计算由rand()产生随机数的平方根，直到资源耗尽，观察到宿主机上CPU使用率，第三个内核的使用率接近100%，并且一批进程的CPU使用率明显存在2：1 的使用比例的对比

Sexto, limite de memória

Semelhante ao sistema operacional, a memória que o contêiner pode usar inclui duas partes: a memória física e a
janela de encaixe Troca controla o uso da memória do contêiner por meio dos dois conjuntos de parâmetros a seguir

• -m ou --memory: define o limite de uso de memória
• - Troca de memória: definir limite de uso de memória + troca
• --Vm 1: inicia 1 thread de trabalho de memória
• –Vm-bytes 280M: cada thread aloca 280M de memória, o valor aqui deve ser menor que –memory-swap, caso contrário, um erro será relatado

docker run -it -m 200M --memory-swap=300M progrium/stress --vm 1 --vm-bytes 280M

docker run -it -m 200M --memory-swap=300M progrium/stress --vm 1 --vm-bytes 310M			#工作线程分配的内存超过300M或者等于300M，分配的内存超过限额，stress线程会报错，容器退出

–Vm-bytes é igual ao valor –memory-swap, o resultado é um erro

Sete, limitações de bloco IO

Por padrão, todos os contêineres podem ler e gravar no disco igualmente. Você pode alterar a prioridade do bloco de contêiner IO por meio do parâmetro
–blkio-weight . –Blkio-weight é semelhante a –cpu-shares. O peso relativo é definido. O padrão é 500.
Por exemplo: A largura de banda do contêiner A para ler e gravar no disco é o dobro do contêiner B

docker run -it --name container_A --blkio-weight 600 centos:stress
cat /sys/fs/cgroup/blkio/blkio.weight

docker run -it --name container_B --blkio-weight 300 centos:stress
cat /sys/fs/cgroup/blkio/blkio.weight

8. Limitações de bps e iops

bps é byte por segundo: a quantidade de dados lidos e gravados por segundo
iops é io por segundo: o número de IOs por segundo.
Os bps e iops do contêiner podem ser controlados pelos seguintes parâmetros

–Device-read-bps: limita a leitura de bps de um certo dispositivo
–device-write-bps: limita a escrita de bps de um certo dispositivo
–device-read-iops: limita a leitura de iops de um certo dispositivo
–device-write- iops: limit Escreva os iops de um determinado dispositivo

O exemplo a seguir é para limitar a taxa na qual o contêiner grava / dev / sda a 5 MB / s

docker run -it --device-write-bps /dev/sda:5MB centos:stress
dd if=/dev/zero of=test bs=1M count=1024 oflag=direct			#可以按ctrl+c中断查看

docker run -it centos:stress
dd if=/dev/zero of=test bs=1M count=1024 oflag=direct