Docker系列之九:Docker 运行时资源限制


title: Docker系列之九:Docker 运行时资源限制
categories: Docker
tags:
- Docker
timezone: Asia/Shanghai
date: 2019-02-25


Docker 运行时资源限制

一个 docker host 上会运行若干容器,每个容器都需要 CPU、内存和 IO 资源。对于 KVM,VMware 等虚拟化技术,用户可以控制分配多少 CPU、内存资源给每个虚拟机。对于容器,Docker 也提供了类似的机制避免某个容器因占用太多资源而影响其他容器乃至整个 host 的性能

Docker 基于 Linux 内核提供的 cgroups 功能,可以限制容器在运行时使用到的资源,比如内存、CPU、块 I/O、网络等。

docker 作为容器的管理者,自然提供了控制容器资源的功能。正如使用内核的 namespace 来做容器之间的隔离,docker 也是通过内核的 cgroups 来做容器的资源限制;包括CPU、内存、磁盘三大方面,基本覆盖了常见的资源配额和使用量控制。

Docker内存控制OOME在linxu系统上,如果内核探测到当前宿主机已经没有可用内存使用,那么会抛出一个OOME(Out Of Memory Exception:内存异常 ),并且会开启killing去杀掉一些进程。

一旦发生OOME,任何进程都有可能被杀死,包括docker daemon在内,为此,docker特地调整了docker daemon的OOM_Odj优先级,以免他被杀掉,但容器的优先级并未被调整。经过系统内部复制的计算后,每个系统进程都会有一个OOM_Score得分,OOM_Odj越高,得分越高,(在docker run的时候可以调整OOM_Odj)得分最高的优先被kill掉,当然,也可以指定一些特定的重要的容器禁止被OMM杀掉,在启动容器时使用 –oom-kill-disable=true指定。

cgroup简介

cgroup是Control Groups的缩写,是Linux 内核提供的一种可以限制、记录、隔离进程组所使用的物理资源(如 cpu、memory、磁盘IO等等) 的机制,被LXC、docker等很多项目用于实现进程资源控制。cgroup将任意进程进行分组化管理的 Linux 内核功能。cgroup本身是提供将进程进行分组化管理的功能和接口的基础结构,I/O 或内存的分配控制等具体的资源管理功能是通过这个功能来实现的。这些具体的资源管理功能称为cgroup子系统,有以下几大子系统实现:

  • blkio:设置限制每个块设备的输入输出控制。例如:磁盘,光盘以及usb等等。
  • cpu:使用调度程序为cgroup任务提供cpu的访问。
  • cpuacct:产生cgroup任务的cpu资源报告。
  • cpuset:如果是多核心的cpu,这个子系统会为cgroup任务分配单独的cpu和内存。
  • devices:允许或拒绝cgroup任务对设备的访问。
  • freezer:暂停和恢复cgroup任务。
  • memory:设置每个cgroup的内存限制以及产生内存资源报告。
  • net_cls:标记每个网络包以供cgroup方便使用。
  • ns:命名空间子系统。
  • perf_event:增加了对每group的监测跟踪的能力,即可以监测属于某个特定的group的所有线程以及运行在特定CPU上的线程。

目前docker只是用了其中一部分子系统,实现对资源配额和使用的控制。

一.内存限额

1.概述

Docker 提供的内存限制功能有以下几点:

  • 容器能使用的内存和交换分区大小。
  • 容器的核心内存大小。
  • 容器虚拟内存的交换行为。
  • 容器内存的软性限制。
  • 是否杀死占用过多内存的容器。
  • 容器被杀死的优先级

2.内存限制相关的参数

-m,--memory     内存限制,格式是数字加单位,单位可以为 b,k,m,g。最小为 4M
--memory-swap   内存+交换分区大小总限制。格式同上。必须必-m设置的大
--memory-reservation    内存的软性限制。格式同上
--oom-kill-disable      是否阻止 OOM killer 杀死容器,默认没设置
--oom-score-adj         容器被 OOM killer 杀死的优先级,范围是[-1000, 1000],默认为 0
--memory-swappiness     用于设置容器的虚拟内存控制行为。值为 0~100 之间的整数
--kernel-memory         核心内存限制。格式同上,最小为 4M

用户内存限制就是对容器能使用的内存和交换分区的大小作出限制。
使用时要遵循两条直观的规则:

-m,--memory选项的参数最小为 4M。
--memory-swap不是交换分区,而是内存加交换分区的总大小,所以--memory-swap必须比-m,--memory大。

在这两条规则下,一般有四种设置方式。

1.不设置

如果不设置-m,--memory--memory-swap,容器默认可以用完宿舍机的所有内存和 swap 分区。不过注意,如果容器占用宿主机的所有内存和 swap 分区超过一段时间后,会被宿主机系统杀死(如果没有设置--00m-kill-disable=true的话)。

2.设置-m,--memory,不设置--memory-swap

给-m或--memory设置一个不小于 4M 的值,假设为 a,不设置--memory-swap,或将--memory-swap设置为 0。这种情况下,容器能使用的内存大小为 a,能使用的交换分区大小也为 a。因为 Docker 默认容器交换分区的大小和内存相同。

如果在容器中运行一个一直不停申请内存的程序,你会观察到该程序最终能占用的内存大小为 2a。

比如$ docker run -m 1G ubuntu:16.04,该容器能使用的内存大小为 1G,能使用的 swap 分区大小也为 1G。容器内的进程能申请到的总内存大小为 2G。

3.设置-m,--memory=a--memory-swap=b,且b > a

给-m设置一个参数 a,给--memory-swap设置一个参数 b。a 时容器能使用的内存大小,b是容器能使用的 内存大小 + swap 分区大小。所以 b 必须大于 a。b -a 即为容器能使用的 swap 分区大小。

比如$ docker run -m 1G --memory-swap 3G ubuntu:16.04,该容器能使用的内存大小为 1G,能使用的 swap 分区大小为 2G。容器内的进程能申请到的总内存大小为 3G。

4.设置-m,--memory=a--memory-swap=-1

给-m参数设置一个正常值,而给--memory-swap设置成 -1。这种情况表示限制容器能使用的内存大小为 a,而不限制容器能使用的 swap 分区大小。

这时候,容器内进程能申请到的内存大小为 a + 宿主机的 swap 大小。

3.memory-swappiness参数

这种 memory reservation 机制不知道怎么翻译比较形象。Memory reservation 是一种软性限制,用于节制容器内存使用。给--memory-reservation设置一个比-m小的值后,虽然容器最多可以使用-m使用的内存大小,但在宿主机内存资源紧张时,在系统的下次内存回收时,系统会回收容器的部分内存页,强迫容器的内存占用回到--memory-reservation设置的值大小。

没有设置时(默认情况下)--memory-reservation的值和-m的限定的值相同。将它设置为 0 会设置的比-m的参数大 等同于没有设置。

Memory reservation 是一种软性机制,它不保证任何时刻容器使用的内存不会超过--memory-reservation限定的值,它只是确保容器不会长时间占用超过--memory-reservation限制的内存大小。

可以用以下方法测试此参数

1.运行一个容器,将内存做以下限制
docker run --memory-reservation 100 -m 200M --rm -it -p 80:80 new

2.在虚拟内部进行压力测试
stress --vm 1 --vm-bytes 300M

3.查看容器资源占用,这个时候可以看到此容器最多申请到了200M内存,虽然我们指定的是300M
docker stats

4.在当前宿主机上进行压力测试(宿主机内存为1G)
stress --vm 1 --vm-bytes 500M

5.再次查看容器资源占用,由于宿主机内存资源紧张,容器的内存占用自动缩减到100M
docker stats

4.OOM killer

默认情况下,在出现 out-of-memory(OOM) 错误时,系统会杀死容器内的进程来获取更多空闲内存。这个杀死进程来节省内存的进程,我们姑且叫它 OOM killer。我们可以通过设置--oom-kill-disable选项来禁止 OOM killer 杀死容器内进程。但请确保只有在使用了-m/--memory选项时才使用--oom-kill-disable禁用 OOM killer。如果没有设置-m选项,却禁用了 OOM-killer,可能会造成出现 out-of-memory 错误时,系统通过杀死宿主机进程或获取更改内存。

下面的例子限制了容器的内存为 100M 并禁止了 OOM killer:

docker run -it -m 100M --oom-kill-disable ubuntu:16.04 /bin/bash

而下面这个容器没设置内存限制,却禁用了 OOM killer 是非常危险的:

docker run -it --oom-kill-disable ubuntu:16.04 /bin/bash

容器没用内存限制,可能或导致系统无内存可用,并尝试时杀死系统进程来获取更多可用内存。

一般一个容器只有一个进程,这个唯一进程被杀死,容器也就被杀死了。我们可以通过--oom-score-adj选项来设置在系统内存不够时,容器被杀死的优先级。负值更教不可能被杀死,而正值更有可能被杀死。

5.核心内存

核心内存和用户内存不同的地方在于核心内存不能被交换出。不能交换出去的特性使得容器可以通过消耗太多内存来堵塞一些系统服务。核心内存包括:

  • stack pages(栈页面)
  • slab pages
  • socket memory pressure
  • tcp memory pressure

可以通过设置核心内存限制来约束这些内存。例如,每个进程都要消耗一些栈页面,通过限制核心内存,可以在核心内存使用过多时阻止新进程被创建。

核心内存和用户内存并不是独立的,必须在用户内存限制的上下文中限制核心内存。

假设用户内存的限制值为 U,核心内存的限制值为 K。有三种可能地限制核心内存的方式:

  • U != 0,不限制核心内存。这是默认的标准设置方式

  • K < U,核心内存时用户内存的子集。这种设置在部署时,每个 cgroup 的内存总量被过度使用。过度使用核心内存限制是绝不推荐的,因为系统还是会用完不能回收的内存。在这种情况下,你可以设置 K,这样 groups 的总数就不会超过总内存了。然后,根据系统服务的质量自有地设置 U。

  • K > U,因为核心内存的变化也会导致用户计数器的变化,容器核心内存和用户内存都会触发回收行为。这种配置可以让管理员以一种统一的视图看待内存。对想跟踪核心内存使用情况的用户也是有用的。
    例如:

    docker run -it -m 500M --kernel-memory 50M ubuntu:16.04 /bin/bash

容器中的进程最多能使用 500M 内存,在这 500M 中,最多只有 50M 核心内存。

docker run -it --kernel-memory 50M ubuntu:16.04 /bin/bash

没用设置用户内存限制,所以容器中的进程可以使用尽可能多的内存,但是最多能使用 50M 核心内存。

6.Swappiness

默认情况下,容器的内核可以交换出一定比例的匿名页。--memory-swappiness就是用来设置这个比例的。--memory-swappiness可以设置为从 0 到 100。0 表示关闭匿名页面交换。100 表示所有的匿名页都可以交换。默认情况下,如果不适用--memory-swappiness,则该值从父进程继承而来。

例如:

docker run -it --memory-swappiness=0 ubuntu:16.04 /bin/bash

将--memory-swappiness设置为 0 可以保持容器的工作集,避免交换代理的性能损失。

docker run -tid —name mem1 —memory 128m ubuntu:16.04 /bin/bash
cat /sys/fs/cgroup/memory/docker/<容器的完整ID>/memory.limit_in_bytes
cat /sys/fs/cgroup/memory/docker/<容器的完整ID>/memory.memsw.limit_in_bytes

二.CPU 限制

1.概述

默认设置下,所有容器可以平等地使用 host CPU 资源并且没有限制。

Docker 的资源限制和隔离完全基于 Linux cgroups。对 CPU 资源的限制方式也和 cgroups 相同。Docker 提供的 CPU 资源限制选项可以在多核系统上限制容器能利用哪些 vCPU。而对容器最多能使用的 CPU 时间有两种限制方式:一是有多个 CPU 密集型的容器竞争 CPU 时,设置各个容器能使用的 CPU 时间相对比例。二是以绝对的方式设置容器在每个调度周期内最多能使用的 CPU 时间。

Docker 可以通过 -c 或 --cpu-shares 设置容器使用 CPU 的权重。如果不指定,默认值为 1024。

与内存限额不同,通过 -c 设置的 cpu share 并不是 CPU 资源的绝对数量,而是一个相对的权重值。某个容器最终能分配到的 CPU 资源取决于它的 cpu share 占所有容器 cpu share 总和的比例。

换句话说:通过 cpu share 可以设置容器使用 CPU 的优先级。

2.CPU 限制相关参数

docker run命令和 CPU 限制相关的所有选项如下:

--cpuset-cpus=""          允许使用的 CPU 集,值可以为 0-3,0,1
-c,--cpu-shares=0   CPU     共享权值(相对权重)
cpu-period=0              限制 CPU CFS 的周期,范围从 100ms~1s,即[1000, 1000000]
--cpu-quota=0             限制 CPU CFS 配额,必须不小于1ms,即 >= 1000
--cpuset-mems=""          允许在上执行的内存节点(MEMs),只对 NUMA 系统有效

其中--cpuset-cpus用于设置容器可以使用的 vCPU 核。-c,--cpu-shares用于设置多个容器竞争 CPU 时,各个容器相对能分配到的 CPU 时间比例。--cpu-period和--cpu-quata用于绝对设置容器能使用 CPU 时间。

--cpuset-mems暂用不上,这里不谈。

3.CPU 集

我们可以设置容器可以在哪些 CPU 核上运行。例如:

# 表示容器中的进程可以在 cpu 1 和 cpu 3 上执行。
docker run -it --cpuset-cpus="1,3" ubuntu:14.04 /bin/bash

# 表示容器中的进程可以在 cpu 0、cpu 1 及 cpu 3 上执行。
docker run -it --cpuset-cpus="0-2" ubuntu:14.04 /bin/bash
cat /sys/fs/cgroup/cpuset/docker/<容器的完整长ID>/cpuset.cpus

在 NUMA 系统上,我们可以设置容器可以使用的内存节点。例如:

## 表示容器中的进程只能使用内存节点 1 和 3 上的内存。
docker run -it --cpuset-mems="1,3" ubuntu:14.04 /bin/bash

## 表示容器中的进程只能使用内存节点 0、1、2 上的内存。
docker run -it --cpuset-mems="0-2" ubuntu:14.04 /bin/bash

4.CPU 资源的相对限制

默认情况下,所有的容器得到同等比例的 CPU 周期。在有多个容器竞争 CPU 时我们可以设置每个容器能使用的 CPU 时间比例。这个比例叫作共享权值,通过-c或--cpu-shares设置。Docker 默认每个容器的权值为 1024。不设置或将其设置为 0,都将使用这个默认值。系统会根据每个容器的共享权值和所有容器共享权值和比例来给容器分配 CPU 时间。

假设有三个正在运行的容器,这三个容器中的任务都是 CPU 密集型的。第一个容器的 cpu 共享权值是 1024,其它两个容器的 cpu 共享权值是 512。第一个容器将得到 50% 的 CPU 时间,而其它两个容器就只能各得到 25% 的 CPU 时间了。如果再添加第四个 cpu 共享值为 1024 的容器,每个容器得到的 CPU 时间将重新计算。第一个容器的CPU 时间变为 33%,其它容器分得的 CPU 时间分别为 16.5%、16.5%、33%。

必须注意的是,这个比例只有在 CPU 密集型的任务执行时才有用。在四核的系统上,假设有四个单进程的容器,它们都能各自使用一个核的 100% CPU 时间,不管它们的 cpu 共享权值是多少。

在多核系统上,CPU 时间权值是在所有 CPU 核上计算的。即使某个容器的 CPU 时间限制少于 100%,它也能使用各个 CPU 核的 100% 时间。

例如,假设有一个不止三核的系统。用-c=512的选项启动容器{C0},并且该容器只有一个进程,用-c=1024的启动选项为启动容器C2,并且该容器有两个进程。CPU 权值的分布可能是这样的:

## 表示容器中的进程CPU份额值为100。
PID    container    CPU CPU share
100    {C0}     0   100% of CPU0
101    {C1}     1   100% of CPU1
102    {C1}     2   100% of CPU2

5.CPU 资源的绝对限制

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

我们可以设置每个容器进程的调度周期,以及在这个周期内各个容器最多能使用多少 CPU 时间。使用--cpu-period即可设置调度周期,使用--cpu-quota即可设置在每个周期内容器能使用的 CPU 时间。两者一般配合使用。例如:

## 将 CFS 调度的周期设为 50000,将容器在每个周期内的 CPU 配额设置为 25000
## 表示该容器每 50ms 可以得到 50% 的 CPU 运行时间。
docker run -it --cpu-period=50000 --cpu-quota=25000 ubuntu:16.04 /bin/bash

## 将容器的 CPU 配额设置为 CFS 周期的两倍,CPU 使用时间怎么会比周期大呢?
## 其实很好解释,给容器分配两个 vCPU 就可以了。
## 该配置表示容器可以在每个周期内使用两个 vCPU 的 100% 时间。
docker run -it --cpu-period=10000 --cpu-quota=20000 ubuntu:16.04 /bin/bash
cat /sys/fs/cgroup/cpu/docker/<容器的完整长ID>/cpu.cfs_period_us
cat /sys/fs/cgroup/cpu/docker/<容器的完整长ID>/cpu.cfs_quota_us

CFS 周期的有效范围是 1ms~1s,对应的--cpu-period的数值范围是 1000~1000000。而容器的 CPU 配额必须不小于 1ms,即--cpu-quota的值必须 >= 1000。可以看出这两个选项的单位都是 us。

6.正确的理解“绝对”

注意前面我们用--cpu-quota设置容器在一个调度周期内能使用的 CPU 时间时实际上设置的是一个上限。并不是说容器一定会使用这么长的 CPU 时间。比如,我们先启动一个容器,将其绑定到 cpu 1 上执行。给其--cpu-quota和--cpu-period都设置为 50000。

docker run --rm --name test01 --cpu-cpus 1 --cpu-quota=50000 --cpu-period=50000 deadloop:busybox-1.25.1-glibc

调度周期为 50000,容器在每个周期内最多能使用 50000 cpu 时间。

再用docker stats test01可以观察到该容器对 CPU 的使用率在100%左右。然后,我们再以同样的参数启动另一个容器。

docker run --rm --name test02 --cpu-cpus 1 --cpu-quota=50000 --cpu-period=50000 deadloop:busybox-1.25.1-glibc

再用docker stats test01 test02可以观察到这两个容器,每个容器对 cpu 的使用率在 50% 左右。说明容器并没有在每个周期内使用 50000 的 cpu 时间。

使用docker stop test02命令结束第二个容器,再加一个参数-c 2048启动它:

docker run --rm --name test02 --cpu-cpus 1 --cpu-quota=50000 --cpu-period=50000 -c 2048 deadloop:busybox-1.25.1-glibc

再用docker stats test01命令可以观察到第一个容器的 CPU 使用率在 33% 左右,第二个容器的 CPU 使用率在 66% 左右。因为第二个容器的共享值是 2048,第一个容器的默认共享值是 1024,所以第二个容器在每个周期内能使用的 CPU 时间是第一个容器的两倍。

三.磁盘IO配额控制

相对于CPU和内存的配额控制,docker对磁盘IO的控制相对不成熟,大多数都必须在有宿主机设备的情况下使用。主要包括以下参数:

–device-read-bps        限制此设备上的读速度(bytes per second),单位可以是kb、mb或者gb。
–device-read-iops       通过每秒读IO次数来限制指定设备的读速度。
–device-write-bps       限制此设备上的写速度(bytes per second),单位可以是kb、mb或者gb。
–device-write-iops      通过每秒写IO次数来限制指定设备的写速度。
–blkio-weight           容器默认磁盘IO的加权值,有效值范围为10-100。
–blkio-weight-device    针对特定设备的IO加权控制。其格式为DEVICE_NAME:WEIGHT

存储配额控制的相关参数,可以参考Red Hat文档中blkio这一章,了解它们的详细作用。

https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/6/html/resource_management_guide/ch-subsystems_and_tunable_parameters#sec-blkio

磁盘IO配额控制示例

device-write-bps

使用下面的命令创建容器,并执行命令验证写速度的限制。

docker run -tid –name disk1 –device-write-bps /dev/sda:1mb ubuntu:stress

通过dd来验证写速度,可以看到容器的写磁盘速度被成功地限制到了1MB/s。

四.容器空间大小限制

在docker使用devicemapper作为存储驱动时,默认每个容器和镜像的最大大小为10G。如果需要调整,可以在daemon启动参数中,使用dm.basesize来指定,但需要注意的是,修改这个值,不仅仅需要重启docker daemon服务,还会导致宿主机上的所有本地镜像和容器都被清理掉。

使用aufs或者overlay等其他存储驱动时,没有这个限制。

附录:

参考:https://www.cnblogs.com/zhuochong/p/9728383.html

参考:https://blog.csdn.net/candcplusplus/article/details/53728507

推荐阅读更多精彩内容