共计 7023 个字符，预计需要花费 18 分钟才能阅读完成。
Linux 过程引入
如果你要写一个计算加法的小程序，这个程序须要输出来自于一个文件，计算实现后的后果则输出到另一个文件中。
因为计算机只意识 0 和 1，所以无论用那种语言编写这段代码，最初都须要通过某种形式翻译成二进制文件，能力在计算机操作系统中运行起来。
而为了可能让这些代码失常运行，咱们往往还要给它提供数据，比方咱们这个加法程序所须要的输出文件。这些数据加上代码自身的二进制文件，放在磁盘，就是咱们平时所说的一个 程序，也叫代码的可执行镜像（executable image）。
而后，咱们就能够在计算机上运行这个 程序 了。
首先，操作系统从 程序 中发现输出保留在一个文件中，所以这些数据就被会加载到内存中待命。同时，操作系统又读取到了计算加法的指令，这时，它就须要批示 CPU 实现加法操作。而 CPU 与内存合作进行加法计算，又会应用寄存器寄存数值、内存堆栈保留执行的命令和变量。同时，计算机里还有被关上的文件，以及各种各样的 I / O 设施在一直地调用中批改本人的状态。
就这样，一旦 程序 被执行起来，它就从磁盘上的二进制文件，变成了计算机内存中的数据、寄存器里的值，堆栈中的指令、被关上的文件，以及各种设施状态信息的一个汇合。像这样一个程序运行起来后的计算机执行环境的总和，就是咱们的配角：过程。
所以，对于过程来说，它的动态体现就是程序，平时都安安静静地待在磁盘上；而一旦运行起来，它就成为了计算机里的数据和状态的总和，这就是它的动静体现，
Linux 容器的隔离
Docker 容器实质上就是 Linux 操作系统的过程，只是 Docker 通过 namespace 实现了过程间的资源隔离技术，这样说起来很多人会感觉到很形象，那接下来咱们通过实战进行理解一下吧！
首先咱们先创立一个容器：
# docker run -it busybox /bin/sh
/ # 在容器里执行一下 PS 指令：
/ # ps
PID USER TIME COMMAND
1 root 0:00 /bin/sh
6 root 0:00 ps能够看到，咱们在 Docker 里最开始执行的 /bin/sh，就是这个容器外部的第 1 号过程（PID=1），而这个容器里一共只有两个过程在运行。这就意味着，后面执行的 /bin/sh，以及咱们刚刚执行的 ps，曾经被 Docker 隔离在一个跟宿主机不同的世界当中。
这到底事怎么做到的呢？
原本，每当咱们在宿主机上运行了一个 /bin/sh 程序，操作系统都会给它调配一个过程编号，比方 PID=100。这个编号是过程的惟一标识，就像员工的工牌一样。所以 PID=100，能够粗略地了解为这个 /bin/sh 是咱们公司里的第 100 号员工，而第 1 号员工就天然是比尔 · 盖茨这样统领全局的人物。而当初，咱们要通过 Docker 把这个 /bin/sh 程序运行在一个容器当中。这时候，Docker 就会在这个第 100 号员工入职时给他施一个“障眼法”，让他永远看不到后面的其余 99 个员工，更看不到比尔 · 盖茨。这样，他就会谬误地认为本人就是公司里的第 1 号员工。这种机制，其实就是对被隔离利用的过程空间做了手脚，使得这些过程只能看到从新计算过的过程编号，比方 PID=1。可实际上，他们在宿主机的操作系统里，还是原来的第 100 号过程。
这种技术，就是 Linux 外面的 Namespace 机制。而 Namespace 的应用形式也十分有意思：它其实只是 Linux 创立新过程的一个可选参数。咱们晓得，在 Linux 零碎中创立线程的零碎调用是 clone()，比方：
int pid = clone(main_function, stack_size, SIGCHLD, NULL); 这个零碎调用就会为咱们创立一个新的过程，并且返回它的过程号 pid。
而当咱们用 clone() 零碎调用创立一个新过程时，就能够在参数中指定 CLONE_NEWPID 参数，比方：
int pid = clone(main_function, stack_size, CLONE_NEWPID | SIGCHLD, NULL); 这时，新创建的这个过程将会“看到”一个全新的过程空间，在这个过程空间里，它的 PID 是 1。之所以说“看到”，是因为这只是一个“障眼法”，在宿主机实在的过程空间里，这个过程的 PID 还是实在的数值，比方 100。
当然，咱们还能够屡次执行下面的 clone() 调用，这样就会创立多个 PID Namespace，而每个 Namespace 里的利用过程，都会认为本人是以后容器里的第 1 号过程，它们既看不到宿主机里真正的过程空间，也看不到其余 PID Namespace 里的具体情况。
而除了咱们刚刚用到的 PID Namespace，Linux 操作系统还提供了 Mount、UTS、IPC、Network 和 User 这些 Namespace，用来对各种不同的过程上下文进行“障眼法”操作。比方，Mount Namespace，用于让被隔离过程只看到以后 Namespace 里的挂载点信息；Network Namespace，用于让被隔离过程看到以后 Namespace 里的网络设备和配置。
这，就是 Linux 容器最根本的实现原理了。
所以，Docker 容器这个听起来玄而又玄的概念，实际上是在创立容器过程时，指定了这个过程所须要启用的一组 Namespace 参数。这样，容器就只能“看”到以后 Namespace 所限定的资源、文件、设施、状态，或者配置。而对于宿主机以及其余不相干的程序，它就齐全看不到了。
所以说，容器，其实是一种非凡的过程而已。
Linux 容器的限度
为什么须要对容器做 限度 呢？
尽管容器内的第一号过程在 障眼法 的烦扰下只能看到容器里的状况，然而宿主机上，它作为第 100 号过程与其余所有过程之间仍然事平台的竞争关系，这就意味着，尽管第 100 号过程外表上被隔离起来，然而它所可能应用到的资源（比方 CPU，内存），却是能够随时被宿主机上的其余过程（或者其余机器）占用的。当然这个 100 号过程本人也可能把所有资源吃光。这些状况，显然都不是一个沙盒应该标识进去的正当行为。
Linux Cgroups 是什么？
cgroups 是 Linux 下管制一个（或一组）过程的资源限度机制，全称是 control groups，能够对 cpu、内存等资源做精细化管制，比方目前很多的 Docker 在 Linux 下就是基于 cgroups 提供的资源限度机制来实现资源管制的；除此之外，开发者也能够指间接基于 cgroups 来进行过程资源管制，比方 8 核的机器上部署了一个 web 服务和一个计算服务，能够让 web 服务仅可应用其中 6 个核，把剩下的两个核留给计算服务。cgroups cpu 限度除了能够限度应用多少 / 哪几个外围之外，还能够设置 cpu 占用比（留神占用比是各自都跑满状况下的应用比例，如果一个 cgroup 闲暇而另一个忙碌，那么忙碌的 cgroup 是有可能占满整个 cpu 外围的）。
在 Linux 中，Cgroups 给用户暴漏出的操作接口是文件系统，即它以文件和目录的形式组织在操作系统的/sys/fs/cgroup 门路下。在 Centos 机器里，咱们能够用 mount 命令将他们展现：
/ # mount -t cgroup
cgroup on /sys/fs/cgroup/systemd type cgroup (ro,seclabel,nosuid,nodev,noexec,relatime,xattr,release_agent=/usr/lib/systemd/systemd-cgroups-agent,name=systemd)
cgroup on /sys/fs/cgroup/hugetlb type cgroup (ro,seclabel,nosuid,nodev,noexec,relatime,hugetlb)
cgroup on /sys/fs/cgroup/cpu,cpuacct type cgroup (ro,seclabel,nosuid,nodev,noexec,relatime,cpuacct,cpu)
cgroup on /sys/fs/cgroup/freezer type cgroup (ro,seclabel,nosuid,nodev,noexec,relatime,freezer)
cgroup on /sys/fs/cgroup/net_cls,net_prio type cgroup (ro,seclabel,nosuid,nodev,noexec,relatime,net_prio,net_cls)
cgroup on /sys/fs/cgroup/blkio type cgroup (ro,seclabel,nosuid,nodev,noexec,relatime,blkio)
cgroup on /sys/fs/cgroup/cpuset type cgroup (ro,seclabel,nosuid,nodev,noexec,relatime,cpuset)
cgroup on /sys/fs/cgroup/perf_event type cgroup (ro,seclabel,nosuid,nodev,noexec,relatime,perf_event)
cgroup on /sys/fs/cgroup/memory type cgroup (ro,seclabel,nosuid,nodev,noexec,relatime,memory)
cgroup on /sys/fs/cgroup/devices type cgroup (ro,seclabel,nosuid,nodev,noexec,relatime,devices)
cgroup on /sys/fs/cgroup/pids type cgroup (ro,seclabel,nosuid,nodev,noexec,relatime,pids)目前看到，在 /sys/fs/cgroup 上面有很多诸如 cpuset、cpu、memory 这样的子目录，也叫子系统。这些都是我这台机器以后能够被 Cgroups 进行限度的资源品种。而在子系统对应的资源类下，你就能够看到该类资源具体能够被限度的办法。
比方，对 CPU 子系统来说，咱们就能够看到如下几个配置文件：
/ # ls -l /sys/fs/cgroup/cpu/
total 0
-rw-r--r-- 1 root root 0 Aug 12 10:55 cgroup.clone_children
--w--w--w- 1 root root 0 Aug 12 10:55 cgroup.event_control
-rw-r--r-- 1 root root 0 Aug 12 10:55 cgroup.procs
-rw-r--r-- 1 root root 0 Aug 12 10:55 cpu.cfs_period_us
-rw-r--r-- 1 root root 0 Aug 12 10:55 cpu.cfs_quota_us
-rw-r--r-- 1 root root 0 Aug 12 10:55 cpu.rt_period_us
-rw-r--r-- 1 root root 0 Aug 12 10:55 cpu.rt_runtime_us
-rw-r--r-- 1 root root 0 Aug 12 10:55 cpu.shares
-r--r--r-- 1 root root 0 Aug 12 10:55 cpu.stat
-r--r--r-- 1 root root 0 Aug 12 10:55 cpuacct.stat
-rw-r--r-- 1 root root 0 Aug 12 10:55 cpuacct.usage
-r--r--r-- 1 root root 0 Aug 12 10:55 cpuacct.usage_percpu
-rw-r--r-- 1 root root 0 Aug 12 10:55 notify_on_release
-rw-r--r-- 1 root root 0 Aug 12 10:55 tasks对 Linux CPU 治理相熟的同学，应该会留神到 cfs_period 和 cfs_quota 这样的关键词。这两个参数须要组合应用，能够用来限度过程在长度 cfs_period 的一段时间内，只能被调配到总量为 cfs_quota 的 CPU 工夫。
接下来咱们来应用下此配置?
首先咱们须要在对应的子系统上面创立一个目录：
# cd /sys/fs/cgroup/cpu
# mkdir container
# cd container/
# ll
total 0
-rw-r--r--. 1 root root 0 Aug 12 19:38 cgroup.clone_children
--w--w--w-. 1 root root 0 Aug 12 19:38 cgroup.event_control
-rw-r--r--. 1 root root 0 Aug 12 19:38 cgroup.procs
-r--r--r--. 1 root root 0 Aug 12 19:38 cpuacct.stat
-rw-r--r--. 1 root root 0 Aug 12 19:38 cpuacct.usage
-r--r--r--. 1 root root 0 Aug 12 19:38 cpuacct.usage_percpu
-rw-r--r--. 1 root root 0 Aug 12 19:38 cpu.cfs_period_us
-rw-r--r--. 1 root root 0 Aug 12 19:38 cpu.cfs_quota_us
-rw-r--r--. 1 root root 0 Aug 12 19:38 cpu.rt_period_us
-rw-r--r--. 1 root root 0 Aug 12 19:38 cpu.rt_runtime_us
-rw-r--r--. 1 root root 0 Aug 12 19:38 cpu.shares
-r--r--r--. 1 root root 0 Aug 12 19:38 cpu.stat
-rw-r--r--. 1 root root 0 Aug 12 19:38 notify_on_release
-rw-r--r--. 1 root root 0 Aug 12 19:38 tasks这个目录被称为一个控制组。你会发现，操作系统会在你新创建的 container 目录下，主动生成子系统对应的资源限度文件。
此刻，咱们执行一个死循环脚本，把计算的 CPU 吃到 100%
# while : ; do : ; done # top
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
7996 root 20 0 1320 256 212 R 100 0.0 1:12.75 sh 通过 top 命令能够看到，CPU 的使用率曾经 100%
此时，咱们能够通过查看 container 目录下的文件，能够看到 container 控制组的 CPU quota 还没有任何限度（：-1）
# cat /sys/fs/cgroup/cpu/container/cpu.cfs_quota_us
-1接下来咱们通过批改这些文件来设置限度：
向 container 组里的 cfs_quota 文件写入 20ms（20000 us）
echo 20000 > /sys/fs/cgroup/cpu/container/cpu.cfs_quota_us 100ms 的工夫里，被该控制组限度的进行只能应用 20MS 的 CPU 工夫，也就是说这个过程只能应用到 20% 的 CPU 带宽
接下来，咱们把被限度的过程的 PID 写入 container 组里的 tasks 文件，下面的设置就会对该过程失效了
# echo 7996 > /sys/fs/cgroup/cpu/container/tasks 而后通过 top 查看下：
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
7996 root 20 0 119484 6140 1652 R 20.3 0.2 3:45.10 sh 能够看到，计算机的 CPU 使用率立即降到了 20%
<u> 是不是很神奇？</u>
除了 CPU 子系统外，Cgroups 的每一项子系统都有独有的资源限度能力：比方
- blkio，为块设施设定 I / O 限度，个别用于磁盘等设施
- cpuset，为过程调配独自的 CPU 核和对应的内存节点
- memory，为过程设定内存应用的限度
Linux Cgroups 的设计还是比拟易用的，简略粗犷地了解呢，它就是一个子系统目录加上一组资源限度文件的组合。而对于 Docker 等 Linux 容器我的项目来说，它们只须要在每个子系统上面，为每个容器创立一个控制组（即创立一个目录），而后在启动容器过程之后，把这个过程 PID 填写到对应控制组的 tasks 文件中就能够了。
而至于在这些控制组上面的资源文件里填上什么值，就靠用户执行 docker run 时的参数指定就能够了, 比方如下命令：
# docker run -it --cpu-period=10000 --cpu-quota=20000 ubuntu /bin/bash在启动这个容器后，咱们能够通过查看 Cgroup 文件系统下，CPU 子系统中，docker这个控制组里的资源限度文件的内容来确认：
#cat/sys/fs/cgroup/cpu/docker/0712c3d12935b9a3f69ac976b9d70309b78cb7db9a5a5c8a612742370b7453e4/cpu.cfs_period_us
10000
#cat/sys/fs/cgroup/cpu/docker/0712c3d12935b9a3f69ac976b9d70309b78cb7db9a5a5c8a612742370b7453e4/cpu.cfs_quota_us
20000点击 “ 浏览原文 ” 获取更好的浏览体验！
