增加容器资源限制

上一节中，我们已经可以通过命令行mydocker run -ti的方式创建并启动容器，这一节我们将通过Cgroup对容器的资源进行控制。

这一节中我们将实现通过mydocker run -ti -m 100m -cpuset 1 -cpushare 512 /bin/sh的方式控制容器容器的内存和CPU配置。

定义Cgroups的数据结构

上一章中我们介绍了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 subsystemsimport(    "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对应的cgroupfunc (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 rw25 20 0:19 / /dev/shm rw,nosuid,nodev shared:4 - tmpfs tmpfs rw26 22 0:20 / /run/lock rw,nosuid,nodev,noexec,relatime shared:6 - tmpfs tmpfs rw,size=5120k27 18 0:21 / /sys/fs/cgroup ro,nosuid,nodev,noexec shared:9 - tmpfs tmpfs ro,mode=75528 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=systemd29 18 0:23 / /sys/fs/pstore rw,nosuid,nodev,noexec,relatime shared:11 - pstore pstore rw30 27 0:24 / /sys/fs/cgroup/memory rw,nosuid,nodev,noexec,relatime shared:13 - cgroup cgroup rw,memory31 27 0:25 / /sys/fs/cgroup/freezer rw,nosuid,nodev,noexec,relatime shared:14 - cgroup cgroup rw,freezer32 27 0:26 / /sys/fs/cgroup/hugetlb rw,nosuid,nodev,noexec,relatime shared:15 - cgroup cgroup rw,hugetlb33 27 0:27 / /sys/fs/cgroup/blkio rw,nosuid,nodev,noexec,relatime shared:16 - cgroup cgroup rw,blkio34 27 0:28 / /sys/fs/cgroup/devices rw,nosuid,nodev,noexec,relatime shared:17 - cgroup cgroup rw,devices35 27 0:29 / /sys/fs/cgroup/perf_event rw,nosuid,nodev,noexec,relatime shared:18 - cgroup cgroup rw,perf_event36 27 0:30 / /sys/fs/cgroup/pids rw,nosuid,nodev,noexec,relatime shared:19 - cgroup cgroup rw,pids37 27 0:31 / /sys/fs/cgroup/net_cls,net_prio rw,nosuid,nodev,noexec,relatime shared:20 - cgroup cgroup rw,net_cls,net_prio38 27 0:32 / /sys/fs/cgroup/cpu,cpuacct rw,nosuid,nodev,noexec,relatime shared:21 - cgroup cgroup rw,cpu,cpuacct39 27 0:33 / /sys/fs/cgroup/cpuset rw,nosuid,nodev,noexec,relatime shared:22 - cgroup cgroup rw,cpuset40 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挂载中的cgroupfunc (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.43Tasks: 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 stKiB Mem :  2048416 total,  1592804 free,   171912 used,   283700 buff/cacheKiB 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] 3000nohup: 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 stKiB Mem :  2048416 total,  1284324 free,   479940 used,   284152 buff/cacheKiB 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

小结

我们通过这一节在容器上增加了可配置的资源的控制，后面我们会继续丰富这个容器引擎的能力。