• docker-Cgroups的资源限制

    一、Cgroup的介绍

    cgroups，是一个非常强大的linux内核工具，他不仅可以限制被namespace 隔离起来的资源，还可以 为资源设置权重、计算使用量、操控进程启停等等。所以cgroups (Control groups) 实现了对资源的配额和度量。

    cpu时间片的概念

    时间片即CPU分配给各个程序的时间，每个线程被分配一个时间段，称作它的时间片，即该进程允许运行的时间，使各个程序从表面上看是同时进行的。如果在时间片结束时进程还在运行，则CPU将被剥夺并分配给另一个进程。如果进程在时间片结束前阻塞或结束，则CPU当即进行切换。而不会造成CPU资源浪费。

    在宏观上：我们可以同时打开多个应用程序，每个程序并行不悖，同时运行。但在微观上：由于只有一个CPU，一次只能处理程序要求的一部分，如何处理公平，一种方法就是引入时间片，每个程序轮流执行。

    对于资源控制有以下几个方面

    （1）cpu的资源控制

    1.1设置CPU使用率上限

    Linux通过CFS （Completely Fair Scheduler， 完全公平调度器）来调度各个进程对CPU的使用。CFS默认的调度周期是100ms。

    我们可以设置每个容器进程的调度周期，以及在这个周期内各个容器最多能使用多少CPU时间。

    使用 --cpu-period 即可设置调度周期，使用 --cpu-quota 即可设置在每个调度周期内能使用的CPU时间。两者可以配合使用。

    CFS周期的有效范围是1ms ~ 1s， 对应的 --cpu-period 的数值范围是 1000 ~1000000 （单位微秒）。

    而容器的CPU配额必须不小于1ms，即 --cpu-quota 的值必须 >= 1000。

    1.查看容器的默认cpu使用限制

    进行cpu使用率测试

     [root@yuji ~]# docker exec -it test1 bash     #进入容器
     [root@059823a1abbe /]# vi /cpu.sh         #写个死循环脚本
     #!/bin/bash
     i=0
     while true
     do
        let i++
     done
     [root@059823a1abbe /]# chmod +x cpu.sh    #给脚本权限
     [root@059823a1abbe /]# ./cpu.sh           #运行脚本
     ​
     #再开一个终端，查看cpu.sh进程的cpu使用率
     [root@localhost ~]# top                  #可以看到使用率接近100%
        PID USER      PR  NI    VIRT    RES    SHR S  %CPU %MEM     TIME+ COMMAND
       3328 root      20   0   11688   1100    916 R  99.7  0.1   7:04.44 cpu.sh
        
     #之后在容器中使用ctrl+c，停止脚本的执行，再top观察CPU使用率

    1.2 创建容器时设置CPU使用时间限制

    1.  #创建容器test2，并限制CPU使用时间为50000微秒，表示最多占用50%的CPU。
    2.  [root@yuji ~]# docker run -itd --name test2 --cpu-quota 50000 centos:7
    3.  WARNING: IPv4 forwarding is disabled. Networking will not work.
    4.  8e7ba758a231b29dad1f668ba83092e8f637d2a9785999c6d23b27c60935b12b
    5.  #查看CPU限额文件
    6.  [root@yuji ~]# cd /sys/fs/cgroup/cpu/docker/
    7.  [root@yuji docker]# ls
    8.  059823a1abbe2ac6ed35599ca0d3d68049e49263ff9add8f65cc55daa094ec08  cpuacct.usage         cpu.shares
    9.  8e7ba758a231b29dad1f668ba83092e8f637d2a9785999c6d23b27c60935b12b  cpuacct.usage_percpu  cpu.stat
    10.  cgroup.clone_children                                             cpu.cfs_period_us     notify_on_release
    11.  cgroup.event_control                                              cpu.cfs_quota_us      tasks
    12.  cgroup.procs                                                      cpu.rt_period_us
    13.  cpuacct.stat                                                      cpu.rt_runtime_us
    14.  [root@yuji docker]# cd 8e7ba758a231b29dad1f668ba83092e8f637d2a9785999c6d23b27c60935b12b
    15.  [root@yuji 8e7ba758a231b29dad1f668ba83092e8f637d2a9785999c6d23b27c60935b12b]# cat cpu.cfs_quota_us
    16.  50000
    17.  ​
    18.  #登录容器test2，写个死循环脚本并运行
    19.  [root@yuji ~]# docker exec -it test2 bash
    20.  [root@8e7ba758a231 /]#  vi /cpu.sh
    21.  #!/bin/bash
    22.  i=0
    23.  while true
    24.  do
    25.   let i++
    26.  done
    27.  [root@8e7ba758a231 /]# chmod +x cpu.sh
    28.  [root@8e7ba758a231 /]# ./cpu.sh 
    29.  ​
    30.  #再开一个终端，查看cpu使用率
    31.  [root@yuji ~]# top                  #CPU使用率在50%左右
    32.   PID USER      PR  NI    VIRT    RES    SHR S  %CPU %MEM     TIME+ COMMAND
    33.  3746 root      20   0   11688   1096    916 R  50.0  0.1   1:55.26 cpu.sh
    34.  ​
    35.  ​
    36.  #容器的CPU使用时间限制设为50000，而调度周期为100000，表示容器占用50000/100000=50%的CPU。

     

     1.3对已存在的容器进行CPU限制

    直接修改 /sys/fs/cgroup/cpu/docker/容器id/cpu.cfs_quota_us 文件即可

    1.  #进入test1容器目录，修改CPU使用时间限制
    2.  [root@yuji ~]# cd /sys/fs/cgroup/cpu/docker/
    3.  [root@yuji docker]# ls
    4.  059823a1abbe2ac6ed35599ca0d3d68049e49263ff9add8f65cc55daa094ec08  cpuacct.usage         cpu.shares
    5.  8e7ba758a231b29dad1f668ba83092e8f637d2a9785999c6d23b27c60935b12b  cpuacct.usage_percpu  cpu.stat
    6.  cgroup.clone_children                                             cpu.cfs_period_us     notify_on_release
    7.  cgroup.event_control                                              cpu.cfs_quota_us      tasks
    8.  cgroup.procs                                                      cpu.rt_period_us
    9.  cpuacct.stat                                                      cpu.rt_runtime_us
    10.  [root@yuji docker]# cd 059823a1abbe2ac6ed35599ca0d3d68049e49263ff9add8f65cc55daa094ec08
    11.  #修改CPU使用时间限制
    12.  [root@yuji 059823a1abbe2ac6ed35599ca0d3d68049e49263ff9add8f65cc55daa094ec08]# echo "33000" >cpu.cfs_quota_us
    13.  [root@yuji 059823a1abbe2ac6ed35599ca0d3d68049e49263ff9add8f65cc55daa094ec08]# cat cpu.cfs_quota_us
    14.  33000
    15.  ​
    16.  #此时再进入test1容器执行之前创建好的脚本，进行压力测试
    17.  [root@yuji ~]# docker exec -it test1 bash
    18.  [root@059823a1abbe /]# ./cpu.sh
    19.  ​
    20.  #再开一个终端，查看cpu使用率
    21.  [root@localhost ~]# top
    22.   PID USER      PR  NI    VIRT    RES    SHR S  %CPU %MEM     TIME+ COMMAND
    23.  4635 root      20   0   11688   1096    916 R  33.3  0.1   1:27.62 cpu.sh
    24.  ​
    25.  ​
    26.  #容器的CPU使用时间限制设为33000，而调度周期为100000，表示容器占用33000/100000=33%的CPU。

    1.4设置CPU资源占用比（设置多个容器时才有效）

    Docker 通过 --cpu-shares 指定CPU份额，默认值为1024，值为1024的倍数。

     #先删除所有容器
     [root@yuji ~]# docker rm -f $(docker ps -aq)
     9c48e09ea156
     7c7e024b557e
     ​
     #创建两个容器为c1和c2
     #只有这2个容器的情况下，cpu资源分摊给这两个容器，512:1024等于1:2，一个占1/3，一个占2/3。
     [root@yuji ~]# docker run -itd --name c1 --cpu-shares 512 centos:7
     WARNING: IPv4 forwarding is disabled. Networking will not work.
     300b50f13ebef4921029e352f5850b1c81f8f8e28827a8d11f20e55eec94642b
     [root@yuji ~]# docker run -itd --name c2 --cpu-shares 1024 centos:7
     WARNING: IPv4 forwarding is disabled. Networking will not work.
     7a999b00c9eef7fdb916c2914087809e7eba55b1c52aaaabeeda16a4006f57a9
     [root@yuji ~]# docker ps -a
     CONTAINER ID   IMAGE      COMMAND       CREATED         STATUS         PORTS     NAMES
     7a999b00c9ee   centos:7   "/bin/bash"   4 seconds ago   Up 3 seconds             c2
     300b50f13ebe   centos:7   "/bin/bash"   6 seconds ago   Up 5 seconds             c1

     进行cpu使用率测试

     #宿主机开启路由转发功能，使容器能够连通外网
     [root@yuji ~]# echo "net.ipv4.ip_forward = 1" >> /etc/sysctl.conf
     [root@yuji ~]# sysctl -p
     net.ipv4.ip_forward = 1
     ​
     #进入test容器，进行压力测试
     docker exec -it test bash
     yum install -y epel-release    #下载epel源
     yum install -y stress          #安装stress工具
     stress -c 4   #产生四个进程，每个进程都反复不停地计算随机数的平方根
     ​
     #进入test1容器，进行压力测试
     docker exec -it test1 bash
     yum install -y epel-release    #下载epel源
     yum install -y stress          #安装stress工具
     stress -c 4   #产生四个进程，每个进程都反复不停的计算随机数的平方根

    查看容器运行状态，观察CPU使用占比

    1.  #再打开一个终端，查看容器运行状态(动态更新)
    2.  [root@yuji ~]# docker stats     #可以看到CPU使用占比大约是1:2
    3.  CONTAINER ID   NAME      CPU %     MEM USAGE / LIMIT     MEM %     NET I/O          BLOCK I/O        PIDS
    4.  7a999b00c9ee   c2        266.52%   188.9MiB / 1.938GiB   9.52%     32.8MB / 152kB   1.91MB / 50MB    7
    5.  300b50f13ebe   c1        133.03%   203.1MiB / 1.938GiB   10.24%    33.7MB / 603kB   108MB / 51.4MB   7
    6.  ​
    7.  #因为宿主机有4核，所以CPU总百分比是400%。
    8.  #c1:c2 = 133.03%:266.52% ≈ 1:2

    1.5 设置容器绑定指定的CPU（绑核）

     注意：CPU编号从0开始。 编号1、3代表第二个核和第四个核 。\

    --cpuset-cpus

    1.  #先为虚拟机分配4个CPU核数
    2.  ​
    3.  #创建容器c3时，绑定1号和3号这两个CPU
    4.  [root@yuji ~]# docker run -itd --name c3 --cpuset-cpus 1,3 centos:7 /bin/bash
    5.  ​
    6.  #进入容器，进行压力测试
    7.  docker exec -it c3 bash
    8.  yum install -y epel-release    #下载epel源
    9.  yum install -y stress          #安装stress工具
    10.  stress -c 4   #产生四个进程，每个进程都反复不停地计算随机数的平方根
    11.  ​
    12.  #退出容器，执行top命令再按1查看CPU使用情况
    13.  [root@yuji ~]# top    #可以看到CPU1和CPU3占满，其他CPU使用率为0
    14.  top - 01:12:49 up  4:01,  3 users,  load average: 3.47, 2.96, 2.49
    15.  Tasks: 183 total,   6 running, 177 sleeping,   0 stopped,   0 zombie
    16.  %Cpu0  :  0.0 us,  0.0 sy,  0.0 ni,100.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
    17.  %Cpu1  :100.0 us,  0.0 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
    18.  %Cpu2  :  0.0 us,  0.0 sy,  0.0 ni,100.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
    19.  %Cpu3  :100.0 us,  0.0 sy,  0.0 ni,  0.0 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
    20.  KiB Mem :  2031912 total,   150852 free,   635800 used,  1245260 buff/cache
    21.  KiB Swap:  4194300 total,  4194236 free,       64 used.  1138692 avail Mem

     

     

     二、对内存使用的限制

               限制容器可以使用的最大内存

    -m （或--memory=）选项用于限制容器可以使用的最大内存

    1.  #-m(--memory=)选项用于限制容器可以使用的最大内存。
    2.  ​
    3.  #创建容器c4，并限制容器可以使用的最大内存为512m
    4.  [root@yuji ~]# docker run -itd --name c4 -m 512m centos:7 /bin/bash
    5.  ​
    6.  #查看容器状态，可以看到c4可以使用的最大内存是512M
    7.  [root@yuji ~]# docker stats
    8.  CONTAINER ID   NAME      CPU %     MEM USAGE / LIMIT     MEM %     NET I/O          BLOCK I/O         PIDS
    9.  437180fc6266   c4        0.00%     396KiB / 512MiB       0.08%     648B / 0B        0B / 0B           1
    10.  ebcc06da3a03   c3        0.00%     174.2MiB / 1.938GiB   8.78%     32.8MB / 196kB   47.7MB / 50.6MB   1
    11.  7a999b00c9ee   c2        0.00%     101.7MiB / 1.938GiB   5.13%     32.9MB / 152kB   1.91MB / 50MB     2
    12.  300b50f13ebe   c1        0.00%     113MiB / 1.938GiB     5.69%     33.7MB / 603kB   108MB / 51.4MB    1

     三、 限制容器可用的swap 大小

    1.  #限制可用的swap 大小，--memory-swap
    2.  ●强调一下， --memory-swap是必须要与 --memory（或-m）一起使用的。
    3.  ●正常情况下， --memory-swap 的值包含容器可用内存和可用swap 。
    4.  ●所以 -m 300m --memory-swap=1g 的含义为：容器可以使用300M 的物理内存，并且可以使用700M (1G - 300M)的swap。
    5.  ​
    6.  设置为0或者不设置，则容器可以使用的 swap 大小为 -m 值的两倍。
    7.  如果 --memory-swap 的值和 -m 值相同，则容器不能使用swap。
    8.  如果 --memory-swap 值为 -1，它表示容器程序使用的内存受限，而可以使用的swap空间使用不受限制（宿主机有多少swap 容器就可以使用多少）。

    实例

     #--memory-swap 的值包含容器可用内存和可用swap，减去-m的值才是可用swap的值。
     #表示容器可以使用512M的物理内存，并且可以使用512M的swap。因为1g减去512m的物理内存，剩余值才是可用swap。
     docker run -itd --name yy01 -m 512m --memory-swap=1g centos:7 bash
     ​
     ​
     #--memoryswap值和 -m 的值相同，表示容器无法使用swap
     docker run -itd --name yy02 -m 512m --memory-swap=512m centos:7 bash
     ​
     ​
     # --memory-swap 的值设置为0或者不设置，则容器可以使用的 swap 大小为 -m 值的两倍。
     docker run -itd --name yy03 -m 512m centos:7 bash
     ​
     ​
     # --memory-swap 值为 -1，它表示容器程序使用的内存受限，但可以使用的swap空间使用不受限制（宿主机有多少swap 容器就可以使用多少）。
     docker run -itd --name yy04 -m 512m --memory-swap=-1 centos:7 bash

    四、 对磁盘IO的配置控制（blkio）的限制

    --device-read-bps：限制某个设备上的读速度bps ( 数据量)，单位可以是kb、mb (M)或者gb。

    --device-write-bps : 限制某个设备上的写速度bps ( 数据量)，单位可以是kb、mb (M)或者gb。

    --device-read-iops :限制读某个设备的iops (次数)

    --device-write-iops :限制写入某个设备的iops ( 次数)

    1.  --device-read-bps:限制某个设备上的读速度bps ( 数据量)，单位可以是kb、mb (M)或者gb。
    2.  例: docker run -itd --name test9 --device-read-bps /dev/sda:1M centos:7 /bin/bash
    3.  #表示该容器每秒只能读取1M的数据量
    4.  ​
    5.  --device-write-bps : 限制某个设备上的写速度bps ( 数据量)，单位可以是kb、mb (M)或者gb。
    6.  例: docker run -itd --name test10 --device-write-bps /dev/sda:1mb centos:7 /bin/bash
    7.  #表示该容器每秒只能写入1M的数据量
    8.  ​
    9.  --device-read-iops :限制读某个设备的iops (次数)
    10.  --device-write-iops :限制写入某个设备的iops ( 次数)

    4.1创建容器，不限制写速度

     #创建容器tt01，不限制写入速度
     docker run -it --name tt01 centos:7 /bin/bash
     ​
     #通过dd来验证写速度，拷贝50M的数据
     dd if=/dev/zero of=/opt/test.out bs=10M count=5 oflag=direct   #添加oflag参数以规避掉文件系统cache
     ​
     #创建容器tt01，不限制写入速度
     [root@yuji ~]# docker run -it --name tt01 centos:7 /bin/bash
     #通过dd来验证写速度，拷贝50M的数据到容器中
     [root@a62f5b811e58 /]# dd if=/dev/zero of=/opt/test.out bs=10M count=5 oflag=direct   #添加oflag参数以规避掉文件系统cache
     5+0 records in
     5+0 records out
     52428800 bytes (52 MB) copied, 0.0948474 s, 553 MB/s
     ​
     #没有限制写速度的情况下，写入很快，0.09秒的时间内已写入50M的数据，写入速度为553M/s。

     4.2创建容器，并限制写速度

    1.  #创建容器，并限制写入速度为1MB/s，即每秒只能写入1MB的数据量。
    2.  [root@yuji ~]# docker run -it --name tt02 --device-write-bps /dev/sda:1mb centos:7 bash
    3.  #通过dd来验证写速度，拷贝50M的数据到容器中
    4.  [root@655f6cca0175 /]# dd if=/dev/zero of=/opt/test.out bs=10M count=5 oflag=direct  #添加oflag参数以规避掉文件系统cache
    5.  5+0 records in
    6.  5+0 records out
    7.  52428800 bytes (52 MB) copied, 50.0048 s, 1.0 MB/s
    8.  ​
    9.  #写入50M的数据，需要50s左右，因为限制了容器的写速度是 1.0 MB/s。

    五 清除docker占用的磁盘空间

    docker system prune -a 可用于清理磁盘，删除关闭的容器、无用的数据卷和网络。

    1.  #查看容器
    2.  [root@yuji ~]# docker ps -a
    3.  CONTAINER ID   IMAGE      COMMAND       CREATED          STATUS                      PORTS     NAMES
    4.  655f6cca0175   centos:7   "bash"        10 minutes ago   Exited (0) 4 minutes ago              tt02
    5.  a62f5b811e58   centos:7   "/bin/bash"   19 minutes ago   Exited (0) 11 minutes ago             tt01
    6.  437180fc6266   centos:7   "/bin/bash"   36 minutes ago   Up 36 minutes                         c4
    7.  ebcc06da3a03   centos:7   "/bin/bash"   50 minutes ago   Up 50 minutes                         c3
    8.  #清理磁盘，删除关闭的容器、无用的数据卷和网络。
    9.  [root@yuji ~]# docker system prune -a
    10.  WARNING! This will remove:                                   #提示
    11.    - all stopped containers                                   #删除清理所有停止的容器
    12.    - all networks not used by at least one container          #删除未被使用的网络
    13.    - all images without at least one container associated to them  #未被使用的镜像
    14.    - all build cache                                         #删除已建立的缓存
    15.  ​
    16.  Are you sure you want to continue? [y/N] y                #是否确定删除
    17.  Deleted Containers:
    18.  655f6cca01754d27a080e01b64aa26c4f96642ab5b5931b186ad04082a98430f
    19.  a62f5b811e584cc6e8d344830d5df9ddcbdd72761966989245b0c52f6abb9a4a
    20.  ......
    21.  Total reclaimed space: 451MB
    22.  
    23.  ​
    24.  #再次查看容器，只剩下启动中的容器
    25.  [root@localhost ~]# docker ps -a
    26.  CONTAINER ID   IMAGE      COMMAND       CREATED          STATUS          PORTS     NAMES
    27.  525d77ff7423   centos:7   "/bin/bash"   3 minutes ago    Up 3 minutes              c6
    28.  fb2ee21e0468   centos:7   "/bin/bash"   12 minutes ago   Up 12 minutes             c4
    29.  81e3ea8f526e   centos:7   "/bin/bash"   18 minutes ago   Up 18 minutes             c3

     总结

    1.对cpu的限制参数

     docker run -cpu-period     #设置调度周期时间1000~1000000
                -cpu-quota      #设置容器进程的CPU占用时间，要与调度周期时间成比例
                --cpu-shares    #设置多个容器之间的CPU资源占用比
                --cpuset-cpus   #绑核（第一个CPU编号从0开始）

    2.对内存的限制

    -m 物理内存 [--memory-swap=总值]

    3.对磁盘IO的限制

     --device-read-bps 设备文件:1mb/1M     #限制读速度
     --device-write-bps 设备文件:1mb/1M    #限制写速度
     --device-read-iops                   #限制读次数
     --device-write-iops                  #限制写次数
     ​
     docker system prune -a    #清理磁盘，删除关闭的容器、无用的数据卷和网络。

  • 相关阅读:
    11.Java面向对象进阶（3）
    安装国产系统Kylin-Desktop实战
    【记一次vsan数据救援的经历】
    ide 快捷键
    【读书笔记】《学习究竟是什么》——学精第一
    60页5G+智慧农业大数据 2022
    mac 安装cnpm 淘宝镜像记录
    CF1574B Combinatorics Homework
    【软件教程】如何用C++交叉编译出能在Android运行的ELF程序或so动态库
    [C/C++]数据结构 链表OJ题: 链表分割
  • 原文地址：https://blog.csdn.net/weixin_48271370/article/details/128006488