如何通过Cgroups机制实现资源限制？

1、什么是Cgroups？

在说Cgroups之前，我们先说说容器的"限制"问题。

我们知道通过Linux Namespace技术，可以实现容器中的进程看不到别的容器资源，但是有一个问题你是否注意到？容器内的进程任然可以任意地使用主机的CPU、内存等资源。如果某一个容器使用的主机资源过多，可能导致主机资源的竞争，进而影响业务。

而Linux Cgroups 就是 Linux 内核中用来为进程设置资源限制的一个重要功能。

Linux Cgroups 的全称是 Linux Control Group。它最主要的作用，就是限制一个进程组能够使用的资源上限，包括 CPU、内存、磁盘、网络带宽等等。此外，Cgroups 还能够对进程进行优先级设置、审计，以及将进程挂起和恢复等操作。

**Cgroups 功能及核心概念 **

资源限制：限制资源的使用量，例如我们可以通过限制某个业务的内存上限，从而保护主机其他业务的安全运行。
优先级控制：不同的组可以有不同的资源（ CPU 、磁盘 IO 等）使用优先级。
审计：计算控制组的资源使用情况。
控制：控制进程的挂起或恢复。

Cgroups功能的实现依赖于三个核心概念：子系统、控制组、层级树。

子系统（subsystem）

一个内核的组件，一个子系统代表一类资源调度控制器。例如内存子系统可以限制内存的使用量，CPU 子系统可以限制 CPU 的使用时间。

子系统是真正实现某类资源的限制的基础。

控制组（cgroup）

表示一组进程和一组带有参数的子系统的关联关系。例如，一个进程使用了 CPU 子系统来限制 CPU 的使用时间，则这个进程和 CPU 子系统的关联关系称为控制组。

层级树（hierarchy）：

由一系列的控制组按照树状结构排列组成的。这种排列方式可以使得控制组拥有父子关系，子控制组默认拥有父控制组的属性，也就是子控制组会继承于父控制组。比如，系统中定义了一个控制组 c1，限制了 CPU 可以使用 1 核，然后另外一个控制组 c2 想实现既限制 CPU 使用 1 核，同时限制内存使用 2G，那么 c2 就可以直接继承 c1，无须重复定义 CPU 限制。

2、Cgroups子系统实例

在 Linux 中，Cgroups 给用户暴露出来的操作接口是文件系统，即它以文件和目录的方式组织在操作系统的 /sys/fs/cgroup 路径下。

[root@docker ~]# mount -t cgroup

cgroup on /sys/fs/cgroup/systemd type cgroup (rw,nosuid,nodev,noexec,relatime,xattr,release_agent=/usr/lib/systemd/systemd-cgroups-agent,name=systemd)

cgroup on /sys/fs/cgroup/net_cls,net_prio type cgroup (rw,nosuid,nodev,noexec,relatime,net_prio,net_cls)

cgroup on /sys/fs/cgroup/cpu,cpuacct type cgroup (rw,nosuid,nodev,noexec,relatime,cpuacct,cpu)

cgroup on /sys/fs/cgroup/blkio type cgroup (rw,nosuid,nodev,noexec,relatime,blkio)

cgroup on /sys/fs/cgroup/cpuset type cgroup (rw,nosuid,nodev,noexec,relatime,cpuset)

cgroup on /sys/fs/cgroup/pids type cgroup (rw,nosuid,nodev,noexec,relatime,pids)

cgroup on /sys/fs/cgroup/perf_event type cgroup (rw,nosuid,nodev,noexec,relatime,perf_event)

cgroup on /sys/fs/cgroup/devices type cgroup (rw,nosuid,nodev,noexec,relatime,devices)

cgroup on /sys/fs/cgroup/memory type cgroup (rw,nosuid,nodev,noexec,relatime,memory)

cgroup on /sys/fs/cgroup/hugetlb type cgroup (rw,nosuid,nodev,noexec,relatime,hugetlb)

cgroup on /sys/fs/cgroup/freezer type cgroup (rw,nosuid,nodev,noexec,relatime,freezer)

通过输出，可以看到当前系统已经挂载了我们常用的cgroups子系统，例如 cpu、memory、pids 等我们常用的cgroups子系统。这些子系统中，cpu 和 memory 子系统是容器环境中使用最多的子系统，下面我对这两个子系统做详细介绍。

CPU 子系统

我们以CPU子系统为例，演示一下cgroups如何限制进程cpu使用时间。

第一步:在 cpu 子系统下创建 cgroup

cgroups的创建很简单，只需要在相应的子系统下创建目录即可。下面我们到 cpu 子系统下创建测试文件夹：

[root@master ~]# mkdir /sys/fs/cgroup/cpu/mydocker

执行完上述命令后，我们查看一下我们新创建的目录下发生了什么？

[root@master ~]# ls -l /sys/fs/cgroup/cpu/mydocker/

total 0

-rw-r--r-- 1 root root 0 Dec  2 20:31 cgroup.clone_children

--w--w--w- 1 root root 0 Dec  2 20:31 cgroup.event_control

-rw-r--r-- 1 root root 0 Dec  2 20:31 cgroup.procs

-r--r--r-- 1 root root 0 Dec  2 20:31 cpuacct.stat

-rw-r--r-- 1 root root 0 Dec  2 20:31 cpuacct.usage

-r--r--r-- 1 root root 0 Dec  2 20:31 cpuacct.usage_percpu

-rw-r--r-- 1 root root 0 Dec  2 20:31 cpu.cfs_period_us

-rw-r--r-- 1 root root 0 Dec  2 20:31 cpu.cfs_quota_us

-rw-r--r-- 1 root root 0 Dec  2 20:31 cpu.rt_period_us

-rw-r--r-- 1 root root 0 Dec  2 20:31 cpu.rt_runtime_us

-rw-r--r-- 1 root root 0 Dec  2 20:31 cpu.shares

-r--r--r-- 1 root root 0 Dec  2 20:31 cpu.stat

-rw-r--r-- 1 root root 0 Dec  2 20:31 notify_on_release

-rw-r--r-- 1 root root 0 Dec  2 20:31 tasks

由上可以看到我们新建的目录下被自动创建了很多文件，其中 cpu.cfs_quota_us 文件代表在某一个阶段限制的 CPU 时间总量，单位为微秒。例如，我们想限制某个进程最多使用 1 核 CPU，就在这个文件里写入 100000（100000 代表限制 1 个核），tasks 文件中写入进程的 ID 即可（如果要限制多个进程 ID，在 tasks 文件中用换行符分隔即可）。

第二步：常见进程，加入cgroup

这里为了方便演示，我先把当前运行的 shell 进程加入 cgroup，然后在当前 shell 运行 cpu 耗时任务（这里利用到了继承，子进程会继承父进程的 cgroup）。

使用以下命令将 shell 进程加入 cgroup 中：

[root@master ~]# cd /sys/fs/cgroup/cpu/mydocker/

[root@master mydocker]# echo $$ > tasks

查看tasks内容

[root@master mydocker]# cat tasks

120257

124289

其中第一个进程 ID 为当前 shell 的主进程，也就是说，当前 shell 主进程为 120257。

第三步：执行 CPU 耗时任务，验证 cgroup 是否可以限制 cpu 使用时间

我们使用以下命令制造一个死循环，来提升 cpu 使用率：

[root@master mydocker]#  while true;do echo;done;

执行完上述命令后，我们新打开一个 shell 窗口，使用 top -p 命令查看当前 cpu 使用率，-p 参数后面跟进程 ID，我这里是 120257。

root@master ~]# top -p 120257

top - 20:43:41 up  2:42,  3 users,  load average: 2.13, 1.08, 0.52

Tasks:   1 total,   1 running,   0 sleeping,   0 stopped,   0 zombie

%Cpu(s):  8.9 us,  3.6 sy,  0.0 ni, 87.5 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st

KiB Mem :  3861296 total,  2985628 free,   385792 used,   489876 buff/cache

KiB Swap:        0 total,        0 free,        0 used.  3194824 avail Mem 

   PID USER      PR  NI    VIRT    RES    SHR S  %CPU %MEM     TIME+ COMMAND

120257 root      20   0  115684   2184   1668 R  99.7  0.1   2:37.08 bash

通过上面输出可以看到 120257这个进程使用 100 % 的 cpu。

为了进一步证实 cgroup 限制 cpu 的准确性，我们修改 cpu 限制时间为 0.5 核，命令如下：

[root@master mydocker]# echo 50000 > cpu.cfs_quota_us

[root@master mydocker]# cat cpu.cfs_quota_us

50000

同样使用上面的命令来制造死循环：

[root@master mydocker]#  while true;do echo;done;

保持当前窗口，新打开一个 shell 窗口，使用 top -p 参数查看 cpu 使用率：

[root@master ~]# top -p 120257

top - 20:49:27 up  2:48,  3 users,  load average: 0.55, 0.49, 0.42

Tasks:   1 total,   1 running,   0 sleeping,   0 stopped,   0 zombie

%Cpu(s):  4.4 us,  1.9 sy,  0.0 ni, 93.7 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st

KiB Mem :  3861296 total,  2984808 free,   386172 used,   490316 buff/cache

KiB Swap:        0 total,        0 free,        0 used.  3194452 avail Mem 

   PID USER      PR  NI    VIRT    RES    SHR S  %CPU %MEM     TIME+ COMMAND

120257 root      20   0  115684   2204   1680 R  49.8  0.1   2:51.68 bash

通过上面输出可以看到，此时 cpu 使用率已经被限制到了 50%，即 0.5 个核。

验证完 cgroup 限制 cpu，我们使用相似的方法来验证 cgroup 对内存的限制。

memory子系统

第一步：在 memory 子系统下创建 cgroup

[root@master mydocker]# mkdir /sys/fs/cgroup/memory/mydocker

[root@master mydocker]# ls -l /sys/fs/cgroup/memory/mydocker

total 0

-rw-r--r-- 1 root root 0 Dec  2 21:01 cgroup.clone_children

--w--w--w- 1 root root 0 Dec  2 21:01 cgroup.event_control

-rw-r--r-- 1 root root 0 Dec  2 21:01 cgroup.procs

-rw-r--r-- 1 root root 0 Dec  2 21:01 memory.failcnt

--w------- 1 root root 0 Dec  2 21:01 memory.force_empty

-rw-r--r-- 1 root root 0 Dec  2 21:01 memory.kmem.failcnt

-rw-r--r-- 1 root root 0 Dec  2 21:01 memory.kmem.limit_in_bytes

-rw-r--r-- 1 root root 0 Dec  2 21:01 memory.kmem.max_usage_in_bytes

-r--r--r-- 1 root root 0 Dec  2 21:01 memory.kmem.slabinfo

-rw-r--r-- 1 root root 0 Dec  2 21:01 memory.kmem.tcp.failcnt

-rw-r--r-- 1 root root 0 Dec  2 21:01 memory.kmem.tcp.limit_in_bytes

-rw-r--r-- 1 root root 0 Dec  2 21:01 memory.kmem.tcp.max_usage_in_bytes

-r--r--r-- 1 root root 0 Dec  2 21:01 memory.kmem.tcp.usage_in_bytes

-r--r--r-- 1 root root 0 Dec  2 21:01 memory.kmem.usage_in_bytes

-rw-r--r-- 1 root root 0 Dec  2 21:01 memory.limit_in_bytes

-rw-r--r-- 1 root root 0 Dec  2 21:01 memory.max_usage_in_bytes

-rw-r--r-- 1 root root 0 Dec  2 21:01 memory.memsw.failcnt

-rw-r--r-- 1 root root 0 Dec  2 21:01 memory.memsw.limit_in_bytes

-rw-r--r-- 1 root root 0 Dec  2 21:01 memory.memsw.max_usage_in_bytes

-r--r--r-- 1 root root 0 Dec  2 21:01 memory.memsw.usage_in_bytes

-rw-r--r-- 1 root root 0 Dec  2 21:01 memory.move_charge_at_immigrate

-r--r--r-- 1 root root 0 Dec  2 21:01 memory.numa_stat

-rw-r--r-- 1 root root 0 Dec  2 21:01 memory.oom_control

---------- 1 root root 0 Dec  2 21:01 memory.pressure_level

-rw-r--r-- 1 root root 0 Dec  2 21:01 memory.soft_limit_in_bytes

-r--r--r-- 1 root root 0 Dec  2 21:01 memory.stat

-rw-r--r-- 1 root root 0 Dec  2 21:01 memory.swappiness

-r--r--r-- 1 root root 0 Dec  2 21:01 memory.usage_in_bytes

-rw-r--r-- 1 root root 0 Dec  2 21:01 memory.use_hierarchy

-rw-r--r-- 1 root root 0 Dec  2 21:01 notify_on_release

-rw-r--r-- 1 root root 0 Dec  2 21:01 tasks

其中 memory.limit_in_bytes 文件代表内存使用总量，单位为 byte。

例如，这里我希望对内存使用限制为 1G，则向 memory.limit_in_bytes 文件写入 1073741824，命令如下：

[root@master mydocker]#  cd /sys/fs/cgroup/memory/mydocker

[root@master mydocker]# pwd

/sys/fs/cgroup/memory/mydocker

[root@master mydocker]# echo 1073741824 > memory.limit_in_bytes

[root@master mydocker]# cat memory.limit_in_bytes

1073741824

第二步：创建进程，加入 cgroup

同样把当前 shell 进程 ID 写入 tasks 文件内：

[root@master mydocker]# echo $$ > tasks

[root@master mydocker]# cat tasks

16532

120257

第三步，执行内存测试工具，申请内存

[root@master mydocker]# memtester 1500m 1

memtester version 4.5.1 (64-bit)

Copyright (C) 2001-2020 Charles Cazabon.

Licensed under the GNU General Public License version 2 (only).

pagesize is 4096

pagesizemask is 0xfffffffffffff000

want 1500MB (1572864000 bytes)

got  1500MB (1572864000 bytes), trying mlock ...over system/pre-process limit, reducing...

got  1499MB (1572859904 bytes), trying mlock ...over system/pre-process limit, reducing...

got  1499MB (1572855808 bytes), trying mlock ...over system/pre-process limit, reducing...

got  1499MB (1572851712 bytes), trying mlock ...over system/pre-process limit, reducing...

got  1499MB (1572847616 bytes), trying mlock ...over system/pre-process limit, reducing...

got  1499MB (1572843520 bytes), trying mlock ...over system/pre-process limit, reducing...

...

该命令会申请 1500 M 内存，并且做内存测试。由于上面我们对当前 shell 进程内存限制为 1 G，当 memtester 使用的内存达到 1G 时，根据提示，已经超出上限。

我们可以降低一下内存申请，将内存申请调整为 500M：

[root@master mydocker]# memtester 500m 1

memtester version 4.5.1 (64-bit)

Copyright (C) 2001-2020 Charles Cazabon.

Licensed under the GNU General Public License version 2 (only).

pagesize is 4096

pagesizemask is 0xfffffffffffff000

want 500MB (524288000 bytes)

got  500MB (524288000 bytes), trying mlock ...locked.

Loop 1/1:

  Stuck Address       : ok

  Random Value        : ok

  Compare XOR         : ok

  Compare SUB         : ok

  Compare MUL         : ok

  Compare DIV         : ok

  Compare OR          : ok

  Compare AND         : ok

  Sequential Increment: ok

  Solid Bits          : ok

  Block Sequential    : ok

  Checkerboard        : ok

  Bit Spread          : ok

  Bit Flip            : ok

  Walking Ones        : ok

  Walking Zeroes      : ok

  8-bit Writes        : ok

  16-bit Writes       : ok

Done.

这里可以看到，此时 memtester 已经成功申请到 500M 内存并且正常完成了内存测试。

删除cgroups子系统

借助libcgroup工具删除目录

[root@master cpu]# yum install libcgroup

[root@master cpu]# yum install libcgroup-tools

进入cgroup子系统目录下,使用cgdelete删除进行删除，比如我们要删除我们现在在cpu下创建的mydocker

cgdelete cpu:/mydocker/

3、Docker是如何使用cgroups的？

Linux Cgroups 的设计还是比较易用的，简单粗暴地理解呢，它就是一个子系统目录加上一组资源限制文件的组合。而对于 Docker 等 Linux 容器项目来说，它们只需要在每个子系统下面，为每个容器创建一个控制组（即创建一个新目录），然后在启动容器进程之后，把这个进程的 PID 填写到对应控制组的 tasks 文件中就可以了。

而至于在这些控制组下面的资源文件里填上什么值，就靠用户执行 docker run 时的参数指定了。

首先，我们使用以下命令创建一个 nginx 容器：

[root@master ~]# docker run -it -m=1g nginx

上述命令创建并启动了一个 nginx 容器，并且限制内存为 1G。然后我们进入cgroups内存子系统的目录，使用 ls 命令查看一下该目录下的内容：

[root@master memory]# ls -l /sys/fs/cgroup/memory/

total 0

-rw-r--r--  1 root root 0 Dec  2 18:01 cgroup.clone_children

--w--w--w-  1 root root 0 Dec  2 18:01 cgroup.event_control

-rw-r--r--  1 root root 0 Dec  2 18:01 cgroup.procs

-r--r--r--  1 root root 0 Dec  2 18:01 cgroup.sane_behavior

drwxr-xr-x  3 root root 0 Dec  2 23:52 docker

-rw-r--r--  1 root root 0 Dec  2 18:01 memory.failcnt

--w-------  1 root root 0 Dec  2 18:01 memory.force_empty

-rw-r--r--  1 root root 0 Dec  2 18:01 memory.kmem.failcnt

-rw-r--r--  1 root root 0 Dec  2 18:01 memory.kmem.limit_in_bytes

-rw-r--r--  1 root root 0 Dec  2 18:01 memory.kmem.max_usage_in_bytes

-r--r--r--  1 root root 0 Dec  2 18:01 memory.kmem.slabinfo

-rw-r--r--  1 root root 0 Dec  2 18:01 memory.kmem.tcp.failcnt

-rw-r--r--  1 root root 0 Dec  2 18:01 memory.kmem.tcp.limit_in_bytes

-rw-r--r--  1 root root 0 Dec  2 18:01 memory.kmem.tcp.max_usage_in_bytes

-r--r--r--  1 root root 0 Dec  2 18:01 memory.kmem.tcp.usage_in_bytes

-r--r--r--  1 root root 0 Dec  2 18:01 memory.kmem.usage_in_bytes

-rw-r--r--  1 root root 0 Dec  2 18:01 memory.limit_in_bytes

-rw-r--r--  1 root root 0 Dec  2 18:01 memory.max_usage_in_bytes

-rw-r--r--  1 root root 0 Dec  2 18:01 memory.memsw.failcnt

-rw-r--r--  1 root root 0 Dec  2 18:01 memory.memsw.limit_in_bytes

-rw-r--r--  1 root root 0 Dec  2 18:01 memory.memsw.max_usage_in_bytes

-r--r--r--  1 root root 0 Dec  2 18:01 memory.memsw.usage_in_bytes

-rw-r--r--  1 root root 0 Dec  2 18:01 memory.move_charge_at_immigrate

-r--r--r--  1 root root 0 Dec  2 18:01 memory.numa_stat

-rw-r--r--  1 root root 0 Dec  2 18:01 memory.oom_control

----------  1 root root 0 Dec  2 18:01 memory.pressure_level

-rw-r--r--  1 root root 0 Dec  2 18:01 memory.soft_limit_in_bytes

-r--r--r--  1 root root 0 Dec  2 18:01 memory.stat

-rw-r--r--  1 root root 0 Dec  2 18:01 memory.swappiness

-r--r--r--  1 root root 0 Dec  2 18:01 memory.usage_in_bytes

-rw-r--r--  1 root root 0 Dec  2 18:01 memory.use_hierarchy

-rw-r--r--  1 root root 0 Dec  2 18:01 notify_on_release

-rw-r--r--  1 root root 0 Dec  2 18:01 release_agent

drwxr-xr-x 63 root root 0 Dec  2 23:55 system.slice

-rw-r--r--  1 root root 0 Dec  2 23:25 tasks

drwxr-xr-x  2 root root 0 Dec  2 18:01 user.slice

通过上面输出可以看到，该目录下有一个 docker 目录，该目录正是 Docker 在内存子系统下创建的。我们进入到 docker 目录下查看一下相关内容：

[root@master docker]# ls -l /sys/fs/cgroup/memory/docker/

total 0

drwxr-xr-x 2 root root 0 Dec  2 23:52 aa2d616b64929e5bc098678a98bc9668f188956c192b7c00c2b849fc369ee59c

-rw-r--r-- 1 root root 0 Dec  2 23:52 cgroup.clone_children

--w--w--w- 1 root root 0 Dec  2 23:52 cgroup.event_control

-rw-r--r-- 1 root root 0 Dec  2 23:52 cgroup.procs

-rw-r--r-- 1 root root 0 Dec  2 23:52 memory.failcnt

--w------- 1 root root 0 Dec  2 23:52 memory.force_empty

-rw-r--r-- 1 root root 0 Dec  2 23:52 memory.kmem.failcnt

-rw-r--r-- 1 root root 0 Dec  2 23:52 memory.kmem.limit_in_bytes

-rw-r--r-- 1 root root 0 Dec  2 23:52 memory.kmem.max_usage_in_bytes

-r--r--r-- 1 root root 0 Dec  2 23:52 memory.kmem.slabinfo

-rw-r--r-- 1 root root 0 Dec  2 23:52 memory.kmem.tcp.failcnt

-rw-r--r-- 1 root root 0 Dec  2 23:52 memory.kmem.tcp.limit_in_bytes

-rw-r--r-- 1 root root 0 Dec  2 23:52 memory.kmem.tcp.max_usage_in_bytes

-r--r--r-- 1 root root 0 Dec  2 23:52 memory.kmem.tcp.usage_in_bytes

-r--r--r-- 1 root root 0 Dec  2 23:52 memory.kmem.usage_in_bytes

-rw-r--r-- 1 root root 0 Dec  2 23:52 memory.limit_in_bytes

-rw-r--r-- 1 root root 0 Dec  2 23:52 memory.max_usage_in_bytes

-rw-r--r-- 1 root root 0 Dec  2 23:52 memory.memsw.failcnt

-rw-r--r-- 1 root root 0 Dec  2 23:52 memory.memsw.limit_in_bytes

-rw-r--r-- 1 root root 0 Dec  2 23:52 memory.memsw.max_usage_in_bytes

-r--r--r-- 1 root root 0 Dec  2 23:52 memory.memsw.usage_in_bytes

-rw-r--r-- 1 root root 0 Dec  2 23:52 memory.move_charge_at_immigrate

-r--r--r-- 1 root root 0 Dec  2 23:52 memory.numa_stat

-rw-r--r-- 1 root root 0 Dec  2 23:52 memory.oom_control

---------- 1 root root 0 Dec  2 23:52 memory.pressure_level

-rw-r--r-- 1 root root 0 Dec  2 23:52 memory.soft_limit_in_bytes

-r--r--r-- 1 root root 0 Dec  2 23:52 memory.stat

-rw-r--r-- 1 root root 0 Dec  2 23:52 memory.swappiness

-r--r--r-- 1 root root 0 Dec  2 23:52 memory.usage_in_bytes

-rw-r--r-- 1 root root 0 Dec  2 23:52 memory.use_hierarchy

-rw-r--r-- 1 root root 0 Dec  2 23:52 notify_on_release

-rw-r--r-- 1 root root 0 Dec  2 23:52 tasks

可以看到 docker 的目录下有一个一串随机 ID 的目录，该目录即为我们上面创建的 nginx 容器的 ID。然后我们进入该目录，查看一下该容器的 memory.limit_in_bytes 文件的内容。

[root@master docker]# cd aa2d616b64929e5bc098678a98bc9668f188956c192b7c00c2b849fc369ee59c

# cat memory.limit_in_bytes

1073741824

可以看到内存限制值正好为 1G。

事实上，Docker 创建容器时，Docker 会根据启动容器的参数，在对应的 cgroups 子系统下创建以容器 ID 为名称的目录, 然后根据容器启动时设置的资源限制参数, 修改对应的 cgroups 子系统资源限制文件, 从而达到资源限制的效果。