上一节中，我们已经可以通过命令行mydocker run -ti的方式创建并启动容器，这一节我们将通过Cgroup对容器的资源进行控制。 这一节中我们将实现通过mydocker run -ti -m 100m -cpuset 1 -cpushare 512 /bin/sh的方式控制容器容器的内存和CPU配置。
上一章中我们介绍了Cgroups包含的三个概念：
cgroup hierarchy中的节点，用于管理进程和subsystem的控制的关系。subsystem 作用于hierarchy上的cgroup节点，并控制节点中进程的资源占用。hierarchy 将cgroup通过树状的结构串起来，并通过虚拟文件系统的方式暴漏给用户。根据上面三个概念的关系，我们先创建出下面的数据结构：
package subsystems // 资源限制配置，包含内存限制，CPU时间片权重，CPU核心数 type ResourceConfig struct { MemoryLimit string CpuShare string CpuSet string } // Subsystem接口，每个Subsystem实现下面的4个接口 // 这里我们将cgroup抽象成了path，原因是cgroup在hierarchy的路径，便是虚拟文件系统中的虚拟路径。 type Subsystem interface { // 返回Subsystem的名字，比如cpu memory Name() string // 设置某个Cgroup在这个Subsystem中的资源限制 Set(path string, res *ResourceConfig) error // 将进程添加到某个cgroup中 Apply(path string, pid int) error // 移除某个cgroup Remove(path string) error } // 通过不同Subsystem的实现创建资源限制处理链 var ( SubsystemsIns = []Subsystem{ &CpusetSubSystem{}, &MemorySubSystem{}, &CpuSubSystem{}, } )上面我们定义了Subsystem的模型，下面我们以memory的subsystem为例介绍下要怎么实现Subsystem的操作：
package subsystems import( "fmt" "io/ioutil" "os" "path" "strconv" ) // memory Subsystem的实现 type MemorySubSystem struct { } // 设置cgroupPath对应的cgroup的内存资源限制 func (s *MemorySubSystem) Set(cgroupPath string, res *ResourceConfig) error { // GetCgroupPath是获取当前Subsystem的在虚拟文件系统中的路径， GetCgroupPath这个函数我们下面会介绍 if subsysCgroupPath, err := GetCgroupPath(s.Name(), cgroupPath, true); err == nil { if res.MemoryLimit != "" { // 设置这个cgroup的内存限制，即将限制写入到cgroup对应的目录的memory.limit_in_bytes文件中 if err := ioutil.WriteFile(path.Join(subsysCgroupPath, "memory.limit_in_bytes"), []byte(res.MemoryLimit), 0644); err != nil { return fmt.Errorf("set cgroup memory fail %v", err) } } return nil } else { return err } } // 删除cgroupPath对应的cgroup func (s *MemorySubSystem) Remove(cgroupPath string) error { if subsysCgroupPath, err := GetCgroupPath(s.Name(), cgroupPath, false); err == nil { // 删除cgroup便是删除对应的cgroupPath的目录 return os.Remove(subsysCgroupPath) } else { return err } } // 将一个进程加入到cgroupPath对应的cgroup中 func (s *MemorySubSystem) Apply(cgroupPath string, pid int) error { if subsysCgroupPath, err := GetCgroupPath(s.Name(), cgroupPath, false); err == nil { // 把进程的Pid写到cgroup的虚拟文件系统对应目录下的"task"文件中 if err := ioutil.WriteFile(path.Join(subsysCgroupPath, "tasks"), []byte(strconv.Itoa(pid)), 0644); err != nil { return fmt.Errorf("set cgroup proc fail %v", err) } return nil } else { return fmt.Errorf("get cgroup %s error: %v", cgroupPath, err) } } // 返回cgroup的名字 func (s *MemorySubSystem) Name() string { return "memory" }上面我们以memory的Subsystem为例介绍了如何实现Subsystem的限制cgroup资源，其中的GetCgroupPath函数是找到对应subsystem的挂载的hierarchy相对路径对应的cgroup在虚拟文件系统的路径，然后通过这个目录的读写去操作cgroup，那么是如何找到挂载了subsystem的hierarchy的挂载目录的呢？我们先熟悉下"/proc/pid/mountinfo"文件：
~ cat /proc/self/mountinfo . . . 24 18 0:12 / /sys/kernel/security rw,nosuid,nodev,noexec,relatime shared:8 - securityfs securityfs rw 25 20 0:19 / /dev/shm rw,nosuid,nodev shared:4 - tmpfs tmpfs rw 26 22 0:20 / /run/lock rw,nosuid,nodev,noexec,relatime shared:6 - tmpfs tmpfs rw,size=5120k 27 18 0:21 / /sys/fs/cgroup ro,nosuid,nodev,noexec shared:9 - tmpfs tmpfs ro,mode=755 28 27 0:22 / /sys/fs/cgroup/systemd rw,nosuid,nodev,noexec,relatime shared:10 - cgroup cgroup rw,xattr,release_agent=/lib/systemd/systemd-cgroups-agent,name=systemd 29 18 0:23 / /sys/fs/pstore rw,nosuid,nodev,noexec,relatime shared:11 - pstore pstore rw 30 27 0:24 / /sys/fs/cgroup/memory rw,nosuid,nodev,noexec,relatime shared:13 - cgroup cgroup rw,memory 31 27 0:25 / /sys/fs/cgroup/freezer rw,nosuid,nodev,noexec,relatime shared:14 - cgroup cgroup rw,freezer 32 27 0:26 / /sys/fs/cgroup/hugetlb rw,nosuid,nodev,noexec,relatime shared:15 - cgroup cgroup rw,hugetlb 33 27 0:27 / /sys/fs/cgroup/blkio rw,nosuid,nodev,noexec,relatime shared:16 - cgroup cgroup rw,blkio 34 27 0:28 / /sys/fs/cgroup/devices rw,nosuid,nodev,noexec,relatime shared:17 - cgroup cgroup rw,devices 35 27 0:29 / /sys/fs/cgroup/perf_event rw,nosuid,nodev,noexec,relatime shared:18 - cgroup cgroup rw,perf_event 36 27 0:30 / /sys/fs/cgroup/pids rw,nosuid,nodev,noexec,relatime shared:19 - cgroup cgroup rw,pids 37 27 0:31 / /sys/fs/cgroup/net_cls,net_prio rw,nosuid,nodev,noexec,relatime shared:20 - cgroup cgroup rw,net_cls,net_prio 38 27 0:32 / /sys/fs/cgroup/cpu,cpuacct rw,nosuid,nodev,noexec,relatime shared:21 - cgroup cgroup rw,cpu,cpuacct 39 27 0:33 / /sys/fs/cgroup/cpuset rw,nosuid,nodev,noexec,relatime shared:22 - cgroup cgroup rw,cpuset 40 19 0:34 / /proc/sys/fs/binfmt_misc rw,relatime shared:23 - autofs systemd-1 rw,fd=22,pgrp=1,timeout=0,minproto=5,maxproto=5,direct . . .通过/proc/self/mountinfo我们可以找出与当前进程相关的mount信息，上一章介绍的时候我们讲过Cgroups的hierarchy的虚拟文件系统是通过cgroup类型的mount挂载上去，option中加上subsystem代表挂载的subsystem，那么我们就可以在mountinfo中找到对应的subsystem的挂载目录，比如memory的：
30 27 0:24 / /sys/fs/cgroup/memory rw,nosuid,nodev,noexec,relatime shared:13 - cgroup cgroup rw,memory可以看出这一条的挂载的subsystem是memory，那么我们在/sys/fs/cgroup/memory中创建文件夹创建的cgroup就可以用来做内存的限制。下面便是我们的实现：
// 通过/proc/self/mountinfo找出挂载了某个subsystem的hierarchy根cgroup节点所在的目录FindCgroupMountpoint("memory") func FindCgroupMountpoint(subsystem string) string { f, err := os.Open("/proc/self/mountinfo") if err != nil { return "" } defer f.Close() scanner := bufio.NewScanner(f) for scanner.Scan() { txt := scanner.Text() fields := strings.Split(txt, " ") for _, opt := range strings.Split(fields[len(fields)-1], ",") { if opt == subsystem { return fields[4] } } } if err := scanner.Err(); err != nil { return "" } return "" } // 得到cgroup在文件系统中的绝对路径 func GetCgroupPath(subsystem string, cgroupPath string, autoCreate bool) (string, error) { cgroupRoot := FindCgroupMountpoint(subsystem) if _, err := os.Stat(path.Join(cgroupRoot, cgroupPath)); err == nil || (autoCreate && os.IsNotExist(err)) { if os.IsNotExist(err) { if err := os.Mkdir(path.Join(cgroupRoot, cgroupPath), 0755); err == nil { } else { return "", fmt.Errorf("error create cgroup %v", err) } } return path.Join(cgroupRoot, cgroupPath), nil } else { return "", fmt.Errorf("cgroup path error %v", err) } }最后，我们需要把这些不同的Subsystems中的cgroup管理起来，并与容器建立关系：
type CgroupManager struct { // cgroup在hierarchy中的路径 相当于创建的cgroup目录相对于各root cgroup目录的路径 Path string // 资源配置 Resource *subsystems.ResourceConfig } func NewCgroupManager(path string) *CgroupManager { return &CgroupManager{ Path: path, } } // 将进程pid加入到每个cgroup中 func (c *CgroupManager) Apply(pid int) error { for _, subSysIns := range(subsystems.SubsystemsIns) { subSysIns.Apply(c.Path, pid) } return nil } // 设置各个subsystem挂载中的cgroup资源限制 func (c *CgroupManager) Set(res *subsystems.ResourceConfig) error { for _, subSysIns := range(subsystems.SubsystemsIns) { subSysIns.Set(c.Path, res) } return nil } // 释放各个subsystem挂载中的cgroup func (c *CgroupManager) Destroy() error { for _, subSysIns := range(subsystems.SubsystemsIns) { if err := subSysIns.Remove(c.Path); err != nil { logrus.Warnf("remove cgroup fail %v", err) } } return nil }通过CgroupManager，将资源限制的配置，以及将进程移动到cgroup中的操作交给各个subsystem去处理。
我们在上一节的时候介绍了github.com/urfave/cli的工具可以方便的创建出命令行的程序，现在我们把资源限制的标签也加上，并在容器创建出来初始化之后将容器的进程加到各Subsystem挂载的cgroup中。
func Run(tty bool, comArray []string, res *subsystems.ResourceConfig) { parent, writePipe := container.NewParentProcess(tty) if parent == nil { log.Errorf("New parent process error") return } if err := parent.Start(); err != nil { log.Error(err) } // use mydocker-cgroup as cgroup name // 创建cgroup manager，并通过调用set和apply设置资源限制和使限制在容器上生效 cgroupManager := cgroups.NewCgroupManager("mydocker-cgroup") defer cgroupManager.Destroy() cgroupManager.Set(res) cgroupManager.Apply(parent.Process.Pid) // 对容器设置完限制之后初始化容器 sendInitCommand(comArray, writePipe) parent.Wait() }到此为止，我们的对容器的资源控制已经完工了，下面我们测试下：
用-m 100m限制内存
mydocker git:(2.2) sudo ./mydocker run -ti -m 100m stress --vm-bytes 200m --vm-keep -m 1 {"level":"info","msg":"command all is stress --vm-bytes 200m --vm-keep -m 1","time":"2016-12-03T20:37:11+08:00"} {"level":"info","msg":"init come on","time":"2016-12-03T20:37:11+08:00"} {"level":"info","msg":"Find path /usr/bin/stress","time":"2016-12-03T20:37:11+08:00"} stress: info: [1] dispatching hogs: 0 cpu, 0 io, 1 vm, 0 hdd可以看到占用内存被限制到了100MB
top - 20:41:49 up 16:28, 3 users, load average: 1.18, 0.96, 0.43 Tasks: 122 total, 2 running, 120 sleeping, 0 stopped, 0 zombie %Cpu(s): 0.4 us, 5.3 sy, 0.0 ni, 0.0 id, 90.4 wa, 0.0 hi, 3.9 si, 0.0 st KiB Mem : 2048416 total, 1592804 free, 171912 used, 283700 buff/cache KiB Swap: 2097148 total, 1892232 free, 204916 used. 1715080 avail Mem PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 2874 root 20 0 212284 102352 276 R 7.6 5.0 0:03.84 stress用-cpushare 512限制限制下CPU的时间片分配比例，我们启动两个占用cpu的stress进程，一个容器设置-cpushare 512：
mydocker git:(2.2) nohup stress --vm-bytes 200m --vm-keep -m 1 & [1] 3000 nohup: ignoring input and appending output to 'nohup.out' mydocker git:(2.2) sudo ./mydocker run -ti -cpushare 512 stress --vm-bytes 200m --vm-keep -m 1 {"level":"info","msg":"command all is stress --vm-bytes 200m --vm-keep -m 1","time":"2016-12-03T21:00:28+08:00"} {"level":"info","msg":"init come on","time":"2016-12-03T21:00:28+08:00"} {"level":"warning","msg":"stress --vm-bytes 200m --vm-keep -m 1","time":"2016-12-03T21:00:28+08:00"} {"level":"info","msg":"Find path /usr/bin/stress","time":"2016-12-03T21:00:28+08:00"} stress: info: [1] dispatching hogs: 0 cpu, 0 io, 1 vm, 0 hdd上面的没有设置cpushare的进程的默认的值是1024，我们通过设置容器的-cpushare 512，所以能看到容器中的进程的CPU占用只有默认的一半。
%Cpu(s): 99.7 us, 0.0 sy, 0.0 ni, 0.0 id, 0.0 wa, 0.0 hi, 0.3 si, 0.0 st KiB Mem : 2048416 total, 1284324 free, 479940 used, 284152 buff/cache KiB Swap: 2097148 total, 2097148 free, 0 used. 1407116 avail Mem PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 3290 bingshe+ 20 0 212284 205000 212 R 66.4 10.0 0:04.49 stress 3273 root 20 0 212284 205004 212 R 33.2 10.0 0:16.01 stress我们通过这一节在容器上增加了可配置的资源的控制，后面我们会继续丰富这个容器引擎的能力。
相关图书推荐<<自己动手写docker>>
相关链接：《自己动手写Docker》书摘之一： Linux Namespace《自己动手写Docker》书摘之二： Linux Cgroups 《自己动手写Docker》书摘之三： Linux UnionFS 《自己动手写Docker》书摘之四： 构造简单容器 《自己动手写Docker》书摘之五： 增加容器资源限制
相关资源：自己动手写 Docker