Docker内存使用

    云计算 前言

默认情况下容器使用的资源是不受限制的。也就是可以使用主机内核调度器所允许的最大资源。但是在容器的使用过程中，经常需要对容器可以使用的主机资源进行限制，本文介绍如何限制容器可以使用的主机内存。

限制容器不能过多的使用主机的内存是非常重要的。对于 linux 主机来说，一旦内核检测到没有足够的内存可以分配，就会扔出 OOME(Out Of Memmory Exception)，并开始杀死一些进程用于释放内存空间。

糟糕的是任何进程都可能成为内核猎杀的对象，包括 docker daemon 和其它一些重要的程序。更危险的是如果某个支持系统运行的重要进程被干掉了，整个系统也就宕掉了！

这里我们考虑一个比较常见的场景，大量的容器把主机的内存消耗殆尽，OOME 被触发后系统内核立即开始杀进程释放内存。如果内核杀死的第一个进程就是 docker daemon 会怎么样？结果是所有的容器都不工作了，这是不能接受的！

针对这个问题，docker 尝试通过调整 docker daemon 的 OOM 优先级来进行缓解。内核在选择要杀死的进程时会对所有的进程打分，直接杀死得分最高的进程，接着是下一个。

当 docker daemon 的 OOM 优先级被降低后(注意容器进程的 OOM 优先级并没有被调整)，docker daemon 进程的得分不仅会低于容器进程的得分，还会低于其它一些进程的得分。这样 docker daemon 进程就安全多了。

我们可以通过下面的脚本直观的看一下当前系统中所有进程的得分情况：

#!/bin/bash
for proc in $(find /proc -maxdepth 1 -regex \'/proc/[0-9]+\'); do
    printf %2d %5d %s\\n \\
        $(cat $proc/oom_score) \\
        $(basename $proc) \\
        $(cat $proc/cmdline | tr \'\\0\' \' \' | head -c 50)
done 2>/dev/null | sort -nr | head -n 40

此脚本输出得分最高的 40 个进程，并进行了排序：

第一列显示进程的得分，mysqld 排到的第一名。显示为 node server.js 的都是容器进程，排名普遍比较靠前。红框中的是 docker daemon 进程，非常的靠后，都排到了 sshd 的后面。

有了上面的机制后是否就可以高枕无忧了呢！不是的，docker 的官方文档中一直强调这只是一种缓解的方案，并且为我们提供了一些降低风险的建议：

通过测试掌握应用对内存的需求

保证运行容器的主机有充足的内存

限制容器可以使用的内存

好了，啰嗦了这么多，其实就是说：通过限制容器使用的内存上限，可以降低主机内存耗尽时带来的各种风险。

为了测试容器的内存使用情况，笔者在 ubuntu 的镜像中安装了压力测试工作 stress，并新创建了镜像 u-stress。本文演示用的所有容器都会通过 u-stress 镜像创建(本文运行容器的宿主机为 CentOS7)。

下面是创建 u-stress 镜像的 Dockerfile：

FROM ubuntu:latest

RUN apt-get update && \\
        apt-get install stress

创建镜像的命令为：

$ docker build -t u-stress:latest .

-m, --memory=Memory limit (format: <number>[<unit>]). Number is a positive integer. Unit can be one of b, k, m, or g. Minimum is 4M.

--memory=Memory limit (format: <number>[<unit>]). Number is a positive integer. Unit can be one of b, k, m, or g. Minimum is 4M.

--memory-swappiness=Tune a container’s memory swappiness behavior. Accepts an integer between 0 and 100.(调整容器的内存swappiness行为。接受0到100之间的整数)

--memory-reservation=Memory soft limit (format: <number>[<unit>]). Number is a positive integer. Unit can be one of b, k, m, or g.

--oom-kill-disable=falseWhether to disable OOM Killer for the container or not.

-m(--memory=) 选项可以完成这样的配置：

$ docker run -it -m 300M --memory-swap -1 --name con1 u-stress /bin/bash

下面的 stress 命令会创建一个进程并通过 malloc 函数分配内存：

# stress --vm 1 --vm-bytes 500M

通过 docker stats 命令查看实际情况：

上面的 docker run 命令中通过 -m 选项限制容器使用的内存上限为 300M。同时设置 memory-swap 值为 -1，它表示容器程序使用内存的受限，而可以使用的 swap 空间使用不受限制(宿主机有多少 swap 容器就可以使用多少)。如果 --memory-swap 设置小于 --memory则设置不生效，使用默认设置）。

下面我们通过 top 命令来查看 stress 进程内存的实际情况：

上面的截图中先通过 pgrep 命令查询 stress 命令相关的进程，进程号比较大的那个是用来消耗内存的进程，我们就查看它的内存信息。VIRT 是进程虚拟内存的大小，所以它应该是 500M。RES 为实际分配的物理内存数量，我们看到这个值就在 300M 上下浮动。看样子我们已经成功的限制了容器能够使用的物理内存数量。

也可以通过如下命令获取 stress 进程的 swap 占用：

for file in /proc/*/status ; do awk \'/VmSwap|Name/{printf $2 $3}END{ print }\' $file; done | sort -k 2 -n -r | grep stress

强调一下 --memory-swap 是必须要与 --memory 一起使用的。但是凡事没有绝对，如果你非要不添加--memory-swap 选项呢？

如：docker run -it --rm -m 100M ubuntu-stress:latest /bin/bash

按照官方文档的理解，如果指定 -m 内存限制时不添加 --memory-swap 选项或 --memory-swap 设置为 0 ，则表示容器中程序可以使用 100M 内存和 100M swap 内存。默认情况下，--memory-swap 会被设置成 memory 的 2倍。

We set memory limit(300M) only, this means the processes in the container can use 300M memory and 300M swap memory, by default, the total virtual memory size --memory-swapwill be set as double of memory, in this case, memory + swap would be 2*300M, so processes can use 300M swap memory as well.

如果按照以上方式运行容器提示如下信息：

WARNING: Your kernel does not support swap limit capabilities, memory limited without swap.

可参考 Adjust memory and swap accounting 获取解决方案:

To enable memory and swap on system using GNU GRUB (GNU GRand Unified Bootloader), do the following:

（1）Log into Ubuntu as a user with sudo privileges.

（2）Edit the /etc/default/grub file.

（3）Set the GRUB_CMDLINE_LINUX value as follows: GRUB_CMDLINE_LINUX=cgroup_enable=memory swapaccount=1

（4）Save and close the file.

（5）Update GRUB. $ sudo update-grub

（6）Reboot your system.

正常情况下， --memory-swap 的值包含容器可用内存和可用 swap。所以 --memory="300m" --memory-swap="1g" 的含义为：

容器可以使用 300M 的物理内存，并且可以使用 700M(1G -300M) 的 swap。--memory-swap 居然是容器可以使用的物理内存和可以使用的 swap 之和！

如果 --memory-swap 的值和 --memory 相同，则容器不能使用 swap。

下面的 demo 演示了在没有 swap 可用的情况下向系统申请大量内存的场景：

$ docker run -it --rm -m 300M --memory-swap=300M u-stress /bin/bash
# stress --vm 1 --vm-bytes 500M

demo 中容器的物理内存被限制在 300M，但是进程却希望申请到 500M 的物理内存。在没有 swap 可用的情况下，进程直接被 OOM kill 了。如果有足够的 swap，程序至少还可以正常的运行。

我们可以通过 --oom-kill-disable 选项强行阻止 OOM kill 的发生，但是笔者认为 OOM kill 是一种健康的行为，为什么要阻止它呢？

swappiness 可以认为是宿主/proc/sys/vm/swappiness设定：

Swappiness is a Linux kernel parameter that controls the relative weight given to swapping out runtime memory, as opposed to dropping pages from the system page cache. Swappiness can be set to values between 0 and 100 inclusive. A low value causes the kernel to avoid swapping, a higher value causes the kernel to try to use swap space.Swappiness

--memory-swappiness=0 表示禁用容器 swap 功能(这点不同于宿主机，宿主机 swappiness 设置为 0 也不保证 swap 不会被使用):

docker run -it --rm -m 100M --memory-swappiness=0 ubuntu-stress:latest /bin/bash

➜  ~ docker run -it --rm -m 100M --memory-swappiness=0 ubuntu-stress:latest /bin/bash
root@e3fd6cc73849:/# stress --vm 1 --vm-bytes 100M  # 没有任何商量的余地，到达 100M 直接被 kill
stress: info: [18] dispatching hogs: 0 cpu, 0 io, 1 vm, 0 hdd
stress: FAIL: [18] (416) <-- worker 19 got signal 9
stress: WARN: [18] (418) now reaping child worker processes
stress: FAIL: [18] (452) failed run completed in 0s
root@e3fd6cc73849:/#

--memory-reservation ...选项可以理解为内存的软限制。如果不设置 -m 选项，那么容器使用内存可以理解为是不受限的。按照官方的说法，memory reservation 设置可以确保容器不会长时间占用大量内存。

➜  ~ docker run -it --rm -m 100M --memory-swappiness=0 --oom-kill-disable ubuntu-stress:latest /bin/bash
root@f54f93440a04:/# stress --vm 1 --vm-bytes 200M  # 正常情况不添加 --oom-kill-disable 则会直接 OOM kill，加上之后则达到限制内存之后也不会被 kill
stress: info: [17] dispatching hogs: 0 cpu, 0 io, 1 vm, 0 hdd

但是如果是以下的这种没有对容器作任何资源限制的情况，添加 --oom-kill-disable 选项就比较 危险 了：

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

因为此时容器内存没有限制，并且不会被 oom kill，此时系统则会 kill 系统进程用于释放内存。

Kernel memory is fundamentally different than user memory as kernel memory can’t be swapped out. The inability to swap makes it possible for the container to block system services by consuming too much kernel memory. Kernel memory includes:

stack pages

slab pages

sockets memory pressure

这里直接引用 Docker 官方介绍，如果无特殊需求，kernel-memory 一般无需设置，这里不作过多说明。

Docker内存资源限制

进程不见了，Linux 的OOM Killer

十问 Linux 虚拟内存管理