容器服务Docker&Kubernetes + 关注
手机版

《自己动手写Docker》书摘之五: 增加容器资源限制

  1. 云栖社区>
  2. 容器服务Docker&Kubernetes>
  3. 博客>
  4. 正文

《自己动手写Docker》书摘之五: 增加容器资源限制

csome 2016-12-05 10:08:06 浏览6319 评论0

摘要: 增加容器资源限制 上一节中,我们已经可以通过命令行mydocker run -ti的方式创建并启动容器,这一节我们将通过Cgroup对容器的资源进行控制。 这一节中我们将实现通过mydocker run -ti -m 100m -cpuset 1 -cpushare 512 /bin/sh的方式控制容器容器的内存和CPU配置。

增加容器资源限制

上一节中,我们已经可以通过命令行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 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"
}

上面我们以memorySubsystem为例介绍了如何实现Subsystem的限制cgroup资源,其中的GetCgroupPath函数是找到对应subsystem的挂载的hierarchy相对路径对应的cgroup在虚拟文件系统的路径,然后通过这个目录的读写去操作cgroup,那么是如何找到挂载了subsystemhierarchy的挂载目录的呢?我们先熟悉下"/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信息,上一章介绍的时候我们讲过Cgroupshierarchy的虚拟文件系统是通过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

可以看出这一条的挂载的subsystemmemory,那么我们在/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的时间片分配比例,我们启动两个占用cpustress进程,一个容器设置-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_01_


相关链接:
《自己动手写Docker》书摘之一: Linux Namespace
《自己动手写Docker》书摘之二: Linux Cgroups  
《自己动手写Docker》书摘之三: Linux UnionFS  
《自己动手写Docker》书摘之四: 构造简单容器  
《自己动手写Docker》书摘之五: 增加容器资源限制

【云栖快讯】一站式开发者服务,海量学习资源免费学  详情请点击

网友评论