上一课时我们安装了 Golang,学习了一些容器必备的基础知识,并且自己动手编译了一个 gocker,实现了 Namespace 的隔离。今天我将带你深入剖析 gocker 的源码和实现原理,并且带你实现 cgroups 的资源限制。
打开 gocker 的源码,我们可以看到 gocker 的实现主要有两个 go 文件:一个是 main.go,一个是 run.go。这两个文件起了什么作用呢?
我们首先来看下 main.go 文件:
$ cat main.go
package main
import (
"log"
"os"
"github.com/urfave/cli/v2"
"github.com/wilhelmguo/gocker/runc"
)
func main() {
app := cli.NewApp()
app.Name = "gocker"
app.Usage = "gocker 是 golang 编写的精简版 Docker,目的是学习 Docker 的运行原理。"
app.Commands = []*cli.Command{
runc.InitCommand,
runc.RunCommand,
}
if err := app.Run(os.Args); err != nil {
log.Fatal(err)
}
}
main.go 文件中引用了一个第三方工具库 github.com/urfave/cli,该工具库提供了一个编写命令行的工具,可以帮助我们快速构建命令行应用程序,Docker 默认的容器运行时 runC 也引用了该工具库。
main 函数是 gocker 执行的入口文件,main 定义了 gocker 的名称和简单介绍,同时调用了 InitCommand 和 RunCommand 实现了gocker init
和gocker run
这两个命令的初始化。
下面我们查看一下 run.go 的文件内容,run.go 文件中定义了 InitCommand 和 RunCommand 的详细实现以及容器启动的过程,文件内容如下。
$ cat runc/run.go
package runc
import (
"errors"
"fmt"
"io/ioutil"
"log"
"os"
"os/exec"
"path/filepath"
"strings"
"syscall"
"github.com/urfave/cli/v2"
)
var RunCommand = &cli.Command{
Name: "run",
Usage: `启动一个隔离的容器
gocker run -it [command]`,
Flags: []cli.Flag{
&cli.BoolFlag{
Name: "it",
Usage: "是否启用命令行交互模式",
},
&cli.StringFlag{
Name: "rootfs",
Usage: "容器根目录",
},
},
Action: func(context *cli.Context) error {
if context.Args().Len() < 1 {
return errors.New("参数不全,请检查!")
}
read, write, err := os.Pipe()
if err != nil {
return err
}
tty := context.Bool("it")
rootfs := context.String("rootfs")
cmd := exec.Command("/proc/self/exe", "init")
cmd.SysProcAttr = &syscall.SysProcAttr{
Cloneflags: syscall.CLONE_NEWNS |
syscall.CLONE_NEWUTS |
syscall.CLONE_NEWIPC |
syscall.CLONE_NEWPID |
syscall.CLONE_NEWNET,
}
if tty {
cmd.Stdin = os.Stdin
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
}
cmd.ExtraFiles = []*os.File{read}
cmd.Dir = rootfs
if err := cmd.Start(); err != nil {
log.Println("command start error", err)
return err
}
write.WriteString(strings.Join(context.Args().Slice(), " "))
write.Close()
cmd.Wait()
return nil
},
}
var InitCommand = &cli.Command{
Name: "init",
Usage: "初始化容器进程,请勿直接调用!",
Action: func(context *cli.Context) error {
pwd, err := os.Getwd()
if err != nil {
log.Printf("Get current path error %v", err)
return err
}
log.Println("Current path is ", pwd)
cmdArray := readCommandArray()
if cmdArray == nil || len(cmdArray) == 0 {
return fmt.Errorf("Command is empty")
}
log.Println("CmdArray is ", cmdArray)
err = pivotRoot(pwd)
if err != nil {
log.Printf("pivotRoot error %v", err)
return err
}
//mount proc
defaultMountFlags := syscall.MS_NOEXEC | syscall.MS_NOSUID | syscall.MS_NODEV
syscall.Mount("proc", "/proc", "proc", uintptr(defaultMountFlags), "")
// 配置hostname
if err := syscall.Sethostname([]byte("lagoudocker")); err != nil {
fmt.Printf("Error setting hostname - %s\n", err)
return err
}
path, err := exec.LookPath(cmdArray[0])
if err != nil {
log.Printf("Exec loop path error %v", err)
return err
}
// export PATH=$PATH:/bin
if err := syscall.Exec(path, cmdArray[0:], os.Environ()); err != nil {
log.Println(err.Error())
}
return nil
},
}
func pivotRoot(root string) error {
// 确保新 root 和老 root 不在同一目录
// MS_BIND:执行bind挂载,使文件或者子目录树在文件系统内的另一个点上可视。
// MS_REC: 创建递归绑定挂载,递归更改传播类型
if err := syscall.Mount(root, root, "bind", syscall.MS_BIND|syscall.MS_REC, ""); err != nil {
return fmt.Errorf("Mount rootfs to itself error: %v", err)
}
// 创建 .pivot_root 文件夹,用于存储 old_root
pivotDir := filepath.Join(root, ".pivot_root")
if err := os.Mkdir(pivotDir, 0777); err != nil {
return err
}
// 调用 Golang 封装的 PivotRoot
if err := syscall.PivotRoot(root, pivotDir); err != nil {
return fmt.Errorf("pivot_root %v", err)
}
// 修改工作目录
if err := syscall.Chdir("/"); err != nil {
return fmt.Errorf("chdir / %v", err)
}
pivotDir = filepath.Join("/", ".pivot_root")
// 卸载 .pivot_root
if err := syscall.Unmount(pivotDir, syscall.MNT_DETACH); err != nil {
return fmt.Errorf("unmount pivot_root dir %v", err)
}
// 删除临时文件夹 .pivot_root
return os.Remove(pivotDir)
}
func readCommandArray() []string {
pipe := os.NewFile(uintptr(3), "pipe")
msg, err := ioutil.ReadAll(pipe)
if err != nil {
log.Printf("init read pipe error %v", err)
return nil
}
msgStr := string(msg)
return strings.Split(msgStr, " ")
}
看到这么多代码你是不是有点懵?别担心,我帮你一一解读。
上面文件中有两个比较重要的变量 InitCommand 和 RunCommand,它们的作用如下:
我们先从 RunCommand 来分析:
var RunCommand = &cli.Command{
// 定义一个启动命令,这里定义的是 run 命令,当执行 gocker run 时会调用该函数
Name: "run",
// 使用说明
Usage: `启动一个隔离的容器
gocker run -it [command]`,
// 执行 gocker run 命令可以传递的参数
Flags: []cli.Flag{
&cli.BoolFlag{
Name: "it",
Usage: "是否启用命令行交互模式",
},
&cli.StringFlag{
Name: "rootfs",
Usage: "容器根目录",
},
},
// gocker run 命令的执行函数
Action: func(context *cli.Context) error {
// 校验参数
if context.Args().Len() < 1 {
return errors.New("参数不全,请检查!")
}
read, write, err := os.Pipe()
if err != nil {
return err
}
// 获取传入的参数的值
tty := context.Bool("it")
rootfs := context.String("rootfs")
// 这里执行 /proc/self/exe init 相当于执行 gocker init
cmd := exec.Command("/proc/self/exe", "init")
// 定义新创建哪些命名空间
cmd.SysProcAttr = &syscall.SysProcAttr{
Cloneflags: syscall.CLONE_NEWNS |
syscall.CLONE_NEWUTS |
syscall.CLONE_NEWIPC |
syscall.CLONE_NEWPID |
syscall.CLONE_NEWNET,
}
// 把容器的标准输出重定向到主机的标准输出
if tty {
cmd.Stdin = os.Stdin
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
}
cmd.ExtraFiles = []*os.File{read}
cmd.Dir = rootfs
// 启动容器
if err := cmd.Start(); err != nil {
log.Println("command start error", err)
return err
}
write.WriteString(strings.Join(context.Args().Slice(), " "))
write.Close()
// 等待容器退出
cmd.Wait()
return nil
}
RunCommand 变量实际上是一个 Command 结构体,这个结构体包含了四个变量。
gocker run
命令的使用说明。gocker run
命令可以传递的参数。那么 InitCommand 究竟做了什么呢?
下面我们看下 InitCommand 中的内容:
var InitCommand = &cli.Command{
Name: "init",
Usage: "初始化容器进程,请勿直接调用!",
Action: func(context *cli.Context) error {
// 获取当前执行目录
pwd, err := os.Getwd()
if err != nil {
log.Printf("Get current path error %v", err)
return err
}
log.Println("Current path is ", pwd)
// 获取用户传递的启动参数
cmdArray := readCommandArray()
if cmdArray == nil || len(cmdArray) == 0 {
return fmt.Errorf("Command is empty")
}
log.Println("CmdArray is ", cmdArray)
// pivotRoot 的作用类似于 chroot,可以把我们准备的镜像目录设置为容器的根目录。
err = pivotRoot(pwd)
if err != nil {
log.Printf("pivotRoot error %v", err)
return err
}
// 挂载容器自己的 proc 目录,实现 ps 只能看到容器自己的进程
defaultMountFlags := syscall.MS_NOEXEC | syscall.MS_NOSUID | syscall.MS_NODEV
syscall.Mount("proc", "/proc", "proc", uintptr(defaultMountFlags), "")
// 配置主机名为 lagoudocker
if err := syscall.Sethostname([]byte("lagoudocker")); err != nil {
fmt.Printf("Error setting hostname - %s\n", err)
return err
}
path, err := exec.LookPath(cmdArray[0])
if err != nil {
log.Printf("Exec loop path error %v", err)
return err
}
// syscall.Exec 相当于 shell 中的 exec 实现,这里用 用户传递的主命令来替换 init 进程,从而实现容器的 1 号进程为用户传递的主进程
if err := syscall.Exec(path, cmdArray[0:], os.Environ()); err != nil {
log.Println(err.Error())
}
return nil
},
}
通过代码你能看出 InitCommand 都做了哪些容器启动前的准备工作吗?
InitCommand 主要做了以下几件事情:
这里有两个比较关键的技术点 pivotRoot 和 syscall.Exec。
最后,总结下容器的完整创建流程:
1.使用以下命令创建容器
gocker run -it -rootfs=/tmp/busybox /bin/sh
2.RunCommand 解析请求的参数(-it -rootfs=/tmp/busybox)和主进程启动命令(/bin/sh);
3.创建 namespace 隔离的容器进程;
4.启动容器进程;
5.容器内的进程执行 /proc/self/exe 调用自己实现容器的初始化,修改当前进程运行的根目录,挂载 proc 文件系统,修改主机名,最后使用 sh 进程替换当前容器的进程,使得容器的主进程为 sh 进程。
目前我们的容器虽然实现了使用 Namespace 隔离各种资源,但是容器内的进程仍然可以任意地使用主机的 CPU 、内存等资源。而这可能导致主机的资源竞争,下面我们使用cgroups来实现对 CPU 和内存的限制。
[在第 10 讲中],我们手动操作 cgroups 实现了对容器资源的限制,下面我把这部分手动操作转化为代码。
首先我们定义 cgroups 的挂载目录和我们要创建的目录,定义如下:
const gockerCgroupPath = "gocker"
const cgroupsRoot = "/sys/fs/cgroup"
然后定义Cgroups结构体,分别定义 CPU 和 Memory 字段,用于存储用户端传递的 CPU 和 Memory 限制值:
type Cgroups struct {
// 单位 核
CPU int
// 单位 兆
Memory int
}
接着定义 Cgroups 对象的一些操作方法,这样方便我们对当前容器的 cgroups 进程操作。方法定义如下。
func (c *Cgroups) Apply(pid int) error {
if c.CPU != 0 {
cpuCgroupPath, err := getCgroupPath("cpu", true)
if err != nil {
return err
}
err = ioutil.WriteFile(path.Join(cpuCgroupPath, "tasks"), []byte(strconv.Itoa(pid)), 0644)
if err != nil {
return fmt.Errorf("set cgroup cpu fail %v", err)
}
}
if c.Memory != 0 {
memoryCgroupPath, err := getCgroupPath("memory", true)
if err != nil {
return err
}
err = ioutil.WriteFile(path.Join(memoryCgroupPath, "tasks"), []byte(strconv.Itoa(pid)), 0644)
if err != nil {
return fmt.Errorf("set cgroup memory fail %v", err)
}
}
return nil
}
// 释放cgroup
func (c *Cgroups) Destroy() error {
if c.CPU != 0 {
cpuCgroupPath, err := getCgroupPath("cpu", false)
if err != nil {
return err
}
return os.RemoveAll(cpuCgroupPath)
}
if c.Memory != 0 {
memoryCgroupPath, err := getCgroupPath("memory", false)
if err != nil {
return err
}
return os.RemoveAll(memoryCgroupPath)
}
return nil
}
func (c *Cgroups) SetCPULimit(cpu int) error {
cpuCgroupPath, err := getCgroupPath("cpu", true)
if err != nil {
return err
}
if err := ioutil.WriteFile(path.Join(cpuCgroupPath, "cpu.cfs_quota_us"), []byte(strconv.Itoa(cpu*100000)), 0644); err != nil {
return fmt.Errorf("set cpu limit fail %v", err)
}
return nil
}
func (c *Cgroups) SetMemoryLimit(memory int) error {
memoryCgroupPath, err := getCgroupPath("memory", true)
if err != nil {
return err
}
if err := ioutil.WriteFile(path.Join(memoryCgroupPath, "memory.limit_in_bytes"), []byte(strconv.Itoa(memory*1024*1024)), 0644); err != nil {
return fmt.Errorf("set memory limit fail %v", err)
}
return nil
}
最后在 run 命令的 Action 函数中,添加 cgroups 初始化逻辑,将 CPU 和内存的限制值写入到 cgroups 文件中,并且将当前进程的 pid 也写入到 cgroups 的 tasks 文件中,使得 CPU 和内存的限制对于当前容器进程生效。
cgroup := cgroups.NewCgroups()
defer cgroup.Destroy()
cpus := context.Int("cpus")
if cpus != 0 {
cgroup.SetCPULimit(cpus)
}
m := context.Int("m")
if m != 0 {
cgroup.SetMemoryLimit(m)
}
cgroup.Apply(cmd.Process.Pid)
到此,我们成功实现了一个带有资源限制的 gocker 容器。下面进入 gocker 的目录,并且编译一下 gocker:
$ cd gocker
$ git checkout lesson-18
$ go install
执行完 go install 后, Golang 会自动帮助我们编译当前项目下的代码,编译后的二进制文件存放在 \(GOPATH/bin 目录下,由于我们之前在 \)HOME/.bashrc 文件下把 $GOPATH/bin 放入了系统 PATH 中,所以此时你可以直接使用 gocker 命令了。
接下来我们使用 gocker 来启动一个带有 CPU 限制的容器:
# gocker run -it -cpus=1 -rootfs=/tmp/busybox /bin/sh
2020/09/19 23:46:27 Current path is /tmp/busybox
2020/09/19 23:46:27 CmdArray is [/bin/sh]
/ #
然后我们新打开一个命令行窗口,查看一下 cgroups 相关的文件是否被创建:
# cd /sys/fs/cgroup/cpu
# ls -l
总用量 0
-rw-r--r-- 1 root root 0 9月 19 21:34 cgroup.clone_children
--w--w--w- 1 root root 0 9月 19 21:34 cgroup.event_control
-rw-r--r-- 1 root root 0 9月 19 21:34 cgroup.procs
-r--r--r-- 1 root root 0 9月 19 21:34 cgroup.sane_behavior
-r--r--r-- 1 root root 0 9月 19 21:34 cpuacct.stat
-rw-r--r-- 1 root root 0 9月 19 21:34 cpuacct.usage
-r--r--r-- 1 root root 0 9月 19 21:34 cpuacct.usage_percpu
-rw-r--r-- 1 root root 0 9月 19 21:34 cpu.cfs_period_us
-rw-r--r-- 1 root root 0 9月 19 21:34 cpu.cfs_quota_us
-rw-r--r-- 1 root root 0 9月 19 21:34 cpu.rt_period_us
-rw-r--r-- 1 root root 0 9月 19 21:34 cpu.rt_runtime_us
-rw-r--r-- 1 root root 0 9月 19 21:34 cpu.shares
-r--r--r-- 1 root root 0 9月 19 21:34 cpu.stat
drwxr-xr-x 2 root root 0 9月 22 20:48 gocker
-rw-r--r-- 1 root root 0 9月 19 21:34 notify_on_release
-rw-r--r-- 1 root root 0 9月 19 21:34 release_agent
drwxr-xr-x 70 root root 0 9月 22 20:24 system.slice
-rw-r--r-- 1 root root 0 9月 19 21:34 tasks
drwxr-xr-x 2 root root 0 9月 19 21:34 user.slice
可以看到我们启动容器后, gocker 在 cpu 子系统下,已经成功创建 gocker 目录。然后我们查看一下 gocker 目录下的内容:
# ls -l gocker/
总用量 0
-rw-r--r-- 1 root root 0 9月 22 20:48 cgroup.clone_children
--w--w--w- 1 root root 0 9月 22 20:48 cgroup.event_control
-rw-r--r-- 1 root root 0 9月 22 20:48 cgroup.procs
-r--r--r-- 1 root root 0 9月 22 20:48 cpuacct.stat
-rw-r--r-- 1 root root 0 9月 22 20:48 cpuacct.usage
-r--r--r-- 1 root root 0 9月 22 20:48 cpuacct.usage_percpu
-rw-r--r-- 1 root root 0 9月 22 20:48 cpu.cfs_period_us
-rw-r--r-- 1 root root 0 9月 22 20:48 cpu.cfs_quota_us
-rw-r--r-- 1 root root 0 9月 22 20:48 cpu.rt_period_us
-rw-r--r-- 1 root root 0 9月 22 20:48 cpu.rt_runtime_us
-rw-r--r-- 1 root root 0 9月 22 20:48 cpu.shares
-r--r--r-- 1 root root 0 9月 22 20:48 cpu.stat
-rw-r--r-- 1 root root 0 9月 22 20:48 notify_on_release
-rw-r--r-- 1 root root 0 9月 22 20:48 tasks
可以看到 cgroups 已经帮我们初始化好了 cpu 子系统的文件,然后我们查看一下 cpu.cfs_quota_us 的内容:
# cat gocker/cpu.cfs_quota_us
100000
可以看到我们容器的 CPU资源已经被限制为 1 核。下面我们来验证一下 CPU 限制是否生效。 首先我们在容器窗口使用以下命令制造一个死循环,来提升 cpu 使用率:
# while true;do echo;done;
然后在主机的窗口使用 top 查看一下cpu 使用率:
top - 20:57:50 up 2 days, 23:23, 2 users, load average: 1.08, 0.27, 0.14
Tasks: 113 total, 4 running, 109 sleeping, 0 stopped, 0 zombie
%Cpu(s): 23.5 us, 26.9 sy, 0.0 ni, 49.2 id, 0.0 wa, 0.0 hi, 0.3 si, 0.0 st
KiB Mem : 3880512 total, 1573052 free, 408696 used, 1898764 buff/cache
KiB Swap: 0 total, 0 free, 0 used. 3141076 avail Mem
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
30766 root 20 0 1312 260 212 R 99.3 0.0 0:30.90 sh
通过 top 的输出可以看到我们的容器 cpu 使用率被限制到了 100% 以内,即 1 个核。
到此,我们的容器不仅有了 Namespace 隔离,同时也有了 cgroups 的资源限制。
上一课时和本课时,我们一起安装了 golang,并且使用 golang 实现了一个精简版的 Docker,它具有基本的 namespace 隔离,并且还使用 cgroups 对容器进行了资源限制。
这两个课时的关键技术我帮你总结如下。
另外,容器的实现当然离不开 Linux 的 namespace 和 cgroups 这两项关键技术,有了 Linux 的这些关键技术才使得我们的容器可以顺利实现,可以说 Linux 是容器技术的基石。而容器的编写,我们不仅可以使用 Go 语言,也可以使用其他编程语言,甚至只使用 shell 命令也可以实现一个容器。
那么,你可以使用 shell 命令实现一个精简版的 Docker 吗?思考后,不妨试着写一下。
下一课时,我将教你使用 Docker Compose 解决开发环境的依赖。
© 2019 - 2023 Liangliang Lee. Powered by gin and hexo-theme-book.