<p>在使用 docker 运行容器时，一台主机上可能会运行几百个容器，这些容器虽然互相隔离，但是底层却使用着相同的 CPU、内存和磁盘资源。如果不对容器使用的资源进行限制，那么容器之间会互相影响，小的来说会导致容器资源使用不公平；大的来说，可能会导致主机和集群资源耗尽，服务完全不可用。</p>    <p>docker 作为容器的管理者，自然提供了控制容器资源的功能。正如使用内核的 namespace 来做容器之间的隔离，docker 也是通过内核的 cgroups 来做容器的资源限制。这篇文章就介绍如何使用 docker 来限制 CPU、内存和 IO，以及对应的 cgroups 文件。</p>    <p>NOTE：如果想要了解 cgroups 的更多信息，可以参考 <a href="/misc/goto?guid=4959751234813967910" rel="nofollow,noindex">kernel 文档</a> 或者其他资源。</p>    <p>我本地测试的 docker 版本是 17.03.0 社区版：</p>    <pre>  ➜  stress docker version  Client:   Version:      17.03.0-ce   API version:  1.26   Go version:   go1.7.5   Git commit:   60ccb22   Built:        Thu Feb 23 11:02:43 2017   OS/Arch:      linux/amd64    Server:   Version:      17.03.0-ce   API version:  1.26 (minimum version 1.12)   Go version:   go1.7.5   Git commit:   60ccb22   Built:        Thu Feb 23 11:02:43 2017   OS/Arch:      linux/amd64   Experimental: false</pre>    <p>使用的是 ubuntu 16.04 系统，内核版本是 4.10.0 ：</p>    <pre>  ➜  ~ uname -a  Linux cizixs-ThinkPad-T450 4.10.0-28-generic #32~16.04.2-Ubuntu SMP Thu Jul 20 10:19:48 UTC 2017 x86_64 x86_64 x86_64 GNU/Linux</pre>    <p>NOTE:不同版本和系统的功能会有差异，具体的使用方法和功能解释请以具体版本的 docker 官方文档为准。</p>    <p>我们使用 <a href="/misc/goto?guid=4959751234910897421" rel="nofollow,noindex">stress</a> 容器来产生 CPU、内存和 IO 的压力，具体的使用请参考它的帮助文档。</p>    <h2>1. CPU 资源</h2>    <p>主机上的进程会通过时间分片机制使用 CPU，CPU 的量化单位是频率，也就是每秒钟能执行的运算次数。为容器限制 CPU 资源并不能改变 CPU 的运行频率，而是改变每个容器能使用的 CPU 时间片。理想状态下，CPU 应该一直处于运算状态（并且进程需要的计算量不会超过 CPU 的处理能力）。</p>    <h3>docker 限制 CPU Share</h3>    <p>docker 允许用户为每个容器设置一个数字，代表容器的 CPU share，默认情况下每个容器的 share 是 1024。要注意，这个 share 是相对的，本身并不能代表任何确定的意义。当主机上有多个容器运行时，每个容器占用的 CPU 时间比例为它的 share 在总额中的比例。举个例子，如果主机上有两个一直使用 CPU 的容器（为了简化理解，不考虑主机上其他进程），其 CPU share 都是 1024，那么两个容器 CPU 使用率都是 50%；如果把其中一个容器的 share 设置为 512，那么两者 CPU 的使用率分别为 67% 和 33%；如果删除 share 为 1024 的容器，剩下来容器的 CPU 使用率将会是 100%。</p>    <p>总结下来，这种情况下，docker 会根据主机上运行的容器和进程动态调整每个容器使用 CPU 的时间比例。这样的好处是能保证 CPU 尽可能处于运行状态，充分利用 CPU 资源，而且保证所有容器的相对公平；缺点是无法指定容器使用 CPU 的确定值。</p>    <p>docker 为容器设置 CPU share 的参数是 -c --cpu-shares ，它的值是一个整数。</p>    <p>我的机器是 4 核 CPU，因此使用 stress 启动 4 个进程来产生计算压力：</p>    <pre>  ➜  stress docker run --rm -it stress --cpu 4  stress: info: [1] dispatching hogs: 4 cpu, 0 io, 0 vm, 0 hdd  stress: dbug: [1] using backoff sleep of 12000us  stress: dbug: [1] --> hogcpu worker 4 [7] forked  stress: dbug: [1] using backoff sleep of 9000us  stress: dbug: [1] --> hogcpu worker 3 [8] forked  stress: dbug: [1] using backoff sleep of 6000us  stress: dbug: [1] --> hogcpu worker 2 [9] forked  stress: dbug: [1] using backoff sleep of 3000us  stress: dbug: [1] --> hogcpu worker 1 [10] forked</pre>    <p>在另外一个 terminal 使用 htop 查看资源的使用情况：</p>    <p><img src="https://simg.open-open.com/show/9573b0de54838c884876b63c254f8e97.jpg"></p>    <p>从上图中可以看到，CPU 四个核资源都达到了 100%。四个 stress 进程 CPU 使用率没有达到 100% 是因为系统中还有其他机器在运行。</p>    <p>为了比较，我另外启动一个 share 为 512 的容器：</p>    <pre>  ➜  stress docker run --rm -it -c 512 stress --cpu 4   stress: info: [1] dispatching hogs: 4 cpu, 0 io, 0 vm, 0 hdd  stress: dbug: [1] using backoff sleep of 12000us  stress: dbug: [1] --> hogcpu worker 4 [6] forked  stress: dbug: [1] using backoff sleep of 9000us  stress: dbug: [1] --> hogcpu worker 3 [7] forked  stress: dbug: [1] using backoff sleep of 6000us  stress: dbug: [1] --> hogcpu worker 2 [8] forked  stress: dbug: [1] using backoff sleep of 3000us  stress: dbug: [1] --> hogcpu worker 1 [9] forked</pre>    <p>因为默认情况下，容器的 CPU share 为 1024，所以这两个容器的 CPU 使用率应该大致为 2：1，下面是启动第二个容器之后的监控截图：</p>    <p><img src="https://simg.open-open.com/show/042acc396663092c7810c105c477b1f4.jpg"></p>    <p>两个容器分别启动了四个 stress 进程，第一个容器 stress 进程 CPU 使用率都在 54% 左右，第二个容器 stress 进程 CPU 使用率在 25% 左右，比例关系大致为 2：1，符合之前的预期。</p>    <h3>限制容器能使用的 CPU 核数</h3>    <p>上面讲述的 -c --cpu-shares 参数只能限制容器使用 CPU 的比例，或者说优先级，无法确定地限制容器使用 CPU 的具体核数；从 1.13 版本之后，docker 提供了 --cpus 参数可以限定容器能使用的 CPU 核数。这个功能可以让我们更精确地设置容器 CPU 使用量，是一种更容易理解也因此更常用的手段。</p>    <p>--cpus 后面跟着一个浮点数，代表容器最多使用的核数，可以精确到小数点二位，也就是说容器最小可以使用 0.01 核 CPU。比如，我们可以限制容器只能使用 1.5 核数 CPU：</p>    <pre>  ➜  ~ docker run --rm -it --cpus 1.5 stress --cpu 3  stress: info: [1] dispatching hogs: 3 cpu, 0 io, 0 vm, 0 hdd  stress: dbug: [1] using backoff sleep of 9000us  stress: dbug: [1] --> hogcpu worker 3 [7] forked  stress: dbug: [1] using backoff sleep of 6000us  stress: dbug: [1] --> hogcpu worker 2 [8] forked  stress: dbug: [1] using backoff sleep of 3000us  stress: dbug: [1] --> hogcpu worker 1 [9] forked</pre>    <p>在容器里启动三个 stress 来跑 CPU 压力，如果不加限制，这个容器会导致 CPU 的使用率为 300% 左右（也就是说会占用三个核的计算能力）。实际的监控如下图：</p>    <p><img src="https://simg.open-open.com/show/577f7586282358ef9c6017bf5d8fc3c6.jpg"></p>    <p>可以看到，每个 stress 进程 CPU 使用率大约在 50%，总共的使用率为 150%，符合 1.5 核的设置。</p>    <p>如果设置的 --cpus 值大于主机的 CPU 核数，docker 会直接报错：</p>    <pre>  ➜  ~ docker run --rm -it --cpus 8 stress --cpu 3  docker: Error response from daemon: Range of CPUs is from 0.01 to 4.00, as there are only 4 CPUs available.  See 'docker run --help'.</pre>    <p>如果多个容器都设置了 --cpus ，并且它们之和超过主机的 CPU 核数，并不会导致容器失败或者退出，这些容器之间会竞争使用 CPU，具体分配的 CPU 数量取决于主机运行情况和容器的 CPU share 值。也就是说 --cpus 只能保证在 CPU 资源充足的情况下容器最多能使用的 CPU 数，docker 并不能保证在任何情况下容器都能使用这么多的 CPU（因为这根本是不可能的）。</p>    <h3>限制容器运行在某些 CPU 核</h3>    <p>现在的笔记本和服务器都会有多个 CPU，docker 也允许调度的时候限定容器运行在哪个 CPU 上。比如，我的主机上有 4 个核，可以通过 --cpuset 参数让容器只运行在前两个核上：</p>    <pre>  ➜  ~ docker run --rm -it --cpuset-cpus=0,1 stress --cpu 2  stress: info: [1] dispatching hogs: 2 cpu, 0 io, 0 vm, 0 hdd  stress: dbug: [1] using backoff sleep of 6000us  stress: dbug: [1] --> hogcpu worker 2 [7] forked  stress: dbug: [1] using backoff sleep of 3000us  stress: dbug: [1] --> hogcpu worker 1 [8] forked</pre>    <p>这样，监控中可以看到只有前面两个核 CPU 达到了 100% 使用率。</p>    <p><img src="https://simg.open-open.com/show/a45799b3b711c5bd426673d3411ebda4.jpg"></p>    <p>--cpuset-cpus 参数可以和 -c --cpu-shares 一起使用，限制容器只能运行在某些 CPU 核上，并且配置了使用率。</p>    <p>限制容器运行在哪些核上并不是一个很好的做法，因为它需要实现知道主机上有多少 CPU 核，而且非常不灵活。除非有特别的需求，一般并不推荐在生产中这样使用。</p>    <h3>CPU 信息的 cgroup 文件</h3>    <p>所有和容器 CPU share 有关的配置都在 /sys/fs/cgroup/cpu/docker/<docker_id>/ 目录下面，其中 cpu.shares 保存了 CPU share 的值（其他文件的意义可以查看 cgroups 的官方文档）：</p>    <pre>  ➜  ~ ls /sys/fs/cgroup/cpu/docker/d93c9a660f4a13789d995d56024f160e2267f2dc26ce676daa66ea6435473f6f/     cgroup.clone_children  cpuacct.stat   cpuacct.usage_all     cpuacct.usage_percpu_sys   cpuacct.usage_sys   cpu.cfs_period_us  cpu.shares  notify_on_release  cgroup.procs           cpuacct.usage  cpuacct.usage_percpu  cpuacct.usage_percpu_user  cpuacct.usage_user  cpu.cfs_quota_us   cpu.stat    tasks  ➜  ~ cat /sys/fs/cgroup/cpu/docker/d93c9a660f4a13789d995d56024f160e2267f2dc26ce676daa66ea6435473f6f/cpu.shares   1024</pre>    <p>和 cpuset（限制 CPU 核）有关的文件在 /sys/fs/cgroup/cpuset/docker/<docker_id> 目录下，其中 cpuset.cpus 保存了当前容器能使用的 CPU 核：</p>    <pre>  ➜  ~ ls /sys/fs/cgroup/cpuset/docker/d93c9a660f4a13789d995d56024f160e2267f2dc26ce676daa66ea6435473f6f/  cgroup.clone_children  cpuset.cpus            cpuset.mem_exclusive   cpuset.memory_pressure     cpuset.mems                      notify_on_release  cgroup.procs           cpuset.effective_cpus  cpuset.mem_hardwall    cpuset.memory_spread_page  cpuset.sched_load_balance        tasks  cpuset.cpu_exclusive   cpuset.effective_mems  cpuset.memory_migrate  cpuset.memory_spread_slab  cpuset.sched_relax_domain_level    ➜  ~ cat /sys/fs/cgroup/cpuset/docker/d93c9a660f4a13789d995d56024f160e2267f2dc26ce676daa66ea6435473f6f/cpuset.cpus  0-1</pre>    <p>--cpus 限制 CPU 核数并不像上面两个参数一样有对应的文件对应，它是由 cpu.cfs_period_us 和 cpu.cfs_quota_us 两个文件控制的。如果容器的 --cpus 设置为 3，其对应的这两个文件值为：</p>    <pre>  ➜  ~ cat /sys/fs/cgroup/cpu/docker/233a38cc641f2e4a1bec3434d88744517a2214aff9d8297e908fa13b9aa12e02/cpu.cfs_period_us   100000  ➜  ~ cat /sys/fs/cgroup/cpu/docker/233a38cc641f2e4a1bec3434d88744517a2214aff9d8297e908fa13b9aa12e02/cpu.cfs_quota_us   300000</pre>    <p>其实在 1.12 以及之前的版本，都是通过 --cpu-period 和 --cpu-quota 这两个参数控制容器能使用的 CPU 核数的。前者表示 CPU 的周期数，默认是 100000 ，单位是微秒，也就是 1s，一般不需要修改；后者表示容器的在上述 CPU 周期里能使用的 quota，真正能使用的 CPU 核数就是 cpu-quota / cpu-period ，因此对于 3 核的容器，对应的 cpu-quota 值为 300000 。</p>    <h2>2. 内存资源</h2>    <p>默认情况下，docker 并没有对容器内存进行限制，也就是说容器可以使用主机提供的所有内存。这当然是非常危险的事情，如果某个容器运行了恶意的内存消耗软件，或者代码有内存泄露，很可能会导致主机内存耗尽，因此导致服务不可用。对于这种情况，docker 会设置 docker daemon 的 OOM（out of memory） 值，使其在内存不足的时候被杀死的优先级降低。另外，就是你可以为每个容器设置内存使用的上限，一旦超过这个上限，容器会被杀死，而不是耗尽主机的内存。</p>    <p>限制内存上限虽然能保护主机，但是也可能会伤害到容器里的服务。如果为服务设置的内存上限太小，会导致服务还在正常工作的时候就被 OOM 杀死；如果设置的过大，会因为调度器算法浪费内存。因此，合理的做法包括：</p>    <ul>     <li>为应用做内存压力测试，理解正常业务需求下使用的内存情况，然后才能进入生产环境使用</li>     <li>一定要限制容器的内存使用上限</li>     <li>尽量保证主机的资源充足，一旦通过监控发现资源不足，就进行扩容或者对容器进行迁移</li>     <li>如果可以（内存资源充足的情况），尽量不要使用 swap，swap 的使用会导致内存计算复杂，对调度器非常不友好</li>    </ul>    <h3>docker 限制容器内存使用量</h3>    <p>在 docker 启动参数中，和内存限制有关的包括（参数的值一般是内存大小，也就是一个正数，后面跟着内存单位 b 、 k 、 m 、 g ，分别对应 bytes、KB、MB、和 GB）：</p>    <ul>     <li>-m --memory ：容器能使用的最大内存大小，最小值为 4m</li>     <li>--memory-swap ：容器能够使用的 swap 大小</li>     <li>--memory-swappiness ：默认情况下，主机可以把容器使用的匿名页（anonymous page）swap 出来，你可以设置一个 0-100 之间的值，代表允许 swap 出来的比例</li>     <li>--memory-reservation ：设置一个内存使用的 soft limit，如果 docker 发现主机内存不足，会执行 OOM 操作。这个值必须小于 --memory 设置的值</li>     <li>--kernel-memory ：容器能够使用的 kernel memory 大小，最小值为 4m。</li>     <li>--oom-kill-disable ：是否运行 OOM 的时候杀死容器。只有设置了 -m ，才可以把这个选项设置为 false，否则容器会耗尽主机内存，而且导致主机应用被杀死</li>    </ul>    <p>关于 --memory-swap 的设置必须解释一下， --memory-swap 必须在 --memory 也配置的情况下才能有用。</p>    <ul>     <li>如果 --memory-swap 的值大于 --memory ，那么容器能使用的总内存（内存 + swap）为 --memory-swap 的值，能使用的 swap 值为 --memory-swap 减去 --memory 的值</li>     <li>如果 --memory-swap 为 0，或者和 --memory 的值相同，那么容器能使用两倍于内存的 swap 大小，如果 --memory 对应的值是 200M ，那么容器可以使用 400M swap</li>     <li>如果 --memory-swap 的值为 -1，那么不限制 swap 的使用，也就是说主机有多少 swap，容器都可以使用</li>    </ul>    <p>如果限制容器的内存使用为 64M，在申请 64M 资源的情况下，容器运行正常（如果主机上内存非常紧张，并不一定能保证这一点）：</p>    <pre>  ➜  docker run --rm -it -m 64m stress --vm 1 --vm-bytes 64M --vm-hang 0  WARNING: Your kernel does not support swap limit capabilities or the cgroup is not mounted. Memory limited without swap.  stress: info: [1] dispatching hogs: 0 cpu, 0 io, 1 vm, 0 hdd  stress: dbug: [1] using backoff sleep of 3000us  stress: dbug: [1] --> hogvm worker 1 [7] forked  stress: dbug: [7] allocating 67108864 bytes ...  stress: dbug: [7] touching bytes in strides of 4096 bytes ...  stress: dbug: [7] sleeping forever with allocated memory  .....</pre>    <p>而如果申请 100M 内存，会发现容器里的进程被 kill 掉了（ <strong>worker 7 got signal 9</strong> ，signal 9 就是 kill 信号）</p>    <pre>  ➜  docker run --rm -it -m 64m stress --vm 1 --vm-bytes 100M --vm-hang 0  WARNING: Your kernel does not support swap limit capabilities or the cgroup is not mounted. Memory limited without swap.  stress: info: [1] dispatching hogs: 0 cpu, 0 io, 1 vm, 0 hdd  stress: dbug: [1] using backoff sleep of 3000us  stress: dbug: [1] --> hogvm worker 1 [7] forked  stress: dbug: [7] allocating 104857600 bytes ...  stress: dbug: [7] touching bytes in strides of 4096 bytes ...  stress: FAIL: [1] (415) <-- worker 7 got signal 9  stress: WARN: [1] (417) now reaping child worker processes  stress: FAIL: [1] (421) kill error: No such process  stress: FAIL: [1] (451) failed run completed in 0s</pre>    <p>关于 swap 和 kernel memory 的限制就不在这里过多解释了，感兴趣的可以查看官方的文档。</p>    <h3>内存信息的 cgroups 文件</h3>    <p>对于 docker 来说，它的内存限制也是存放在 cgroups 文件系统的。对于某个容器，你可以在 sys/fs/cgroup/memory/docker/<container_id> 目录下看到容器内存相关的文件：</p>    <pre>  ➜  ls /sys/fs/cgroup/memory/docker/b067fa0c58dcdd4fa856177fac0112655b605fcc9a0fe07e36950f0086f62f46   cgroup.clone_children  memory.kmem.failcnt             memory.kmem.tcp.limit_in_bytes      memory.max_usage_in_bytes        memory.soft_limit_in_bytes  notify_on_release  cgroup.event_control   memory.kmem.limit_in_bytes      memory.kmem.tcp.max_usage_in_bytes  memory.move_charge_at_immigrate  memory.stat                 tasks  cgroup.procs           memory.kmem.max_usage_in_bytes  memory.kmem.tcp.usage_in_bytes      memory.numa_stat                 memory.swappiness  memory.failcnt         memory.kmem.slabinfo            memory.kmem.usage_in_bytes          memory.oom_control               memory.usage_in_bytes  memory.force_empty     memory.kmem.tcp.failcnt         memory.limit_in_bytes               memory.pressure_level            memory.use_hierarchy</pre>    <p>而上面的内存限制对应的文件是 memory.limit_in_bytes ：</p>    <pre>  ➜  cat /sys/fs/cgroup/memory/docker/b067fa0c58dcdd4fa856177fac0112655b605fcc9a0fe07e36950f0086f62f46/memory.limit_in_bytes  67108864</pre>    <h2>3. IO 资源（磁盘）</h2>    <p>对于磁盘来说，考量的参数是容量和读写速度，因此对容器的磁盘限制也应该从这两个维度出发。目前 docker 支持对磁盘的读写速度进行限制，但是并没有方法能限制容器能使用的磁盘容量（一旦磁盘 mount 到容器里，容器就能够使用磁盘的所有容量）。</p>    <pre>  ➜  ~ docker run -it --rm ubuntu:16.04 bash    root@5229f756523c:/# time $(dd if=/dev/zero of=/tmp/test.data bs=10M count=100 && sync)  100+0 records in  100+0 records out  1048576000 bytes (1.0 GB) copied, 3.82859 s, 274 MB/s    real 0m4.124s  user 0m0.000s  sys 0m1.812s</pre>    <h3>限制磁盘的权重</h3>    <p>通过 --blkio-weight 参数可以设置 block 的权重，这个权重和 --cpu-shares 类似，它是一个相对值，取值范围是 10-1000，当多个 block 去屑磁盘的时候，其读写速度和权重成反比。</p>    <p>不过在我的环境中， --blkio-weight 参数虽然设置了对应的 cgroups 值，但是并没有作用，不同 weight 容器的读写速度还是一样的。github 上有一个对应的 <a href="/misc/goto?guid=4959751235004930294" rel="nofollow,noindex">issue</a> ，但是没有详细的解答。</p>    <p>--blkio-weight-device 可以设置某个设备的权重值，测试下来虽然两个容器同时读的速度不同，但是并没有按照对应的比例来限制。</p>    <h3>限制磁盘的读写速率</h3>    <p>除了权重之外，docker 还允许你直接限制磁盘的读写速率，对应的参数有：</p>    <ul>     <li>--device-read-bps ：磁盘每秒最多可以读多少比特（bytes）</li>     <li>--device-write-bps ：磁盘每秒最多可以写多少比特（bytes）</li>    </ul>    <p>上面两个参数的值都是磁盘以及对应的速率，格式为 <device-path>:<limit>[unit] ， device-path 表示磁盘所在的位置，限制 limit 为正整数，单位可以是 kb 、 mb 和 gb 。</p>    <p>比如可以把设备的度速率限制在 1mb：</p>    <pre>  $ docker run -it --device /dev/sda:/dev/sda --device-read-bps /dev/sda:1mb ubuntu:16.04 bash  root@6c048edef769:/# cat /sys/fs/cgroup/blkio/blkio.throttle.read_bps_device   8:0 1048576  root@6c048edef769:/# dd iflag=direct,nonblock if=/dev/sda of=/dev/null bs=5M count=10  10+0 records in  10+0 records out  52428800 bytes (52 MB) copied, 50.0154 s, 1.0 MB/s</pre>    <p>从磁盘中读取 50m 花费了 50s 左右，说明磁盘速率限制起了作用。</p>    <p>另外两个参数可以限制磁盘读写频率（每秒能执行多少次读写操作）：</p>    <ul>     <li>--device-read-iops ：磁盘每秒最多可以执行多少 IO 读操作</li>     <li>--device-write-iops ：磁盘每秒最多可以执行多少 IO 写操作</li>    </ul>    <p>上面两个参数的值都是磁盘以及对应的 IO 上限，格式为 <device-path>:<limit> ，limit 为正整数，表示磁盘 IO 上限数。</p>    <p>比如，我们可以让磁盘每秒最多读 100 次：</p>    <pre>  ➜  ~ docker run -it --device /dev/sda:/dev/sda --device-read-iops /dev/sda:100 ubuntu:16.04 bash  root@2e3026e9ccd2:/# dd iflag=direct,nonblock if=/dev/sda of=/dev/null bs=1k count=1000  1000+0 records in  1000+0 records out  1024000 bytes (1.0 MB) copied, 9.9159 s, 103 kB/s</pre>    <p>从测试中可以看出，容器设置了读操作的 iops 为 100，在容器内部从 block 中读取 1m 数据（每次 1k，一共要读 1000 次），共计耗时约 10s，换算起来就是 100 iops/s，符合预期结果。</p>    <p>写操作 bps 和 iops 与读类似，这里就不再重复了，感兴趣的可以自己实验。</p>    <h3>磁盘信息的 cgroups 文件</h3>    <p>容器中磁盘限制的 cgroups 文件位于 /sys/fs/cgroup/blkio/docker/<docker_id> 目录：</p>    <pre>  ➜  ~ ls /sys/fs/cgroup/blkio/docker/1402c1682cba743b4d80f638da3d4272b2ebdb6dc6c2111acfe9c7f7aeb72917/                                 blkio.io_merged                   blkio.io_serviced                blkio.leaf_weight                blkio.throttle.io_serviced        blkio.time_recursive   tasks  blkio.io_merged_recursive         blkio.io_serviced_recursive      blkio.leaf_weight_device         blkio.throttle.read_bps_device    blkio.weight  blkio.io_queued                   blkio.io_service_time            blkio.reset_stats                blkio.throttle.read_iops_device   blkio.weight_device  blkio.io_queued_recursive         blkio.io_service_time_recursive  blkio.sectors                    blkio.throttle.write_bps_device   cgroup.clone_children  blkio.io_service_bytes            blkio.io_wait_time               blkio.sectors_recursive          blkio.throttle.write_iops_device  cgroup.procs  blkio.io_service_bytes_recursive  blkio.io_wait_time_recursive     blkio.throttle.io_service_bytes  blkio.time                        notify_on_release</pre>    <p>其中 blkio.throttle.read_iops_device 对应了设备的读 IOPS，前面一列是 <a href="/misc/goto?guid=4959751235089408602" rel="nofollow,noindex">设备的编号</a> ，可以通过 cat /proc/partitions 查看设备和分区的设备号；后面是 IOPS 上限值：</p>    <pre>  ➜  ~ cat /sys/fs/cgroup/blkio/docker/1402c1682cba743b4d80f638da3d4272b2ebdb6dc6c2111acfe9c7f7aeb72917/blkio.throttle.read_iops_device   8:0 100</pre>    <p>blkio.throttle.read_bps_device 对应了设备的读速率，格式和 IOPS 类似，只是第二列的值为 bps：</p>    <pre>  ➜  ~ cat /sys/fs/cgroup/blkio/docker/9de94493f1ab4437d9c2c42fab818f12c7e82dddc576f356c555a2db7bc61e21/blkio.throttle.read_bps_device   8:0 1048576</pre>    <h2>总结</h2>    <p>从上面的实验可以看出来，CPU 和内存的资源限制已经是比较成熟和易用，能够满足大部分用户的需求。磁盘限制也是不错的，虽然现在无法动态地限制容量，但是限制磁盘读写速度也能应对很多场景。</p>    <p>至于网络，docker 现在并没有给出网络限制的方案，也不会在可见的未来做这件事情，因为目前网络是通过插件来实现的，和容器本身的功能相对独立，不是很容易实现，扩展性也很差。docker 社区已经有很多呼声，也有 issue 是关于网络流量限制的: <a href="/misc/goto?guid=4959751235173532925" rel="nofollow,noindex">issue 26767</a> 、 <a href="/misc/goto?guid=4959751235252823182" rel="nofollow,noindex">issue 37</a> 、 <a href="/misc/goto?guid=4959751235337687334" rel="nofollow,noindex">issue 4763</a> 。</p>    <p>资源限制一方面可以让我们为容器（应用）设置合理的 CPU、内存等资源，方便管理；另外一方面也能有效地预防恶意的攻击和异常，对容器来说是非常重要的功能。如果你需要在生产环境使用容器，请务必要花时间去做这件事情。</p>    <h2>参考资料</h2>    <ul>     <li><a href="/misc/goto?guid=4959751235426691069" rel="nofollow,noindex">docker docs: Limit a container’s resources</a></li>     <li><a href="/misc/goto?guid=4958848583386733820" rel="nofollow,noindex">Resource management in Docker</a></li>     <li><a href="/misc/goto?guid=4959751235544169496" rel="nofollow,noindex">Docker资源管理探秘：Docker背后的内核Cgroups机制</a></li>    </ul>    <p> </p>    <p>来自：http://cizixs.com/2017/08/04/docker-resources-limit</p>    <p> </p>