个人中心
文章发布
退出
作者热门文章
- Java锁的逻辑（结合对象头和ObjectMonitor）
- 还在用饼状图？来瞧瞧这些炫酷的百分比可视化新图形（附代码实现）⛵
- 自动注册实体类到EntityFrameworkCore上下文，并适配ABP及ABPVNext
- 基于Sklearn机器学习代码实战
29
4
本文为《自己动手写 Docker》的学习，对于各位学习 docker 的同学非常友好，非常建议买一本来学习.
书中有摘录书中的一些知识点，不过限于篇幅，没有全部摘录 (主要也是懒) 。项目仓库地址为： JaydenChang/simple-docker (github.com) 。
kernel (内核) 指大多数操作系统的核心部分，由操作系统中用于管理存储器、文件、外设和系统资源的部分组成。操作系统内核通常运行进程，并提供进程间通信.
namespace 是 Linux 自带的功能来隔离内核资源的机制.
Linux 中有 6 种 namespace 。
UTS，UNIX Time Sharing，用于隔离 nodeName (主机名) 和 domainName (域名)。在该 Namespace 下修改 hostname 不会影相其他的 Namespace.
IPC，Inter-Process Communication (进程间通讯)，用于隔离 System V IPC 和 POSIX message queues (一种消息队列，结构为链表).
两种 IPC 本质上差不多，System V IPC 随内核持续，POSIX IPC 随进程持续.
PID，Process IDs，用于隔绝 PID。同样的进程，在不同 Namespace 里是不同的 PID。新建的 PID Namespace 里第一个 PID 是1.
用于隔绝文件系统，挂载了某一目录，在这个 Namespace 下就会把这个目录当作根目录，我们看到的文件系统树就会以这个目录为根目录.
mount 操作本身不会影响到外部，docker 中的 volume 也用到了这个特性.
用于 隔离用户组 ID.
每个 Namespace 都有一套自己的网络设备，可以使用相同的端口号，映射到 host 的不同端口.
Cgroups 全称为 Control Groups，是 Linux 内核提供的物理资源隔离机制.
Linux 有一些限制:
subsystem 配置文件 不是 subsystem ，就像 .git 不是 git 一样，就像没安装 git 也可以从别人那里获得 .git 文件夹，只是不能用罢了。 subsystem 配置文件 也是如此，新建一个 cgroup 就会生成 cgroup 配置文件 ，但并不代表你关联了一个 subsystem。只有当改变了一个 cgroup 配置文件 ，里面要限制某种资源时，就会自动关联到这个被限制的资源所对应的 subsystem 上。 kernel 接口，就是在 Linux 上调用 api 来控制 cgroups.
首先创建一个 hierarchy，而 hierarchy 要挂载到一个目录上，这里创建一个目录:
复制
mkdir hierarchy-test
然后挂载:
复制
sudo mount -t cgroup -o none,name=hierarchy-test hierarchy-test ./hierarchy-test
可以在这个目录下看到一大堆文件，这些文件就是 cgroup 根节点的配置.
然后在这个目录下创建新的空目录，会发现，新的目录里也会有很多 cgroup 配置文件，这些目录已成为 cgroup 根节点的子节点 cgroup.
复制
.
├── cgroup.clone_children
├── cgroup.procs
├── cgroup.sane_behavior
├── notify_on_release
├── release_agent
├── tasks
└── temp # 这是新创建的文件夹
├── cgroup.clone_children
├── cgroup.procs
├── notify_on_release
└── tasks
在 cgroup 中添加和移动进程：系统的所有进程都会被放到根节点中，可以根据需要移动进程:
只需将进程 ID 写到对应的 cgroup 的 tasks 文件即可.
复制
sudo sh -c "echo $$ >> tasks"
该命令就是将当前终端的这个进程加到当前所在的 cgroup 的目录的 tasks 文件中.
通过 subsystem 限制 cgroup 中进程的资源:
docker 会给每个容器创建一个 cgroup，再限制该 cgroup 的资源，从而达到限制容器的资源的作用.
其实写了这么多，综合上面的前置知识，不难猜测，docker 的原理是：隔离主机.
复制
package main
import (
"fmt"
"io/ioutil"
"os"
"os/exec"
"path"
"strconv"
"syscall"
)
const cgroupMemoryHierarchyCount = "/sys/fs/cgroup/memory"
func main() {
// 第二次会运行这段代码
// 这段代码运行的地方就可以看做是一个简易的容器
// 这里只是对进程进行了隔离
// 但是可以看到 pid 已经变成了 1，因为我们有 PID Namespace
if os.Args[0] == "/proc/self/exe" {
fmt.Printf("current pid %d\n", syscall.Getpid())
cmd := exec.Command("sh", "-c", `stress --vm-bytes 200m --vm-keep -m 1`)
cmd.SysProcAttr = &syscall.SysProcAttr{}
cmd.Stdin = os.Stdin
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if err := cmd.Run(); err != nil {
fmt.Println(err)
os.Exit(1)
}
}
// 第一次运行这段
// **command 设置为当前进程，也就是这个 go 程序本身，也就是说 cmd.Start() 会再次运行该程序
cmd := exec.Command("/proc/self/exe")
// 在 start 之前，修改 cmd 的各种配置，也就是第二次运行这个程序的时候的配置
// 创建 namespace
cmd.SysProcAttr = &syscall.SysProcAttr {
Cloneflags: syscall.CLONE_NEWUTS | syscall.CLONE_NEWPID | syscall.CLONE_NEWNS,
}
cmd.Stdin = os.Stdin
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
// 因为之后要打印 process 的 id，所以用 start
// 如果这里用 run 的话，那么 else 里的代码永远不会执行，因为 stress 永远不会结束
if err := cmd.Start(); err != nil {
fmt.Println("Error", err)
os.Exit(1)
} else {
// 打印 new process id
fmt.Printf("%v\n", cmd.Process.Pid)
// 接下来三段对 cgroup 操作
// the hierarchy has been already created by linux on the memory subsystem
// create a sub cgroup
os.Mkdir(path.Join(
cgroupMemoryHierarchyCount,
"testMemoryLimit",
), 0755)
// place container process in this cgroup
ioutil.WriteFile(path.Join(
cgroupMemoryHierarchyCount,
"testMemoryLimit",
"tasks",
), []byte(strconv.Itoa(cmd.Process.Pid)), 0644)
// restrict the stress process on this cgroup
ioutil.WriteFile(path.Join(
cgroupMemoryHierarchyCount,
"testMemoryLimit",
"memory.limit_int_bytes",
), []byte("100m"), 0644)
// cmd.Start() 不会等待进程结束，所以需要手动等待
// 如果不加的话，由于主进程结束了，子进程也会被强行结束
cmd.Process.Wait()
}
}
UFS，Union File System，联合文件系统。docker 在下载一个 image 文件时，会看到一次下载很多个文件，这就是 UFS。它是一种分层、轻量、高性能的文件系统。UFS 类似 git，每次修改文件时，都是一次提交，并有记录，修改都反映在一个新的文件上，而不是修改旧文件.
UFS 允许多个不同目录挂载到同一个虚拟文件系统下，这就是为什么 image 之间可以共享文件，以及继承镜像的原因.
AUFS，Advanced Union File System，是 UFS 的一个改动版本.
笔者本身使用的是 WSL 做日常开发，WSL 内核不支持 AUFS，后面会提到更换内核.
docker 在早期使用 AUFS，直到现在也可以选择作为一种存储驱动类型.
image 由多层 read-only layer 构成.
当启动一个 container 时，就会在 image 上再加一层 init layer，init layer 也是 read-only 的，用于储存容器的环境配置。此外，docker 还会创建一个 read-write 的 layer，用于执行所有的写操作.
当停止容器时，这个 read-write layer 依然保留，只有删除 container 时才会被删除.
那么，怎么删除旧文件呢?
docker 会在 read-write layer 生成一个 .wh.<fileName> 文件来隐藏要删除的文件.
我们先创建一个如下的文件夹结构:
复制
.
├── container-layer
│ └── container.txt
├── image-layer
│ └── image.txt
└── mnt
然后挂载到 mnt 文件夹上:
复制
sudo mount -t aufs -o dirs=./container-layer:./image-layer none ./mnt
如果没有手动添加权限的话，默认 dirs 左边第一个文件夹有 write-read 权限，其他都是 read-only.
我们可以发现，imageLayer1 和 writeLayer 的文件出现在 mnt 文件夹下:
复制
.
├── container-layer
│ └── container.txt
├── image-layer
│ └── image.txt
└── mnt
├── container.txt
└── image.txt
然后我们修改一下 image.txt 的内容，然后再看看整个目录，会发现， container-layer 目录下多了一个 image.txt ，然后我们看看 container-layer 的 image.txt 的内容，有添加前后的的文字.
也就是说，实际上，当修改某一个 layer 的时候，实际上不会改变这个 layer，而是将其复制到 container-layer 中，然后再修改这个新的文件.
在 /proc 文件夹下可以看到很多文件夹的名字都是个数字，其实就是个 PID。是 Linux 为每个进程创建的空间.
复制
/proc/N # PID 为 N 的进程
/proc/N/cmdline # 进程的启动命令
/proc/N/cwd # 链接到进程的工作目录
/proc/N/environ # 进程的环境变量列表
/proc/N/exe # 链接到进程的执行命令
/proc/N/fd # 包含进程相关的所有文件描述符
/proc/N/maps # 与进程相关的内存映射信息
/proc/N/mem # 进程持有的内存，不可读
/proc/N/root # 链接到进程的根目录
/proc/N/stat # 进程的状态
/proc/N/statm # 进程的内存状态
/proc/N/status # 比上面两个更可读
/proc/self # 链接到当前正在运行的进程
获取帮助编写 command line app 的工具:
复制
go get github.com/urfave/cli
代码结构:
复制
.
├── command.go
├── container
│ └── init.go
├── dockerCommand
│ └── run.go
├── go.mod
├── go.sum
└── main.go
command.go 用于放置各种 command 命令，这里先只写一个 runCommand 命令.
首先用 urfave/cli 创建一个 runCommand 命令:
复制
// command.go
var runCommand = cli.Command{
Name: "run",
Usage: "Create a container",
Flags: []cli.Flag{
// integrate -i and -t for convenience
&cli.BoolFlag{
Name: "it",
Usage: "open an interactive tty(pseudo terminal)",
},
},
Action: func(context *cli.Context) error {
args := context.Args()
if len(args) == 0 {
return errors.New("Run what?")
}
cmdArray := args.Get(0) // command
// check whether type `-it`
tty := context.Bool("it") // presudo terminal
// 这个函数在下面定义
dockerCommand.Run(tty, cmdArray)
return nil
},
}
上面的 Run 函数在 dockerCommand/run.go 下定义。当运行 docker run 时，实际上主要是 Action 下的这个函数在工作:
复制
// dockerCommand/run.go
// This is the function what `docker run` will call
func Run(tty bool, cmdArray string) {
// this is "docker init <cmdArray>"
initProcess := container.NewProcess(tty, cmdArray)
// start the init process
if err := initProcess.Start(); err != nil{
logrus.Error(err)
}
initProcess.Wait()
os.Exit(-1)
}
但其实这个函数做的也只是去跑一个 initProcess。这个 command process 在另一个包里定义.
上面提到的 container.NewProcess 在 container/init.go 里定义:
复制
// container/init.go
func NewProcess(tty bool, cmdArray string) *exec.Cmd {
// create a new command which run itself
// the first arguments is `init` which is the below exported function
// so, the <cmd> will be interpret as "docker init <cmdArray>"
args := []string{"init", cmdArray}
cmd := exec.Command("/proc/self/exe", args...)
// new namespaces, thanks to Linux
cmd.SysProcAttr = &syscall.SysProcAttr{
Cloneflags: syscall.CLONE_NEWUTS | syscall.CLONE_NEWIPC | syscall.CLONE_NEWPID | syscall.CLONE_NEWNS | syscall.CLONE_NEWNET,
}
// this is what presudo terminal means
// link the container's stdio to os
if tty {
cmd.Stdin = os.Stdin
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
}
return cmd
}
这个函数的作用是生成一个新的 command process，但这个 command 是 /proc/self/exe 这个程序本身，也就是，我们最后生成的可执行文件，但这次我们不运行 docker run ，而是 docker init ，这个 init 命令在下面定义.
initCommand 和 runCommand 在同一个文件里定义，也是一个 command，但是注意这个 command 不面向用户，只用于协助 runCommand.
复制
// command.go
// docker init, but cannot be used by user
var initCommand = cli.Command{
Name: "init",
Usage: "init a container",
Action: func(context *cli.Context) error {
logrus.Infof("Start initiating...")
cmdArray := context.Args().Get(0)
logrus.Infof("container command: %v", cmdArray)
return container.InitProcess(cmdArray, nil)
},
}
这里使用了 container.InitProcess 函数，这个函数是真正用于容器初始化的函数.
这里的是 InitProcess，也就是容器初始化的步骤.
注意 syscall.Exec 这里:
mount / 并指定 private，不然容器里的 proc 会使用外面的 proc，即使在不同 namespace 下。
复制
// already in container
// initiate the container
func InitProcess(cmdArray string, args []string) error {
defaultMountFlags := syscall.MS_NOEXEC | syscall.MS_NOSUID | syscall.MS_NODEV
// mount
if err := syscall.Mount("", "/", "", syscall.MS_PRIVATE|syscall.MS_REC, ""); err != nil {
logrus.Errorf("mount / fails: %v", err)
return err
}
// mount proc filesystem
syscall.Mount("proc", "/proc", "proc", uintptr(defaultMountFlags), "")
argv := []string{cmdArray}
if err := syscall.Exec(cmdArray, argv, os.Environ()); err != nil {
logrus.Errorf("mount /proc fails: %v", err)
}
return nil
}
一般来说，我们都是想要这个 cmdArray 作为 PID=1 的进程。but，我们有 initProcess 本身的存在，所以 PID = 1 的其实是 initProcess，那如何让 cmdArray 作为 PID=1 的存在呢?
这里有一个 syscall.Exec 神器，Exec 内部会调用 kernel 的 execve 函数，这个函数会把当前进程上运行的程序替换为另一个程序，这正是我们想要的，在不改变 PID 的情况下，替换程序 (即使 kill PID 为 1 的进程，新创建的进程也会是 PID=2).
为什么要第一个命令的 PID 为 1?
这里要用到 subsystem 的知识.
看到这里，有个 cpu，cpushare，cpuset 等等，有点晕，查了下，有关 CPU 的 cgroup subsystem，这里列举常见的 3 个:
通常前两者可以合体 。
复制
package subsystems
type ResourceConfig struct {
MemoryLimit string
CPUShare string
CPUSet string
}
type Subsystem interface {
// return the name of which type of subsystem
Name() string
// set a resource limit on a cgroup
Set(cgroupPath string, res *ResourceConfig) error
// add a processs with the pid to a group
AddProcess(cgroupPath string, pid int) error
// remove a cgroup
RemoveCgroup(cgroupPath string) error
}
// instance of a subsystems
var SubsystemsInstance = []Subsystem{
&CPU{},
&CPUSet{},
&Memory{},
}
很简单，返回 “memory” 字符串，表示这个 subsystem 是 memorySubsystem.
复制
func (ms *MemorySubsystem) Name() string {
return "memory"
}
Set() 用于对 cgroup 设置资源限制，因此参数为 cgroup 的 path 和 resourceConfig.
GetCgroupPath 后面会提及，作用是获取这个 subsystem 所挂载的 hierarchy 上的虚拟文件系统下的 从group 路径。
复制
// set the memory limit to this cgroup with cgroupPath
func (ms *Memory) Set(cgroupPath string, res *ResourceConfig) error {
if subsystemCgroupPath, err := GetCgroupPath(ms.Name(), cgroupPath, true); err != nil {
return err
} else {
if err := ioutil.WriteFile(path.Join(subsystemCgroupPath, "memory.limit_in_bytes"), []byte(res.MemoryLimit), 0644); err != nil {
return fmt.Errorf("set cgroup memory fail: %v", err)
}
}
return nil
}
复制
func (ms *Memory) AddProcess(cgroupPath string, pid int) error {
if subsystemCgroupPath, err := GetCgroupPath(ms.Name(), cgroupPath, false); err != nil {
return err
} else {
if err := ioutil.WriteFile(path.Join(subsystemCgroupPath, "tasks"), []byte(strconv.Itoa(pid)), 0644); err != nil {
return fmt.Errorf("cgroup add process fail: %v", err)
}
}
return nil
}
os.Remove 可以移除参数所指定的文件或文件夹。
复制
func (ms *Memory) RemoveCgroup(cgroupPath string) error {
if subsystemCgroupPath, err := GetCgroupPath(ms.Name(), cgroupPath, false); err != nil {
return err
} else {
return os.Remove(subsystemCgroupPath)
}
}
这里的设计和上面没什么区别，直接贴参考代码 。
复制
// cpu.go
func (c *CPU) Name() string {
return "CPUShare"
}
func (c *CPU) Set(cgroupPath string, res *ResourceConfig) error {
if subsystemCgroupPath, err := GetCgroupPath(c.Name(), cgroupPath, true); err != nil {
return err
} else {
if err := ioutil.WriteFile(path.Join(subsystemCgroupPath, "cpu.shares"), []byte(res.CPUShare), 0644); err != nil {
return fmt.Errorf("set cpu share limit failed: %s", err)
}
}
return nil
}
func (c *CPU) AddProcess(cgroupPath string, pid int) error {
if subsystemCgroupPath, err := GetCgroupPath(c.Name(), cgroupPath, false); err != nil {
return err
} else {
if err := ioutil.WriteFile(path.Join(subsystemCgroupPath, "tasks"), []byte(strconv.Itoa(pid)), 0644); err != nil {
return fmt.Errorf("cgroup add cpu process failed: %v", err)
}
}
return nil
}
func (c *CPU) RemoveCgroup(cgroupPath string) error {
if subsystemCgroupPath, err := GetCgroupPath(c.Name(), cgroupPath, false); err != nil {
return err
} else {
return os.Remove(subsystemCgroupPath)
}
}
复制
// cpuset.go
func (c *CPUSet) Name() string {
return "CPUSet"
}
func (c *CPUSet) Set(cgroupPath string, res *ResourceConfig) error {
if subsystemCgroupPath, err := GetCgroupPath(c.Name(), cgroupPath, true); err != nil {
return err
} else {
if err := ioutil.WriteFile(path.Join(subsystemCgroupPath, "cpuset.cpus"), []byte(res.CPUSet), 0644); err != nil {
return fmt.Errorf("set cgroup cpuset failed: %v", err)
}
}
return nil
}
func (c *CPUSet) AddProcess(cgroupPath string, pid int) error {
if subsystemCgroupPath, err := GetCgroupPath(c.Name(), cgroupPath, false); err != nil {
return err
} else {
if err := ioutil.WriteFile(path.Join(subsystemCgroupPath, "tasks"), []byte(strconv.Itoa(pid)), 0644); err != nil {
return fmt.Errorf("cgroup add cpuset process failed: %v", err)
}
}
return nil
}
func (c *CPUSet) RemoveCgroup(cgroupPath string) error {
if subsystemCgroupPath, err := GetCgroupPath(c.Name(), cgroupPath, false); err != nil {
return err
} else {
return os.Remove(path.Join(subsystemCgroupPath))
}
}
GetCgroupPath() 用于获取某个 subsystem 所挂载的 hierarchy 上的虚拟文件系统 (挂载后的文件夹) 下的 cgroup 的路径。通过对这个目录的改写来改动 cgroup.
首先我们抛开 cgroup，在此之前我们要知道 这个 hierarchy 的 cgroup 根节点的路径。那可以在 /proc/self/mountinfo 中获取.
下面是一些实现细节:
FindCgroupMountpoint() 来找到 cgroup 的根节点。 GetCgroupPath 将其和 cgroup 的相对路径拼接从而获取 cgroup 的路径。如果 autoCreate 为 true 且该路径不存在，那么就新建一个 cgroup。(在 hierarchy 环境下，mkdir 其实会隐式地创建一个 cgroup，其中包括很多配置文件) 点击这里回顾 。
复制
// as the function name shows, find the root path of hierarchy
func FindCgroupMountpoint(subsystemName string) string {
f, err := os.Open("/proc/self/mountinfo")
// get info about mount relate to current process
if err != nil {
return ""
}
defer f.Close()
scanner := bufio.NewScanner(f)
for scanner.Scan() {
txt := scanner.Text()
fields := strings.Split(txt, " ")
// find whether "subsystemName" appear in the last field
// if so, then the fifth field is the path
for _, opt := range strings.Split(fields[len(fields)-1], ",") {
if opt == subsystemName {
return fields[4]
}
}
}
return ""
}
// get the absolute path of a cgroup
func GetCgroupPath(subsystemName string, cgroupPath string, autoCreate bool) (string, error) {
cgroupRootPath := FindCgroupMountpoint(subsystemName)
expectedPath := path.Join(cgroupRootPath, cgroupPath)
// find the cgroup or create a new cgroup
if _, err := os.Stat(expectedPath); err == nil || (autoCreate && os.IsNotExist(err)) {
if os.IsNotExist(err) {
if err := os.Mkdir(expectedPath, 0755); err != nil {
return "", fmt.Errorf("error when create cgroup: %v", err)
}
}
return expectedPath, nil
} else {
return "", fmt.Errorf("cgroup path error: %v", err)
}
}
Set() 可能会创建多个 cgroups，如果 subsystems 们在不同的 hierarchy 就会这样。 AddProcess() 和 Remove() 要在每个 subsystem 上执行一遍。因为这些 subsystem 可能存在于不同的 hierarchies。 Set() 和 AddProcess() 都不是返回错误，而是发出警告，然后返回 nil。因为有些时候用户只指定某一个限制，例如 memory，那样的话修改 cpu 等其实会报错 (正常的报错)，因此我们不 return err 来退出。
复制
package cgroups
import "simple-docker/subsystem"
type CgroupManager struct {
Path string // relative path, relative to the root path of the hierarchy
// so this may cause more than one cgroup in different hierarchies
Resource *subsystems.ResourceConfig
}
func NewCgroupManager(path string) *CgroupManager {
return &CgroupManager{
Path: path,
}
}
// set the three resource config subsystems to the cgroup(will create if the cgroup path is not existed)
// this may generate more than one cgroup, because those subsystem may appear in different hierarchies
func (cm CgroupManager) Set(res *subsystems.ResourceConfig) error {
for _, subsystem := range subsystems.SubsystemsInstance {
if err := subsystem.Set(cm.Path, res); err != nil {
logrus.Warnf("set resource fail: %v", err)
}
}
return nil
}
// add process to the cgroup path
// why should we iterate all the subsystems? we have only one cgroup
// because those subsystems may appear at different hierarchies, which will then cause more than one cgroup, 1-3 in this case.
func (cm *CgroupManager) AddProcess(pid int) error {
for _, subsystem := range subsystems.SubsystemsInstance {
if err := subsystem.AddProcess(cm.Path, pid); err != nil {
logrus.Warn("app process fail: %v", err)
}
}
return nil
}
// delete the cgroup(s)
func (cm *CgroupManager) Remove() error {
for _, subsystem := range subsystems.SubsystemsInstance {
if err:= subsystem.RemoveCgroup(cm.Path); err != nil {
return err
}
}
return nil
}
限制容器运行的命令不再像是 /bin/sh 这种单个参数，而是多个参数，因此需要使用管道来对多个参数进行处理。那么需要修改以下文件:
os.Pipe() 获取管道。返回的 readPipe 和 writePipe 都是 *os.File 类型。 ExtraFile 这个参数来解决。cmd 会带着参数里的文件来创建新的进程。(这里除了 ExtraFile，还会有类似 StandardFile，也就是 stdin，stdout，stderr)
复制
func NewParentProcess(tty bool) (*exec.Cmd, *os.File) {
readPipe, writePipe, err := os.Pipe()
if err != nil {
logrus.Errorf("new pipe error: %v", err)
return nil, nil
}
// create a new command which run itself
cmd := exec.Command("/proc/self/exe", "init")
// new namespaces
cmd.SysProcAttr = &syscall.SysProcAttr{
Cloneflags: syscall.CLONE_NEWUTS | syscall.CLONE_NEWIPC | syscall.CLONE_NEWPID | syscall.CLONE_NEWNS | syscall.CLONE_NEWNET,
}
// link the container's stdio to os
if tty {
cmd.Stdin = os.Stdin
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
}
cmd.ExtraFiles = []*os.File{readPipe}
return cmd, writePipe
}
除了 NewProcess() ， InitProcess() 也要改变下.
readCommand() 时会堵塞，直到 write 端传数据进来。 InitProcess() 也不会运行到 syscall.Exec() 这一步。 /bin/ls 的麻烦，这个函数会帮我们找到参数命令的绝对路径。也就是说，只要输入 ls 即可，lookPath 会自动找到 /bin/ls 。然后我们再把这个 path 作为 argv() 传给 syscall.Exec
复制
// already in container
// initialize the container
func InitProcess() error {
cmdArray := readCommand()
if len(cmdArray) == 0 {
return fmt.Errorf("init process fails, cmdArray is nil")
}
defaultMountFlags := syscall.MS_NOEXEC | syscall.MS_NOSUID | syscall.MS_NODEV
// mount proc filesystem
syscall.Mount("proc", "/proc", "proc", uintptr(defaultMountFlags), "")
path, err := exec.LookPath(cmdArray[0])
if err != nil {
logrus.Errorf("initProcess look path failed: %v", err)
return err
}
// log path info
logrus.Infof("find path: %v", path)
if err := syscall.Exec(path, cmdArray, os.Environ()); err != nil {
logrus.Errorf(err.Error())
}
return nil
}
func readCommand() []string {
pipe := os.NewFile(uintptr(3), "pipe")
msg, err := ioutil.ReadAll(pipe)
if err != nil {
logrus.Errorf("read pipe failed: %v", err)
return nil
}
return strings.Split(string(msg), " ")
}
复制
func Run(tty bool, cmdArray []string, res *subsystem.ResourceConfig) {
initProcess, writePipe := container.NewProcess(tty)
// start the init process
if err := initProcess.Start(); err != nil {
logrus.Error(err)
}
// create container manager to control resource config on all hierarchies
cm := cgroups.NewCgroupManager("simple-docker")
defer cm.Remove()
cm.Set(res)
cm.AddProcess(initProcess.Process.Pid)
// send command to write side
sendInitCommand(cmdArray, writePipe)
initProcess.Wait()
os.Exit(-1)
}
func sendInitCommand(cmdArray []string, writePipe *os.File) {
cmdString := strings.Join(cmdArray, " ")
logrus.Infof("whole init command is: %v", cmdString)
writePipe.WriteString(cmdString)
writePipe.Close()
}
复制
var RunCommand = cli.Command{
Name: "run",
Usage: "Create a container",
Flags: []cli.Flag{
&cli.BoolFlag{
Name: "it",
Usage: "open a interactive tty(pre sudo terminal)",
},
&cli.StringFlag{
Name: "m",
Usage: "limit the memory",
},
&cli.StringFlag{
Name: "cpu",
Usage: "limit the cpu amount",
},
&cli.StringFlag{
Name: "cpushare",
Usage:"limit the cpu share",
},
},
Action: func(context *cli.Context) error {
args := context.Args()
if len(args) == 0 {
return errors.New("run what?")
}
cmdArray := make([]string,len(args)) // command
copy(cmdArray,args)
// checkout whether type `-it`
tty := context.Bool("it") // pre sudo terminal
// get the resource config
resourceConfig := subsystem.ResourceConfig {
MemoryLimit: context.String("m"),
CPUShare: context.String("cpushare"),
CPUSet: context.String("cpu"),
}
dockerCommand.Run(tty, cmdArray, &resourceConfig)
return nil
},
}
// docker init, but cannot be used by user
var InitCommand = cli.Command{
Name: "init",
Usage: "init a container",
Action: func(context *cli.Context) error {
logrus.Infof("start initializing...")
return container.InitProcess()
},
}
除了上面的修改，我们还要定义一个程序的入口:
复制
package main
import (
"os"
"github.com/sirupsen/logrus"
"github.com/urfave/cli"
)
const usage = `Usage`
func main() {
app := cli.NewApp()
app.Name = "simple-docker"
app.Usage = usage
app.Commands = []cli.Command{
RunCommand,
InitCommand,
}
app.Before = func(context *cli.Context) error {
logrus.SetFormatter(&logrus.JSONFormatter{})
logrus.SetOutput(os.Stdout)
return nil
}
if err := app.Run(os.Args); err != nil {
logrus.Fatal(err)
}
}
复制
go run . run -it stress -m 100m --vm-bytes 200m --vm-keep -m 1
效果如下:
不过这个运行方式不能进行交互，我们可以使用这个命令来验证我们写的 docker 是否与宿主机隔离:
复制
go run . run -it /bin/sh
可以看到，pid，ipc，network 方面都与宿主机进行了隔离.
因为电脑硬盘空间不太够，就不使用虚拟机来做实验了，笔者这里使用 WSL2 来完成后续工作，然而，WSL2 Kernel 没有把 aufs 编译进去，那只能换内核了，查阅资料，有两种更换内核的方法:
直接替换 C:\System32\lxss\tools\kernel 文件 。
在 users 目录下新建 .wslconfig 文件:
复制
[wsl2]
kernel="要替换kernel的路径"
很明显，我是不会满足于使用别人编译好的内核的，那我也来动手做一个.
我们先在 WSL 上准备好相关软件包:
复制
apt update #更新源
apt install build-essential flex bison libssl-dev libelf-dev gcc make
编译内核需要从 GitHub 上 clone 微软官方的 WSL 代码和 AUFS-Standalone 的代码库 。
复制
git clone https://github.com/microsoft/WSL2-Linux-Kernel kernel
git clone https://github.com/sfjro/aufs-standalone aufs5
然后查看 WSL 内核版本：在 wsl 下运行命令 uname -r 。
例如我的内核版本是 5.15.19，那 kernel 和 aufs 都要切换到相应的分支去 (kernel 默认就是 5.15.19，故不用切换) 。
复制
cd aufs5
git checkout aufs5.15.36
然后退回到 kernel 文件夹给代码打补丁:
复制
cat ../aufs5/aufs5-mmap.patch | patch -p1
cat ../aufs5/aufs5-base.patch | patch -p1
cat ../aufs5/aufs5-kbuild.patch | patch -p1
三个 Patch 的顺序无关.
然后再复制一点配置文件:
复制
cp ../aufs5/Documentation . -r
cp ../aufs5/fs/ . -r
cp ../aufs5/include/uapi/linux/aufs_type.h ./include/uapi/linux
接下来我们来修改一下编译配置，在 Microsoft/config-wsl 中任意位置增加一行:
复制
CONFIG_AUFS_FS=y
最后，就可以开始编译了！ 。
复制
make KCONFIG_CONFIG=Microsoft/config-wsl -j8
过程中会问你一些问题，我除了 AUFS Debug 都选了 y.
最后会在当前目录生成 vmlinuz ，在 arch/x86/boot 下生成 bzImage .
关闭 WSL 后更换内核，重启 WSL 输入 grep aufs /proc/filesystems 验证结果，如果出现 aufs 的字样，说明操作成功.
先在 docker 获取 busybox 镜像并打包成一个 tar 包:
复制
docker pull busybox
docker run -d busybox top -b
docker export -o busybox.tar <container_id>
将其复制到 WSL 下并解压.
pivot_root 是一个系统调用，作用是改变当前 root 文件系统。pivot_root 可以将当前进程的 root 文件系统移动到 put_old 文件夹，然后使 new_root 成为新的 root 文件系统.
复制
func pivotRoot(root string) error {
// remount the root dir, in order to make current root and old root in different file systems
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)
}
// create 'rootfs/.pivot_root' to store old_root
pivotDir := filepath.Join(root, ".pivot_root")
if err := os.Mkdir(pivotDir, 0777); err != nil {
return err
}
// pivot_root mount on new rootfs, old_root mount on rootfs/.pivot_root
if err := syscall.PivotRoot(root, pivotDir); err != nil {
return fmt.Errorf("pivot_root %v", err)
}
// change current work dir to root dir
if err := syscall.Chdir("/"); err != nil {
return fmt.Errorf("chdir / %v", err)
}
pivotDir = filepath.Join("/", ".pivot_root")
// umount rootfs/.rootfs_root
if err := syscall.Unmount(pivotDir, syscall.MNT_DETACH); err != nil {
return fmt.Errorf("umount pivot_root dir %v", err)
}
// del the temporary dir
return os.Remove(pivotDir)
}
有了这个函数就可以在 init 容器进程时，进行一系列的 mount 操作:
复制
func setUpMount() error {
// get current path
pwd, err := os.Getwd()
if err != nil {
logrus.Errorf("get current location error: %v", err)
return err
}
logrus.Infof("current location: %v", pwd)
pivotRoot(pwd)
// mount proc
defaultMountFlags := syscall.MS_NOEXEC | syscall.MS_NOSUID | syscall.MS_NODEV
if err := syscall.Mount("proc", "/proc", "proc", uintptr(defaultMountFlags), ""); err != nil {
logrus.Errorf("mount /proc failed: %v", err)
return err
}
if err := syscall.Mount("tmpfs", "/dev", "tmpfs", syscall.MS_NOSUID|syscall.MS_STRICTATIME, "mode=755"); err != nil {
logrus.Errorf("mount /dev failed: %v", err)
return err
}
return nil
}
tmpfs 是一种基于内存的文件系统，用 RAM 或 swap 分区来存储.
在 NewParentProcess() 中加一句 cmd.Dir="/root/busybox" .
写完上述函数，然后在 initProcess() 中调用一下:
复制
if err := setUpMount(); err != nil {
logrus.Errorf("initProcess look path failed: %v", err)
}
然后来运行测试一下:
复制
root@Jayden: ~# go run . run -it sh
###### dividing live
{"level":"info","msg":"Start initiating...","time":"2023-05-04T11:27:04+08:00"}
{"level":"info","msg":"whole init command is: sh","time":"2023-05-04T11:27:04+08:00"}
{"level":"info","msg":"current location: /root/busybox","time":"2023-05-04T11:27:04+08:00"}
{"level":"info","msg":"Find path: /bin/sh","time":"2023-05-04T11:27:04+08:00"}
/ #
可以看到，容器当前目录被虚拟定位到了根目录，其实是在宿主机上映射的 /root/busybox .
前面提到了，docker 使用 AUFS 存储镜像和容器。docker 在使用镜像启动一个容器时，会新建 2 个 layer：write layer 和 container-init-layer。write layer 是容器唯一的可读写层，container-init-layer 是为容器新建的只读层，用来存储容器启动时传入的系统信息.
CreateReadOnlyLayer() 新建 busybox 文件夹，解压 busybox.tar 到 busybox 目录下，作为容器只读层。 CreateWriteLayer() 新建一个 writeLayer 文件夹，作为容器唯一可写层。 CreateMountPoint() 先创建了 mnt 文件夹作为挂载点，再把 writeLayer 目录和 busybox 目录 mount 到 mnt 目录下。
复制
// extra tar to 'busybox', used as the read only layer for container
func CreateReadOnlyLayer(rootURL string) {
busyboxURL := rootURL + "busybox/"
busyboxTarURL := rootURL + "busybox.tar"
exist, err := PathExists(busyboxURL)
if err != nil {
logrus.Infof("fail to judge whether dir %s exists. %v", busyboxURL, err)
}
if !exist {
if err := os.Mkdir(busyboxURL, 0777); err != nil {
logrus.Errorf("mkdir dir %s error. %v", busyboxURL, err)
}
if _, err := exec.Command("tar", "-xvf", busyboxTarURL, "-C", busyboxURL).CombinedOutput(); err != nil {
logrus.Errorf("unTar dir %s error %v", busyboxTarURL, err)
}
}
}
// create a unique folder as writeLayer
func CreateWriteLayer(rootURL string) {
writeURL := rootURL + "writeLayer/"
if err := os.Mkdir(writeURL, 0777); err != nil {
logrus.Errorf("mkdir dir %s error %v", writeURL, err)
}
}
func CreateMountPoint(rootURL string, mntURL string) {
// create mnt folder as mount point
if err := os.Mkdir(mntURL, 0777); err != nil {
logrus.Errorf("mkdir dir %s error %v", mntURL, err)
}
// mount 'writeLayer' and 'busybox' to 'mnt'
dirs := "dirs=" + rootURL + "writeLayer:" + rootURL + "busybox"
cmd := exec.Command("mount", "-t", "aufs", "-o", dirs, "none", mntURL)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if err := cmd.Run(); err != nil {
logrus.Errorf("%v", err)
}
}
func NewWorkSpace(rootURL, mntURL string) {
CreateReadOnlyLayer(rootURL)
CreateWriteLayer(rootURL)
CreateMountPoint(rootURL, mntURL)
}
接下来在 NewParentProcess() 将容器使用的宿主机目录 /root/busybox 替换为 /root/mnt ，这样使用 AUFS 系统启动容器的代码就完成了.
复制
cmd.ExtraFiles = []*os.File{readPipe}
mntURL := "/root/mnt/"
rootURL := "/root/"
NewWorkSpace(rootURL, mntURL)
cmd.Dir = mntURL
return cmd, writePipe
docker 会在删除容器时，把容器对应的 write layer 和 container-init-layer 删除，而保留镜像中所有的内容.
DeleteMountPoint() 中 umount mnt 目录。 mnt 目录。 DeleteWriteLayer() 删除 writeLayer 文件夹。
复制
func DeleteMountPoint(rootURL string, mntURL string) {
cmd := exec.Command(rootURL, mntURL)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if err := cmd.Run(); err != nil {
logrus.Errorf("%v", err)
}
if err := os.RemoveAll(mntURL); err != nil {
logrus.Errorf("remove dir %s error %v", mntURL, err)
}
}
func DeleteWriteLayer(rootURL string) {
writeURL := rootURL + "writeLayer/"
if err := os.RemoveAll(writeURL); err != nil {
logrus.Errorf("remove dir %s error %v", writeURL, err)
}
}
func DeleteWorkSpace(rootURL, mntURL string) {
DeleteMountPoint(rootURL, mntURL)
DeleteWriteLayer(rootURL)
}
现在来启动一个容器测试:
复制
root@Jayden: ~# go run . run -it sh
dirs=/root/writeLayer:/root/busybox
{"level":"info","msg":"Start initiating...","time":"2023-05-04T15:16:43+08:00"}
{"level":"info","msg":"whole init command is: sh","time":"2023-05-04T15:16:43+08:00"}
{"level":"info","msg":"current location: /root/mnt","time":"2023-05-04T15:16:43+08:00"}
{"level":"info","msg":"Find path: /bin/sh","time":"2023-05-04T15:16:43+08:00"}
/ #
测试在容器内创建文件:
复制
/ # mkdir aaa
/ # touch aaa/test.txt
此时我们可以在宿主机终端查看 /root/mnt/writeLayer ，可以看到刚才新建的 aaa 文件夹和 test.txt ，在我们退出容器后， /root/mnt 文件夹被删除，伴随着刚才创建的文件夹和文件都被删除，而作为镜像的 busybox 仍被保留，且内容未被修改.
上节实现了容器和镜像的分离，但是如果容器退出，容器可写层的所有内容就会被删除，这里使用 volume 来实现容器数据持久化.
先在 command.go 里添加 -v 标签:
复制
var RunCommand = cli.Command{
Name: "run",
Usage: "Create a container",
Flags: []cli.Flag{
// integrate -i and -t for convenience
&cli.BoolFlag{
Name: "it",
Usage: "open an interactive tty(pseudo terminal)",
},
&cli.StringFlag{
Name: "m",
Usage: "limit the memory",
}, &cli.StringFlag{
Name: "cpu",
Usage: "limit the cpu amount",
}, &cli.StringFlag{
Name: "cpushare",
Usage: "limit the cpu share",
},
// add `-v` tag
&cli.StringFlag{
Name: "v",
Usage: "volume",
},
},
Action: func(context *cli.Context) error {
args := context.Args()
if len(args) <= 0 {
return errors.New("run what?")
}
// 转化 cli.Args 为 []string
cmdArray := make([]string, len(args)) // command
copy(cmdArray, args)
// check whether type `-it`
tty := context.Bool("it") // presudo terminal
// get the resource config
resourceConfig := subsystem.ResourceConfig{
MemoryLimit: context.String("m"),
CPUShare: context.String("cpushare"),
CPUSet: context.String("cpu"),
}
// send volume args to Run()
volume := context.String("v")
dockerCommand.Run(tty, cmdArray, &resourceConfig,volume)
return nil
},
}
在 Run() 中，把 volume 传给创建容器的 NewParentProcess() 和删除容器文件系统的 DeleteWorkSpace() :
复制
func Run(tty bool, cmdArray []string, res *subsystem.ResourceConfig, volume string) {
// this is "docker init <cmdArray>"
initProcess, writePipe := container.NewParentProcess(tty, volume)
if initProcess == nil {
logrus.Errorf("new parent process error")
return
}
// start the init process
if err := initProcess.Start(); err != nil {
logrus.Error(err)
}
// create container manager to control resource config on all hierarchies
cm := cgroup.NewCgroupManager("simple-docker-container")
defer cm.Remove()
cm.Set(res)
cm.AddProcess(initProcess.Process.Pid)
// send command to write side
// will close the plug
sendInitCommand(cmdArray, writePipe)
initProcess.Wait()
rootURL := "/root/"
mntURL := "/root/mnt/"
container.DeleteWorkSpace(rootURL, mntURL, volume)
os.Exit(0)
}
在 NewWorkSpace() 中，继续把 volume 传给创建容器文件系统的 NewWorkSapce() .
创建容器文件系统过程如下:
volumeURLExtract() 解析。 volumeURLExtract() 返回字符数组长度为 2，且数据元素均不为空时，则执行 MountVolume() 来挂载数据卷。
复制
func NewWorkSpace(rootURL, mntURL, volume string) {
CreateReadOnlyLayer(rootURL)
CreateWriteLayer(rootURL)
CreateMountPoint(rootURL, mntURL)
if volume != "" {
volumeURLs := volumeUrlExtract(volume)
length := len(volumeURLs)
if length == 2 && volumeURLs[0] != "" && volumeURLs[1] != "" {
MountVolume(rootURL, mntURL, volumeURLs)
logrus.Infof("%q", volumeURLs)
} else {
logrus.Infof("volume parameter input is not correct")
}
}
}
func volumeUrlExtract(volume string) []string {
// divide volume by ":"
return strings.Split(volume, ":")
}
挂载数据卷过程如下:
/root/${parentURL} ) /root/mnt/${containerURL} )
复制
func MountVolume(rootURL, mntURL string, volumeURLs []string) {
// create host file catalog
parentURL := volumeURLs[0]
if err := os.Mkdir(parentURL, 0777); err != nil {
logrus.Infof("mkdir parent dir %s error. %v", parentURL, err)
}
// create mount point in container file system
containerURL := volumeURLs[1]
containerVolumeURL := mntURL + containerURL
if err := os.Mkdir(containerVolumeURL, 0777); err != nil {
logrus.Infof("mkdir container dir %s error. %v", containerVolumeURL, err)
}
// mount host file catalog to mount point in container
dirs := "dirs=" + parentURL
cmd := exec.Command("mount", "-t", "aufs", "-o", dirs, "none", containerVolumeURL)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if err := cmd.Run(); err != nil {
logrus.Errorf("mount volume failed. %v", err)
}
}
删除容器文件系统过程如下:
volumeURLExtract() 解析 volume 字符串返回的字符数组长度为 2，数据元素均不为空时，才执行 DeleteMountPointWithVolume() 来处理。 DeleteMountPoint() 。
复制
func DeleteWorkSpace(rootURL, mntURL, volume string) {
if volume != "" {
volumeURLs := volumeUrlExtract(volume)
length := len(volumeURLs)
if length == 2 && volumeURLs[0] != "" && volumeURLs[1] != "" {
DeleteMountPointWithVolume(rootURL, mntURL, volumeURLs)
} else {
DeleteMountPoint(rootURL, mntURL)
}
} else {
DeleteMountPoint(rootURL, mntURL)
}
DeleteWriteLayer(rootURL)
}
DeleteMountPointWithVolume() 处理逻辑如下:
/root/mnt/${containerURL} )，保证整个容器挂载点没有再被使用。 /root/mnt )。
复制
func DeleteMountPointWithVolume(rootURL, mntURL string, volumeURLs []string) {
// umount volume point in container
containerURL := mntURL + volumeURLs[1]
cmd := exec.Command("umount", containerURL)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if err := cmd.Run(); err != nil {
logrus.Errorf("umount volume failed. %v", err)
}
// umount the whole point of the container
cmd = exec.Command("umount", mntURL)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if err := cmd.Run(); err != nil {
logrus.Errorf("umount mountpoint failed. %v", err)
}
if err := os.RemoveAll(mntURL); err != nil {
logrus.Infof("remove mountpoint dir %s error %v", mntURL, err)
}
}
接下来启动容器测试:
复制
# go run . run -it -v /root/volume:/containerVolume sh
{"level":"info","msg":"[\"/root/volume\" \"/containerVolume\"]","time":"2023-05-05T09:25:43+08:00"}
{"level":"info","msg":"whole init command is: sh","time":"2023-05-05T09:25:43+08:00"}
{"level":"info","msg":"Start initiating...","time":"2023-05-05T09:25:43+08:00"}
{"level":"info","msg":"current location: /root/mnt","time":"2023-05-05T09:25:43+08:00"}
{"level":"info","msg":"Find path: /bin/sh","time":"2023-05-05T09:25:43+08:00"}
/ # ls
bin dev home lib64 root tmp var
containerVolume etc lib proc sys usr
/ #
进入 containerVolume ，创建一个 文本文件，并随便写点东西:
复制
cd containerVolume
echo -e "test" >> test.txt
此时我们能在宿主机的 /root/volume 找到我们刚才创建的文本文件。退出容器后，volume 文件夹也没有被删除。再次进入容器:
复制
r# go run . run -it -v /root/volume:/containerVolume sh
{"level":"info","msg":"mkdir parent dir /root/volume error. mkdir /root/volume: file exists","time":"2023-05-05T09:29:24+08:00"}
{"level":"info","msg":"[\"/root/volume\" \"/containerVolume\"]","time":"2023-05-05T09:29:24+08:00"}
{"level":"info","msg":"whole init command is: sh","time":"2023-05-05T09:29:24+08:00"}
{"level":"info","msg":"Start initiating...","time":"2023-05-05T09:29:24+08:00"}
{"level":"info","msg":"current location: /root/mnt","time":"2023-05-05T09:29:24+08:00"}
{"level":"info","msg":"Find path: /bin/sh","time":"2023-05-05T09:29:24+08:00"}
/ # ls
bin dev home lib64 root tmp var
containerVolume etc lib proc sys usr
/ # ls containerVolume/
test.txt
此时这里会提示 volume 文件夹存在，我们在 test.txt 内追加内容:
复制
cd containerVolume
echo -e "###" >> test.txt
此时再次退出容器，能看到修改过后的文件内容，可以看到 volume 文件夹没有被删除.
容器在退出时会删除所有可写层的内容，commit 命令可以把运行状态容器的内容存储为镜像保存下来.
在 main.go 里添加 commit 命令:
复制
app.Commands = []cli.Command{
InitCommand,
RunCommand,
CommitCommand,
}
然后在 command.go 里实现 CommitCommand 命令:
复制
var CommitCommand = cli.Command{
Name: "commit",
Usage: "commit a container into image",
Action: func(context *cli.Context) error {
if len(context.Args()) < 1 {
return fmt.Errorf("missing container name")
}
imageName := context.Args()[0]
// commitContainer(containerName)
commitContainer(imageName)
return nil
},
}
添加 commit.go ，通过 commitContainer() 实现将容器文件系统打包成 ${imagename}.tar .
复制
package main
import (
"os/exec"
"github.com/sirupsen/logrus"
)
func commitContainer(imageName string) {
mntURL := "/root/mnt"
imageTar := "/root/" + imageName + ".tar"
if _, err := exec.Command("tar", "-czf", imageTar, "-C", mntURL, ".").CombinedOutput(); err != nil {
logrus.Errorf("tar folder %s error %v", mntURL, err)
}
}
运行测试:
复制
# go run . run -it sh
然后在另一个终端运行:
复制
# go run . commit image
这时候可以在 root 目录下看到多了一个 image.tar ，解压后可以发现压缩包的内容和 /root/mnt 一致.
tips：一定要先运行容器！如果不运行容器直接打包，会提示 /root/mnt 不存在.
容器，放在操作系统层面，就是一个进程，当前运行命令的 simple-docker 是主进程，容器是当前 simple-docker 进程 fork 出来的子进程。子进程的结束和父进程的运行是一个异步的过程，即父进程不会知道子进程在什么时候结束。如果创建子进程时，父进程退出，那这个子进程就是孤儿进程 (没人管)，此时进程号为 1 的进程 init 就会接受这些孤儿进程.
先在 command.go 添加 -d 标签，表示这个容器启动时在后台运行:
复制
var RunCommand = cli.Command{
Name: "run",
Usage: "Create a container",
Flags: []cli.Flag{
// integrate -i and -t for convenience
&cli.BoolFlag{
Name: "it",
Usage: "open an interactive tty(pseudo terminal)",
},
&cli.StringFlag{
Name: "m",
Usage: "limit the memory",
}, &cli.StringFlag{
Name: "cpu",
Usage: "limit the cpu amount",
}, &cli.StringFlag{
Name: "cpushare",
Usage: "limit the cpu share",
}, &cli.StringFlag{
Name: "v",
Usage: "volume",
}, &cli.BoolFlag{
Name: "d",
Usage :"detach container",
}, &cli.StringFlag{
Name: "cpuset",
Usage: "limit the cpuset",
},
},
Action: func(context *cli.Context) error {
args := context.Args()
if len(args) <= 0 {
return errors.New("run what?")
}
// 转化 cli.Args 为 []string
cmdArray := make([]string, len(args)) // command
copy(cmdArray, args)
// check whether type `-it`
tty := context.Bool("it") // presudo terminal
detach := context.Bool("d") // detach container
// tty cannot work with detach
if tty && detach {
return fmt.Errorf("it and d paramter cannot both privided")
}
// get the resource config
resourceConfig := subsystem.ResourceConfig{
MemoryLimit: context.String("m"),
CPUShare: context.String("cpushare"),
CPUSet: context.String("cpu"),
}
volume := context.String("v")
dockerCommand.Run(tty, cmdArray, &resourceConfig, volume)
return nil
},
}
然后也要修改一下 run.go 的 Run() :
复制
func Run(tty bool, cmdArray []string, res *subsystem.ResourceConfig, volume string) {
// this is "docker init <cmdArray>"
initProcess, writePipe := container.NewParentProcess(tty, volume)
if initProcess == nil {
logrus.Errorf("new parent process error")
return
}
// start the init process
if err := initProcess.Start(); err != nil {
logrus.Error(err)
}
// create container manager to control resource config on all hierarchies
cm := cgroup.NewCgroupManager("simple-docker-container")
defer cm.Remove()
cm.Set(res)
cm.AddProcess(initProcess.Process.Pid)
// send command to write side
// will close the plug
sendInitCommand(cmdArray, writePipe)
// if background process, parent process won't wait
if tty {
initProcess.Wait()
}
rootURL := "/root/"
mntURL := "/root/mnt/"
container.DeleteWorkSpace(rootURL, mntURL, volume)
os.Exit(0)
}
测试一下:
复制
# go run . run -d top
{"level":"info","msg":"whole init command is: top","time":"2023-05-05T15:32:44+08:00"}
根据书上的提示， ps -ef 用来查找 top 进程:
复制
# ps -ef | grep top
root 3713 751 0 14:42 pts/2 00:00:00 top
前面几次运行命令，都找不到 top 这个进程，于是我后面多跑了几次，终于看到了这个进程。。.
可以看到，top 命令的进程正在运行着，不过运行环境是 WSL，父进程 id 不是 1，然后 ps -ef 查看一下，top 的父进程是一个 bash 进程，而 bash 进程的父进程是一个 init 进程，这样应该算过了吧 (偶尔的一两次不严谨).
前面创建的容器里，所有关于容器的信息，例如 PID、容器创建时间、容器运行命令等，都没有记录，这导致容器运行完后就在也不知道它的信息了，因此要把这部分信息保留。先在 command.go 里加一个 name 标签，方便用户指定容器的名字:
复制
var RunCommand = cli.Command{
Name: "run",
Usage: "Create a container",
Flags: []cli.Flag{
// integrate -i and -t for convenience
&cli.BoolFlag{
Name: "it",
Usage: "open an interactive tty(pseudo terminal)",
},
&cli.StringFlag{
Name: "m",
Usage: "limit the memory",
}, &cli.StringFlag{
Name: "cpu",
Usage: "limit the cpu amount",
}, &cli.StringFlag{
Name: "cpushare",
Usage: "limit the cpu share",
}, &cli.StringFlag{
Name: "v",
Usage: "volume",
}, &cli.BoolFlag{
Name: "d",
Usage :"detach container",
}, &cli.StringFlag{
Name: "cpuset",
Usage: "limit the cpuset",
}, &cli.StringFlag {
Name: "name",
Usage: "container name",
},
},
Action: func(context *cli.Context) error {
args := context.Args()
if len(args) <= 0 {
return errors.New("run what?")
}
// 转化 cli.Args 为 []string
cmdArray := make([]string, len(args)) // command
copy(cmdArray, args)
// check whether type `-it`
tty := context.Bool("it") // presudo terminal
detach := context.Bool("d") // detach container
if tty && detach {
return fmt.Errorf("it and d paramter cannot both privided")
}
// get the resource config
resourceConfig := subsystem.ResourceConfig{
MemoryLimit: context.String("m"),
CPUShare: context.String("cpushare"),
CPUSet: context.String("cpu"),
}
volume := context.String("v")
containerName := context.String("name")
dockerCommand.Run(tty, cmdArray, &resourceConfig, volume, containerName)
return nil
},
}
添加一个方法来记录容器的相关信息，这里用先用一个 10 位的数字来表示容器的 id:
复制
func randStringBytes(n int) string {
letterBytes := "1234567890"
rand.Seed(time.Now().UnixNano())
b := make([]byte, n)
for i := range b {
b[i] = letterBytes[rand.Intn(len(letterBytes))]
}
return string(b)
}
这里用时间戳为种子，每次生成一个 10 以内的数字作为 letterBytes 数组的下标，最后拼成整个容器的 id。容器的信息默认保存在 /var/run/simple-docker/${containerName}/config.json ，容器基本格式如下:
复制
type ContainerInfo struct {
Pid string `json:"pid"`
Id string `json:"id"`
Name string `json:"name"`
Command string `json:"command"` // the command that init process execute
CreatedTime string `json:"created_time"`
Status string `json:"status"`
}
var (
RUNNING string = "running"
STOP string = "stopped"
Exit string = "exited"
DefaultInfoLocation string = "/var/run/simple-docker/%s"
ConfigName string = "config.json"
)
下面是记录容器信息:
复制
func recordContainerInfo(containerPID int, commandArray []string, containerName string) (string, error) {
// create an ID that length is 10
id := randStringBytes(10)
createTime := time.Now().Format("2006-01-02 15:04:05") // format must like this
command := strings.Join(commandArray, "")
// if containerName is nil, make containerID as name
if containerName == "" {
containerName = id
}
containerInfo := &container.ContainerInfo{
Id: id,
Pid: strconv.Itoa(containerPID),
Command: command,
CreatedTime: createTime,
Status: container.RUNNING,
Name: containerName,
}
// trun containerInfo info string
jsonBytes, err := json.Marshal(containerInfo)
if err != nil {
logrus.Errorf("record container info error: %v", err)
return "", err
}
jsonStr := string(jsonBytes)
// container path
dirURL := fmt.Sprintf(container.DefaultInfoLocation, containerName)
if err := os.MkdirAll(dirURL, 0622); err != nil {
logrus.Errorf("mkdir error %s error: %v", dirURL, err)
return "", err
}
fileName := dirURL + "/" + container.ConfigName
// create config.json
file, err := os.Create(fileName)
if err != nil {
logrus.Errorf("create %s error %v", fileName, err)
return "", err
}
defer file.Close()
// write jsonify data to file
if _, err := file.WriteString(jsonStr); err != nil {
logrus.Errorf("write %s error %v", fileName, err)
return "", err
}
return containerName, nil
}
这里格式化的时间必须是 2006-01-02 15:04:05 ，不然格式化后的时间会是几千年后 doge.
详细可以看这篇文章： goland时间格式化time.Now().Format_golang time.now().format_好狗不见的博客-CSDN博客 。
在主函数加上调用:
复制
func Run(tty bool, cmdArray []string, res *subsystem.ResourceConfig, volume, containerName string) {
// this is "docker init <cmdArray>"
initProcess, writePipe := container.NewParentProcess(tty, volume)
if initProcess == nil {
logrus.Errorf("new parent process error")
return
}
// start the init process
if err := initProcess.Start(); err != nil {
logrus.Error(err)
}
// container info
containerName, err := recordContainerInfo(initProcess.Process.Pid, cmdArray, containerName)
if err != nil {
logrus.Errorf("record container info error: %v", err)
return
}
// create container manager to control resource config on all hierarchies
cm := cgroup.NewCgroupManager("simple-docker-container")
defer cm.Remove()
cm.Set(res)
cm.AddProcess(initProcess.Process.Pid)
// send command to write side
// will close the plug
sendInitCommand(cmdArray, writePipe)
if tty {
initProcess.Wait()
deleteContainerInfo(containerName)
}
rootURL := "/root/"
mntURL := "/root/mnt/"
container.DeleteWorkSpace(rootURL, mntURL, volume)
os.Exit(0)
}
如果创建 tty 方式的容器，在容器退出后，就会删除相关信息:
复制
func deleteContainerInfo(containerID string) {
dirURL := fmt.Sprintf(container.DefaultInfoLocation, containerID)
if err := os.RemoveAll(dirURL); err != nil {
logrus.Errorf("remove dir %s error %v", dirURL, err)
}
}
测试一下:
复制
# go run . run -d top
# go run . run -d --name jay top
执行完成后，可以在 /var/run/simple-docker/ 找到两个文件夹，一个是随机 id，一个是 jay，文件夹下各有一个 config.json ，记录了容器的相关信息.
在 main.go 加一个 listCommand :
复制
app.Commands = []cli.Command{
RunCommand,
InitCommand,
CommitCommand,
ListCommand,
}
在 command.go 添加定义:
复制
var ListCommand = cli.Command{
Name: "ps",
Usage: "list all the containers",
Action: func(context *cli.Context) error {
ListContainers()
return nil
},
}
新建一个 list.go ，实现记录列出容器信息:
复制
func ListContainers() {
// get the path that store the info of the container
dirURL := fmt.Sprintf(container.DefaultInfoLocation, "")
dirURL = dirURL[:len(dirURL)-1]
// read all the files in the directory
files, err := ioutil.ReadDir(dirURL)
if err != nil {
logrus.Errorf("read dir %s error %v", dirURL, err)
return
}
var containers []*container.ContainerInfo
for _, file := range files {
tmpContainer, err := getContainerInfo(file)
// .Println(tmpContainer)
if err != nil {
logrus.Errorf("get container info error %v", err)
continue
}
containers = append(containers, tmpContainer)
}
// use tabwriter.NewWriter to print the containerInfo
w := tabwriter.NewWriter(os.Stdout, 12, 1, 3, ' ', 0)
fmt.Fprintf(w, "ID\tNAME\tPID\tSTATUS\tCOMMAND\tCREATED\n")
for _, item := range containers {
fmt.Fprintf(w, "%s\t%s\t%s\t%s\t%s\t%s\n",
item.Id, item.Name, item.Pid, item.Status, item.Command, item.CreatedTime)
}
// refresh stdout
if err := w.Flush(); err != nil {
logrus.Errorf("flush stdout error %v",err)
return
}
}
func getContainerInfo(file os.FileInfo) (*container.ContainerInfo, error) {
containerName := file.Name()
// create the absolute path
configFileDir := fmt.Sprintf(container.DefaultInfoLocation, containerName)
configFileDir = configFileDir + "/" + container.ConfigName
// read config.json
content, err := ioutil.ReadFile(configFileDir)
if err != nil {
logrus.Errorf("read file %s error %v", configFileDir, err)
return nil, err
}
var containerInfo container.ContainerInfo
// turn json to containerInfo
if err := json.Unmarshal(content, &containerInfo); err != nil {
logrus.Errorf("unmarshal json error %v", err)
return nil, err
}
return &containerInfo, nil
}
接上小节的测试，我们运行以下命令:
复制
# go run . run -d top
{"level":"info","msg":"whole init command is: top","time":"2023-05-05T19:29:11+08:00"}
# go run . run -d --name jay top
{"level":"info","msg":"whole init command is: top","time":"2023-05-05T19:29:25+08:00"}
# go run . ps
ID NAME PID STATUS COMMAND CREATED
6675792962 6675792962 4317 running top 2023-05-05 19:29:11
5553437308 jay 4404 running top 2023-05-05 19:29:25
现在就可以通过 ps 来看到所有创建的容器状态和它们的 init 进程 id 了.
在 main.go 加一个 logCommand :
复制
app.Commands = []cli.Command{
RunCommand,
InitCommand,
CommitCommand,
ListCommand,
LogCommand,
}
然后在 command.go 里添加 logCommand :
复制
var LogCommand = cli.Command{
Name: "logs",
Usage: "print logs of a container",
Action: func(context *cli.Context) error {
if len(context.Args()) < 1 {
return fmt.Errorf("missing container name")
}
contianerName := context.Args()[0]
logContainer(contianerName)
return nil
},
}
新建一个 log.go ，定义 logContainer() :
复制
func logContainer(containerName string) {
// get the log path
dirURL := fmt.Sprintf(container.DefaultInfoLocation, containerName)
logFileLocation := dirURL + "/" + container.ContainerLogFile
// open log file
file, err := os.Open(logFileLocation)
if err != nil {
logrus.Errorf("log container open file %s error: %v", logFileLocation, err)
return
}
defer file.Close()
// read log file content
content, err := ioutil.ReadAll(file)
if err != nil {
logrus.Errorf("log container read file %s error: %v", logFileLocation, err)
return
}
// use Fprint to transfer content to stdout
fmt.Fprint(os.Stdout, string(content))
}
测试一下，先用 detach 方式创建一个容器:
复制
# go run . run -d --name jay top
{"level":"info","msg":"whole init command is: top","time":"2023-05-06T14:26:32+08:00"}
# go run . ps
ID NAME PID STATUS COMMAND CREATED
1837062451 jay 2065 running top 2023-05-06 14:26:32
# go run . logs jay
Mem: 3265116K used, 4568420K free, 3256K shrd, 71432K buff, 1135692K cached
CPU: 0.3% usr 0.2% sys 0.0% nic 99.3% idle 0.0% io 0.0% irq 0.0% sirq
Load average: 0.03 0.09 0.08 1/521 5
PID PPID USER STAT VSZ %VSZ CPU %CPU COMMAND
可以看到，logs 命令成功运行并输出容器的日志。(这里之前出现过前几次创建容器，而后台却没运行的情况，导致一开始运行 logs 时报错了，建议在运行 logs 前多检查下 top 是否后台运行中) 。
在 6.3 小节里，实现了查看后台运行的容器的日志，但是容器一旦创建后，就无法再次进入容器，这一次来实现进入容器内部的功能，也就是 exec.
setns 是一个系统调用，可根据提供的 PID 再次进入到指定的 Namespace。它要先打开 /proc/${pid}/ns 文件夹下对应的文件，然后使当前进程进入到指定的 Namespace 中。对于 go 来说，一个有多线程的进程使无法使用 setns 调用进入到对应的命名空间的，go 没启动一个程序就会进入多线程状态，因此无法简单在 go 里直接调用系统调用，这里还需要借助 C 来实现这个功能.
在 go 里写 C:
复制
package rand
/*
#include <stdlib.h>
*/
import "C"
func Random() int {
return int(C.random())
}
func Seed(i int) {
C.srandom(C.uint(i))
}
先使用 C 根据 PID进入对应 Namespace:
复制
package nsenter
/*
#define _GNU_SOURCE
#include <errno.h>
#include <sched.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
// if this package is quoted, this function will run automatic
__attribute__((constructor)) void enter_namespace(void)
{
char *simple_docker_pid;
// get pid from system environment
simple_docker_pid = getenv("simple_docker_pid");
if (simple_docker_pid)
{
fprintf(stdout, "got simple docker pid=%s\n", simple_docker_pid);
}
else
{
fprintf(stdout, "missing simple docker pid env skip nsenter");
// if no specified pid, the func will exit
return;
}
char *simple_docker_cmd;
simple_docker_cmd = getenv("simple_docker_cmd");
if (simple_docker_cmd)
{
fprintf(stdout, "got simple docker cmd=%s\n", simple_docker_cmd);
}
else
{
fprintf(stdout, "missing simple docker cmd env skip nsenter");
// if no specified cmd, the func will exit
return;
}
int i;
char nspath[1024];
char *namespace[] = {"ipc", "uts", "net", "pid", "mnt"};
for (i = 0; i < 5; i++)
{
// create the target path, like /proc/pid/ns/ipc
sprintf(nspath, "/proc/%s/ns/%s", simple_docker_pid, namespace[i]);
int fd = open(nspath, O_RDONLY);
printf("===== %d %s\n", fd, nspath);
// call sentns and enter the target namespace
if (setns(fd, 0) == -1)
{
fprintf(stderr, "setns on %s namespace failed: %s\n", namespace[i], strerror(errno));
}
else
{
fprintf(stdout, "setns on %s namespace succeeded\n", namespace[i]);
}
close(fd);
}
// run command in target namespace
int res = system(simple_docker_cmd);
exit(0);
return;
}
*/
import "C"
那如何使用这段代码呢，只需要在要加载的地方引用这个 package 即可，我这里是 nenster .
其实也可以，单独放在一个 C 文件里，go 文件可以这样写:
复制
package nsenter
import "C"
下面增加 ExecCommand :
复制
var ExecCommand = cli.Command{
Name: "exec",
Usage: "exec a command into container",
Action: func(context *cli.Context) error {
if os.Getenv(ENV_EXEC_PID) != "" {
logrus.Infof("pid callback pid %v", os.Getgid())
return nil
}
if len(context.Args()) < 2 {
return fmt.Errorf("missing container name or command")
}
containerName := context.Args()[0]
cmdArray := make([]string, len(context.Args())-1)
for i, v := range context.Args().Tail() {
cmdArray[i] = v
}
ExecContainer(containerName, cmdArray)
return nil
},
}
新建一个 exec.go 下面实现获取容器名和需要的命令，并且在这里引用 nsenter :
复制
const ENV_EXEC_PID = "simple_docker_pid"
const ENV_EXEC_CMD = "simple_docker_cmd"
func getContainerPidByName(containerName string) (string, error) {
// get the path that store container info
dirURL := fmt.Sprintf(container.DefaultInfoLocation, containerName)
configFilePath := dirURL + "/" + container.ConfigName
// read files in target path
contentBytes, err := ioutil.ReadFile(configFilePath)
if err != nil {
return "", err
}
var containerInfo container.ContainerInfo
// unmarshal json to containerInfo
if err := json.Unmarshal(contentBytes, &containerInfo); err != nil {
return "", err
}
return containerInfo.Pid, nil
}
func ExecContainer(containerName string, comArray []string) {
// get the pid according the containerName
pid, err := getContainerPidByName(containerName)
if err != nil {
logrus.Errorf("exec container getContainerPidByName %s error %v", containerName, err)
return
}
// divide command by blank space and combine as a string
cmdStr := strings.Join(comArray, " ")
logrus.Infof("container pid %s", pid)
logrus.Infof("command %s", cmdStr)
cmd := exec.Command("/proc/self/exe", "exec")
cmd.Stdin = os.Stdin
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
err = os.Setenv(ENV_EXEC_PID, pid)
if err != nil {
logrus.Errorf("set env exec pid %s error %v", pid, err)
}
err = os.Setenv(ENV_EXEC_CMD, cmdStr)
if err != nil {
logrus.Errorf("set env exec command %s error %v", cmdStr, err)
}
if err := cmd.Run(); err != nil {
logrus.Errorf("exec container %s error %v", containerName, err)
}
}
测试一下:
复制
# go run . run --name jay -d top
{"level":"info","msg":"whole init command is: top","time":"2023-05-07T13:23:09+08:00"}
# go run . ps
ID NAME PID STATUS COMMAND CREATED
6530018751 jay 146639 running top 2023-05-07 13:23:09
# go run . logs jay
Mem: 4355160K used, 3478372K free, 3272K shrd, 208844K buff, 1581396K cached
CPU: 1.2% usr 0.6% sys 0.0% nic 97.9% idle 0.0% io 0.0% irq 0.1% sirq
Load average: 0.12 0.14 0.16 1/574 6
PID PPID USER STAT VSZ %VSZ CPU %CPU COMMAND
# go run . exec jay sh
/ # ls
bin dev etc home lib lib64 proc root sys tmp usr var
/ # ps -ef
PID USER TIME COMMAND
1 root 0:00 top
13 root 0:00 sh
15 root 0:00 ps -ef
/ #
可以看到，成功进入容器内部，且与宿主机隔离.
这里出现了一个很奇怪的 bug，就是通过 cgo 去 setns，执行到 mnt 时，抛出个错误： Stale file handle ，当时找了全网，也找不到答案，于是陷入了两天的痛苦 debug，在重新敲代码时，发现又不报错了，切换回那个有错误的分支，也不报错了。既然暂时找不到错误，先搁着吧，如果有看到这篇文章的朋友，也遇到了这个错误，可以留意下。(感觉会是一个雷) 。
(应该是容器的 mnt 没有 mount 上去，才会导致 stale file handle) 。
定义 StopCommand :
复制
var StopCommand = cli.Command{
Name: "stop",
Usage: "stop a container",
Action: func(context *cli.Context) error {
if len(context.Args()) < 1 {
return fmt.Errorf("missing container name")
}
containerName := context.Args()[0]
stopContainer(containerName)
return nil
},
}
然后声明一个函数，通过容器名来获取容器信息:
复制
func getContainerInfoByName(containerName string) (*container.ContainerInfo, error) {
dirURL := fmt.Sprintf(container.DefaultInfoLocation, containerName)
configFilePath := dirURL + "/" + container.ConfigName
contentBytes, err := ioutil.ReadFile(configFilePath)
if err != nil {
logrus.Errorf("read config file %s error %v", configFilePath, err)
return nil, err
}
var containerInfo container.ContainerInfo
// unmarshal json to container info
if err := json.Unmarshal(contentBytes, &containerInfo); err != nil {
logrus.Errorf("unmarshal json to container info error %v", err)
return nil, err
}
return &containerInfo, nil
}
然后是停止容器:
复制
func stopContainer(containerName string) {
// get pid by containerName
pid, err := getContainerPidByName(containerName)
if err != nil {
logrus.Errorf("get container pid by name %s error %v", containerName, err)
return
}
// turn pid(string) to int
pidInt, err := strconv.Atoi(pid)
if err != nil {
logrus.Errorf("convert pid from string to int error %v", err)
return
}
// kill container main process
if err := syscall.Kill(pidInt, syscall.SIGTERM); err != nil {
logrus.Errorf("stop container %s error %v", containerName, err)
return
}
// get info of the container
containerInfo, err := getContainerInfoByName(containerName)
if err != nil {
logrus.Errorf("get container info by name %s error %v", containerName, err)
return
}
// process is killed, update process status
containerInfo.Status = container.STOP
containerInfo.Pid = " "
// update info to json
nweContentBytes, err := json.Marshal(containerInfo)
if err != nil {
logrus.Errorf("json marshal %s error %v", containerName, err)
return
}
dirURL := fmt.Sprintf(container.DefaultInfoLocation, containerName)
configFilePath := dirURL + "/" + container.ConfigName
// overwrite containerInfo
if err := ioutil.WriteFile(configFilePath, nweContentBytes, 0622); err != nil {
logrus.Errorf("write config file %s error %v", configFilePath, err)
}
}
测试:
复制
# go run . stop jay
# go run . ps
ID NAME PID STATUS COMMAND CREATED
6883605813 jay stopped top
# ps -ef | grep top
root 43588 761 0 20:00 pts/0 00:00:00 grep --color=auto top
可以看到，jay 这个进程被停止了，且 pid 号设为空.
定义 RemoveCommand :
复制
var RemoveCommand = cli.Command{
Name: "rm",
Usage: "remove a container",
Action: func(context *cli.Context) error {
if len(context.Args()) < 1 {
return fmt.Errorf("missing container name")
}
containerName := context.Args()[0]
removeContainer(containerName)
return nil
},
}
实现删除容器:
复制
func removeContainer(containerName string) {
containerInfo, err := getContainerInfoByName(containerName)
if err != nil {
logrus.Errorf("get container %s info failed: %v", containerName, err)
return
}
// only remove the stopped container
if containerInfo.Status != container.STOP {
logrus.Errorf("cannot remove running container %s", containerName)
return
}
dirURL := fmt.Sprintf(container.DefaultInfoLocation, containerName)
// remove all the info including sub dir
if err := os.RemoveAll(dirURL); err != nil {
logrus.Errorf("cannot remove dir %s error: %v", dirURL, err)
return
}
}
测试一下:
复制
# go run . rm jay
# go run . ps
ID NAME PID STATUS COMMAND CREATED
可以看到，jay 这个容器被删除了.
这一节，根据书上的内容，有许多函数需要改动。建议这里对着作者给出的源码 debug，书上有部分内容有明显错误.
之前的文件系统如下:
修改后的文件系统如下:
writeLayer/${containerName} mnt/${containerName} 因此，本节要实现为每个容器分配单独的隔离文件系统，以及实现对不同容器打包镜像.
修改 run.go 。
在 Run 函数参数列表添加一个 imageName :
复制
func Run(tty bool, cmdArray []string, res *subsystem.ResourceConfig, volume, containerName, imageName string) {
containerID := randStringBytes(10)
if containerName == "" {
containerName = containerID
}
// this is "docker init <cmdArray>"
initProcess, writePipe := container.NewParentProcess(tty, volume, containerName, imageName)
if initProcess == nil {
logrus.Errorf("new parent process error")
return
}
// start the init process
if err := initProcess.Start(); err != nil {
logrus.Error(err)
}
// container info
containerName, err := recordContainerInfo(initProcess.Process.Pid, cmdArray, containerName, volume)
if err != nil {
logrus.Errorf("record container info error: %v", err)
return
}
// create container manager to control resource config on all hierarchies
cm := cgroups.NewCgroupManager("simple-docker-container")
defer cm.Remove()
cm.Set(res)
cm.AddProcess(initProcess.Process.Pid)
// send command to write side
// will close the plug
sendInitCommand(cmdArray, writePipe)
if tty {
initProcess.Wait()
deleteContainerInfo(containerName)
container.DeleteWorkSpace(volume, containerName)
}
os.Exit(0)
}
同时也在 command.go 的 runCommand 里修改:
复制
Action: func(context *cli.Context) error {
args := context.Args()
if len(args) <= 0 {
return errors.New("run what?")
}
// 转化 cli.Args 为 []string
cmdArray := make([]string, len(args)) // command
copy(cmdArray, args)
// check whether type `-it`
tty := context.Bool("it") // presudo terminal
detach := context.Bool("d") // detach container
if tty && detach {
return fmt.Errorf("it and d paramter cannot both privided")
}
// get the resource config
resourceConfig := subsystem.ResourceConfig{
MemoryLimit: context.String("m"),
CPUShare: context.String("cpushare"),
CPUSet: context.String("cpu"),
}
volume := context.String("v")
containerName := context.String("name")
imageName := cmdArray[0]
cmdArray = cmdArray[1:]
Run(tty, cmdArray, &resourceConfig, volume, containerName, imageName)
return nil
},
在 recordContainerInfo 函数的参数列表添加 volume:
复制
func recordContainerInfo(containerPID int, commandArray []string, containerName, volume string) (string, error) {
// create an ID that length is 10
id := randStringBytes(10)
createTime := time.Now().Format("2006-01-02 15:04:05")
command := strings.Join(commandArray, "")
// if containerName is nil, make containerID as name
if containerName == "" {
containerName = id
}
containerInfo := &container.ContainerInfo{
Id: id,
Pid: strconv.Itoa(containerPID),
Command: command,
CreatedTime: createTime,
Status: container.RUNNING,
Name: containerName,
Volume: volume,
}
// trun containerInfo info string
jsonBytes, err := json.Marshal(containerInfo)
if err != nil {
logrus.Errorf("record container info error: %v", err)
return "", err
}
jsonStr := string(jsonBytes)
// container path
dirURL := fmt.Sprintf(container.DefaultInfoLocation, containerName)
if err := os.MkdirAll(dirURL, 0622); err != nil {
logrus.Errorf("mkdir error %s error: %v", dirURL, err)
return "", err
}
fileName := dirURL + "/" + container.ConfigName
// create config.json
file, err := os.Create(fileName)
if err != nil {
logrus.Errorf("create %s error %v", fileName, err)
return "", err
}
defer file.Close()
// write jsonify data to file
if _, err := file.WriteString(jsonStr); err != nil {
logrus.Errorf("write %s error %v", fileName, err)
return "", err
}
return containerName, nil
}
给 ContainerInfo 添加 Volume 成员:
复制
type ContainerInfo struct {
Pid string `json:"pid"` //容器的init进程在宿主机上的 PID
Id string `json:"id"` //容器Id
Name string `json:"name"` //容器名
Command string `json:"command"` //容器内init运行命令
CreatedTime string `json:"createTime"` //创建时间
Status string `json:"status"` //容器的状态
Volume string `json:"volume"`
}
然后将 RootURL ， MntURL ， WriteLayer 设为常量:
复制
var (
RUNNING string = "running"
STOP string = "stopped"
Exit string = "exited"
DefaultInfoLocation string = "/var/run/simple-docker/%s/"
ConfigName string = "config.json"
ContainerLogFile string = "container.log"
RootURL string = "/root/"
MntURL string = "/root/mnt/%s/"
WriteLayerURL string = "/root/writeLayer/%s"
)
相应地， NewParentProcess 函数也要修改:
复制
func NewParentProcess(tty bool, volume string, containerName, imageName string) (*exec.Cmd, *os.File) {
readPipe, writePipe, err := os.Pipe()
if err != nil {
logrus.Errorf("New Pipe Error: %v", err)
return nil, nil
}
// create a new command which run itself
// the first arguments is `init` which is in the "container/init.go" file
// so, the <cmd> will be interpret as "docker init <cmdArray>"
cmd := exec.Command("/proc/self/exe", "init")
cmd.SysProcAttr = &syscall.SysProcAttr{
Cloneflags: syscall.CLONE_NEWUTS | syscall.CLONE_NEWPID | syscall.CLONE_NEWNS |
syscall.CLONE_NEWNET | syscall.CLONE_NEWIPC,
}
cmd.Stdin = os.Stdin
if tty {
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
} else {
dirURL := fmt.Sprintf(DefaultInfoLocation, containerName)
if err := os.MkdirAll(dirURL, 0622); err != nil {
logrus.Errorf("NewParentProcess mkdir %s error %v", dirURL, err)
return nil, nil
}
stdLogFilePath := dirURL + ContainerLogFile
stdLogFile, err := os.Create(stdLogFilePath)
if err != nil {
logrus.Errorf("NewParentProcess create file %s error %v", stdLogFilePath, err)
return nil, nil
}
cmd.Stdout = stdLogFile
}
cmd.ExtraFiles = []*os.File{readPipe}
NewWorkSpace(volume, imageName, containerName)
cmd.Dir = fmt.Sprintf(MntURL, containerName)
return cmd, writePipe
}
NewWorkSpace 函数的三个参数分别改为： volume ， imageName ， containerName :
复制
func NewWorkSpace(volume, imageName, containerName string) {
CreateReadOnlyLayer(imageName)
CreateWriteLayer(containerName)
CreateMountPoint(containerName, imageName)
if volume != "" {
volumeURLs := volumeUrlExtract(volume)
length := len(volumeURLs)
if length == 2 && volumeURLs[0] != "" && volumeURLs[1] != "" {
MountVolume(volumeURLs, containerName)
logrus.Infof("%q", volumeURLs)
} else {
logrus.Infof("volume parameter input is not correct")
}
}
}
下面来修改 CreateReadOnlyLayer ， CreateWriteLayer ， CreateMountPoint 这三个函数:
首先是 CreateReadOnlyLayer ，参数名改为 imageName ，镜像解压出来的只读层以 RootURL+imageName 命名:
复制
func CreateReadOnlyLayer(imageName string) error {
unTarFolderURL := RootURL + "/" + imageName + "/"
imageURL := RootURL + "/" + imageName + ".tar"
exist, err := PathExists(unTarFolderURL)
if err != nil {
logrus.Infof("fail to judge whether dir %s exists. %v", unTarFolderURL, err)
return err
}
if !exist {
if err := os.MkdirAll(unTarFolderURL, 0777); err != nil {
logrus.Errorf("mkdir dir %s error. %v", unTarFolderURL, err)
return err
}
if _, err := exec.Command("tar", "-xvf", imageURL, "-C", unTarFolderURL).CombinedOutput(); err != nil {
logrus.Errorf("unTar dir %s error %v", unTarFolderURL, err)
return err
}
}
return nil
}
CreateWriteLayer 为每个容器创建一个读写层，把参数改为 containerName，容器读写层修改为 WriteLayerURL+containerName 命名:
复制
func CreateWriteLayer(containerName string) {
writeUrl := fmt.Sprintf(WriteLayerURL, containerName)
if err := os.MkdirAll(writeUrl, 0777); err != nil {
logrus.Infof("Mkdir write layer dir %s error. %v", writeUrl, err)
}
}
CreateMountPoint 创建容器根目录，然后把镜像只读层和容器读写层挂载到容器根目录，成为容器文件系统，参数列表改为 containerName 和 imageName :
复制
func CreateMountPoint(containerName, imageName string) error {
// create mnt folder as mount point
mntURL := fmt.Sprintf(MntURL, containerName)
if err := os.MkdirAll(mntURL, 0777); err != nil {
logrus.Errorf("mkdir dir %s error %v", mntURL, err)
return err
}
// mount 'writeLayer' and 'busybox' to 'mnt'
tmpWriteLayer := fmt.Sprintf(WriteLayerURL, containerName)
tmpImageLocation := RootURL + "/" + imageName
dirs := "dirs=" + tmpWriteLayer + ":" + tmpImageLocation
_, err := exec.Command("mount", "-t", "aufs", "-o", dirs, "none", mntURL).CombinedOutput()
if err != nil {
logrus.Errorf("run command for creating mount point failed: %v", err)
return err
}
return nil
}
MountVolume 根据用户输入的 volume 参数获取相应挂载宿主机数据卷 URL 和容器的挂载点 URL，并挂载数据卷。参数列表改为 volumeURLs 和 containerName :
复制
func MountVolume(volumeURLs []string, containerName string) error {
// create host file catalog
parentURL := volumeURLs[0]
if err := os.Mkdir(parentURL, 0777); err != nil {
logrus.Infof("mkdir parent dir %s error. %v", parentURL, err)
}
// create mount point in container file system
containerURL := volumeURLs[1]
mntURL := fmt.Sprintf(MntURL, containerName)
containerVolumeURL := mntURL + "/" + containerURL
if err := os.Mkdir(containerVolumeURL, 0777); err != nil {
logrus.Infof("mkdir container dir %s error. %v", containerVolumeURL, err)
}
// mount host file catalog to mount point in container
dirs := "dirs=" + parentURL
_, err := exec.Command("mount", "-t", "aufs", "-o", dirs, "none", containerVolumeURL).CombinedOutput()
if err != nil {
logrus.Errorf("mount volume failed. %v", err)
return err
}
return nil
}
然后在删除容器的 removeContainer 函数最后加一行 DeleteWorkSpace :
复制
func removeContainer(containerName string) {
containerInfo, err := getContainerInfoByName(containerName)
if err != nil {
logrus.Errorf("get container %s info failed: %v", containerName, err)
return
}
// only remove the stopped container
if containerInfo.Status != container.STOP {
logrus.Errorf("cannot remove running container %s", containerName)
return
}
dirURL := fmt.Sprintf(container.DefaultInfoLocation, containerName)
// remove all the info including sub dir
if err := os.RemoveAll(dirURL); err != nil {
logrus.Errorf("cannot remove dir %s error: %v", dirURL, err)
return
}
container.DeleteWorkSpace(containerInfo.Volume, containerName)
}
然后 DeleteWorkSpace 也要修改， DeleteWorkSpace 作用是当容器退出时，删除容器相关文件系统，参数列表改为 containerName 和 volume:
复制
func DeleteWorkSpace(volume, containerName string) {
if volume != "" {
volumeURLs := volumeUrlExtract(volume)
length := len(volumeURLs)
if length == 2 && volumeURLs[0] != "" && volumeURLs[1] != "" {
DeleteMountPointWithVolume(volumeURLs, containerName)
} else {
DeleteMountPoint(containerName)
}
} else {
DeleteMountPoint(containerName)
}
DeleteWriteLayer(containerName)
}
DeleteMountPoint 函数作用是删除未挂载数据卷的容器文件系统，参数修改为 containerName :
复制
func DeleteMountPoint(containerName string) error {
mntURL := fmt.Sprintf(MntURL, containerName)
_, err := exec.Command("umount", mntURL).CombinedOutput()
if err != nil {
logrus.Errorf("%v", err)
return err
}
if err := os.RemoveAll(mntURL); err != nil {
logrus.Errorf("remove dir %s error %v", mntURL, err)
return err
}
return nil
}
DeleteMountPointWithVolume 函数用来删除挂载数据卷容器的文件系统，参数列表改为 volumeURLs 和 containerName :
复制
func DeleteMountPointWithVolume(volumeURLs []string, containerName string) error {
// umount volume point in container
mntURL := fmt.Sprintf(MntURL, containerName)
containerURL := mntURL + "/" + volumeURLs[1]
if _, err := exec.Command("umount", containerURL).CombinedOutput(); err != nil {
logrus.Errorf("umount volume failed. %v", err)
return err
}
// umount the whole point of the container
_, err := exec.Command("umount", mntURL).CombinedOutput()
if err != nil {
logrus.Errorf("umount mountpoint failed. %v", err)
return err
}
if err := os.RemoveAll(mntURL); err != nil {
logrus.Infof("remove mountpoint dir %s error %v", mntURL, err)
}
return nil
}
DeleteWriteLayer 函数用来删除容器读写层，参数改为 containerName :
复制
func DeleteWriteLayer(containerName string) {
writeURL := fmt.Sprintf(WriteLayerURL, containerName)
if err := os.RemoveAll(writeURL); err != nil {
logrus.Errorf("remove dir %s error %v", writeURL, err)
}
}
然后修改 command.go 中的 commitCommand ：输入参数名改为 containerName 和 imageName ：· 。
复制
var CommitCommand = cli.Command{
Name: "commit",
Usage: "commit a container into image",
Action: func(context *cli.Context) error {
if len(context.Args()) < 1 {
return fmt.Errorf("missing container name")
}
containerName := context.Args()[0]
imageName := context.Args()[1]
// commitContainer(containerName)
commitContainer(containerName, imageName)
return nil
},
}
修改 commit.go 的 commitContainer 函数，根据传入的 containerName 制作 imageName.tar 镜像:
复制
func commitContainer(containerName, imageName string) {
mntURL := fmt.Sprintf(container.MntURL, containerName)
mntURL += "/"
imageTar := container.RootURL + "/" + imageName + ".tar"
if _, err := exec.Command("tar", "-czf", imageTar, "-C", mntURL, ".").CombinedOutput(); err != nil {
logrus.Errorf("tar folder %s error %v", mntURL, err)
}
}
测试一下，用 busybox 启动两个容器 test1 和 test2，test1 把宿主机 /root/from1 挂载到容器 /to1 ，test2 把宿主机 /root/from2 挂载到 /to2 下:
复制
# go run . run -d --name test1 -v /root/from1:/to1 busybox top
{"level":"info","msg":"[\"/root/from1\" \"/to1\"]","time":"2023-05-11T10:04:42+08:00"}
{"level":"info","msg":"whole init command is: top","time":"2023-05-11T10:04:42+08:00"}
# go run . run -d --name test2 -v /root/from2:/to2 busybox top
{"level":"info","msg":"[\"/root/from2\" \"/to2\"]","time":"2023-05-11T10:04:51+08:00"}
{"level":"info","msg":"whole init command is: top","time":"2023-05-11T10:04:51+08:00"}
# go run . ps
ID NAME PID STATUS COMMAND CREATED
4010011034 test1 11570 running top 2023-05-11 10:04:42
5746376093 test2 11684 running top 2023-05-11 10:04:51
打开另一个终端，可以看到 /root 目录下多了 from1 和 from2 两个目录，我们看看 mnt 和 writeLayer ， mnt 下多了两个 busybox 的挂载层， writeLayer 下分别挂载了两个容器的目录:
复制
# tree writeLayer/
writeLayer/
├── test1
│ └── to1
└── test2
└── to2
下面进入 test1 容器，创建 /to1/test1.txt :
复制
# go run . exec test1 sh
{"level":"info","msg":"container pid 11570","time":"2023-05-11T10:16:33+08:00"}
{"level":"info","msg":"command sh","time":"2023-05-11T10:16:33+08:00"}
/ # echo -e "test1" >> /to1/test1.txt
/ # mkdir to1-1
/ # echo -e "test111111" >> /to1-1/test1111.txt
这时候再来看看可写层:
复制
# tree writeLayer/
writeLayer/
├── test1
│ ├── root
│ ├── to1
│ └── to1-1
│ └── test1111.txt
└── test2
└── to2
# cat writeLayer/test1/to1-1/test1111.txt
test111111
多了 to1-1/test1111.txt ，那刚刚创建的 test1.txt 去哪了呢？这时候我们看看 from1 ，在这里，新创建的文件写入了数据卷.
下面来验证 commit 功能:
复制
# go run . commit test1 image1
导出的镜像路径为 /root/image1.tar .
下面测试停止和删除容器:
复制
# go run . stop test1
# go run . ps
ID NAME PID STATUS COMMAND CREATED
4010011034 test1 stopped top 2023-05-11 10:04:42
5746376093 test2 11684 running top 2023-05-11 10:04:51
# go run . rm test1
# go run . ps
ID NAME PID STATUS COMMAND CREATED
5746376093 test2 11684 running top 2023-05-11 10:04:51
我们看看容器根目录和可读写层:
复制
# ls mnt
test2
# tree writeLayer/
writeLayer/
└── test2
└── to2
test1 的容器根目录和可读写层被删除.
下面来试一下用镜像创建容器:
复制
# go run . run -d --name test3 -v /root/from3:/to3 image1 top
{"level":"info","msg":"[\"/root/from3\" \"/to3\"]","time":"2023-05-11T10:32:44+08:00"}
{"level":"info","msg":"whole init command is: top","time":"2023-05-11T10:32:44+08:00"}
# go run . ps
ID NAME PID STATUS COMMAND CREATED
5746376093 test2 11684 running top 2023-05-11 10:04:51
4713076733 test3 13056 running top 2023-05-11 10:32:44
这时我们可以看到 /root 多了一个 image1 目录:
复制
# ls image1
bin dev etc home lib lib64 proc root sys tmp to1 to1-1 usr var
在这里发现了刚才创建的 to1-1 ，用 image1.tar 启动的容器 test3，进入容器后发现我们刚刚写入的文件，至此，我们成功把容器 test1 的数据卷 to1 信息，重新写入了容器 test3 数据卷 to3.
在次小节后，进入容器都要指定镜像名，不然都会报错.
本节来实现让容器内运行的程序可以使用外部传递的环境变量.
在原来基础上增加 -e 选项，允许用户指定环境变量，由于环境变量可以是多个，这里允许用户多次使用 -e 来传递，同时添加对环境变量的解析，整体修改如下:
复制
var RunCommand = cli.Command{
Name: "run",
Usage: "Create a container",
Flags: []cli.Flag{
// integrate -i and -t for convenience
&cli.BoolFlag{
Name: "it",
Usage: "open an interactive tty(pseudo terminal)",
},
&cli.StringFlag{
Name: "m",
Usage: "limit the memory",
}, &cli.StringFlag{
Name: "cpu",
Usage: "limit the cpu amount",
}, &cli.StringFlag{
Name: "cpushare",
Usage: "limit the cpu share",
}, &cli.StringFlag{
Name: "v",
Usage: "volume",
}, &cli.BoolFlag{
Name: "d",
Usage: "detach container",
}, &cli.StringFlag{
Name: "cpuset",
Usage: "limit the cpuset",
}, &cli.StringFlag{
Name: "name",
Usage: "container name",
}, &cli.StringSliceFlag{
Name: "e",
Usage: "set environment",
},
},
Action: func(context *cli.Context) error {
args := context.Args()
if len(args) <= 0 {
return errors.New("run what?")
}
// 转化 cli.Args 为 []string
cmdArray := make([]string, len(args)) // command
copy(cmdArray, args)
// check whether type `-it`
tty := context.Bool("it") // presudo terminal
detach := context.Bool("d") // detach container
if tty && detach {
return fmt.Errorf("it and d paramter cannot both privided")
}
// get the resource config
resourceConfig := subsystem.ResourceConfig{
MemoryLimit: context.String("m"),
CPUShare: context.String("cpushare"),
CPUSet: context.String("cpu"),
}
volume := context.String("v")
containerName := context.String("name")
envSlice := context.StringSlice("e")
imageName := cmdArray[0]
cmdArray = cmdArray[1:]
Run(tty, cmdArray, &resourceConfig, volume, containerName, imageName, envSlice)
return nil
},
}
参数里新增一个 envSlice ，然后传递给 NewParentProcess 函数.
复制
func Run(tty bool, cmdArray []string, res *subsystem.ResourceConfig, volume, containerName, imageName string, envSlice []string) {
containerID := randStringBytes(10)
if containerName == "" {
containerName = containerID
}
// this is "docker init <cmdArray>"
initProcess, writePipe := container.NewParentProcess(tty, volume, containerName, imageName, envSlice)
if initProcess == nil {
logrus.Errorf("new parent process error")
return
}
// start the init process
if err := initProcess.Start(); err != nil {
logrus.Error(err)
}
// container info
containerName, err := recordContainerInfo(initProcess.Process.Pid, cmdArray, containerName, volume)
if err != nil {
logrus.Errorf("record container info error: %v", err)
return
}
// create container manager to control resource config on all hierarchies
cm := cgroups.NewCgroupManager("simple-docker-container")
defer cm.Remove()
cm.Set(res)
cm.AddProcess(initProcess.Process.Pid)
// send command to write side
// will close the plug
sendInitCommand(cmdArray, writePipe)
if tty {
initProcess.Wait()
deleteContainerInfo(containerName)
container.DeleteWorkSpace(volume, containerName)
}
os.Exit(0)
}
参数新增一个 envSlice ，给 cmd 设置环境变量.
复制
func NewParentProcess(tty bool, volume string, containerName, imageName string, envSlice []string) (*exec.Cmd, *os.File) {
readPipe, writePipe, err := os.Pipe()
if err != nil {
logrus.Errorf("New Pipe Error: %v", err)
return nil, nil
}
// create a new command which run itself
// the first arguments is `init` which is in the "container/init.go" file
// so, the <cmd> will be interpret as "docker init <cmdArray>"
cmd := exec.Command("/proc/self/exe", "init")
cmd.SysProcAttr = &syscall.SysProcAttr{
Cloneflags: syscall.CLONE_NEWUTS | syscall.CLONE_NEWPID | syscall.CLONE_NEWNS |
syscall.CLONE_NEWNET | syscall.CLONE_NEWIPC,
}
cmd.Stdin = os.Stdin
if tty {
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
} else {
dirURL := fmt.Sprintf(DefaultInfoLocation, containerName)
if err := os.MkdirAll(dirURL, 0622); err != nil {
logrus.Errorf("NewParentProcess mkdir %s error %v", dirURL, err)
return nil, nil
}
stdLogFilePath := dirURL + ContainerLogFile
stdLogFile, err := os.Create(stdLogFilePath)
if err != nil {
logrus.Errorf("NewParentProcess create file %s error %v", stdLogFilePath, err)
return nil, nil
}
cmd.Stdout = stdLogFile
}
cmd.ExtraFiles = []*os.File{readPipe}
cmd.Env = append(os.Environ(), envSlice...)
NewWorkSpace(volume, imageName, containerName)
cmd.Dir = fmt.Sprintf(MntURL, containerName)
return cmd, writePipe
}
测试一下:
复制
# go run . run -it --name test -e test=123 -e luck=test busybox sh
{"level":"info","msg":"Start initiating...","time":"2023-05-11T14:14:52+08:00"}
{"level":"info","msg":"whole init command is: sh","time":"2023-05-11T14:14:52+08:00"}
{"level":"info","msg":"Current location is /root/mnt/test","time":"2023-05-11T14:14:52+08:00"}
{"level":"info","msg":"Find path: /bin/sh","time":"2023-05-11T14:14:52+08:00"}
/ # env | grep test
test=123
luck=test
可以看到，手动指定的环境变量在容器内可见。后面创建一个后台运行的容器:
复制
# go run . run -d --name test -e test=123 -e luck=test busybox top
{"level":"info","msg":"whole init command is: top","time":"2023-05-11T14:19:31+08:00"}
# go run . ps
ID NAME PID STATUS COMMAND CREATED
9649354121 test 29524 running top 2023-05-11 14:19:31
# go run . exec test sh
{"level":"info","msg":"container pid 29524","time":"2023-05-11T14:20:12+08:00"}
{"level":"info","msg":"command sh","time":"2023-05-11T14:20:12+08:00"}
/ # ps -ef
PID USER TIME COMMAND
1 root 0:00 top
7 root 0:00 sh
8 root 0:00 ps -ef
/ # env | grep test
/ #
查看环境变量，没有我们设置的环境变量.
这里不能用 env 命令获取设置的环境变量，原因是 exec 可以说 go 发起的另一个进程，这个进程的父进程是宿主机的，这个，并不是容器内的。在 cgo 内使用了 setns 系统调用，才使得进程进入了容器内部的命名空间，但由于环境变量是继承自父进程的，因此这个 exec 进程的环境变量其实是继承自宿主机，所以在 exec 看到的环境变量其实是宿主机的环境变量.
但只要是容器内 pid 为 1 的进程，创造出来的进程都会继承它的环境变量，下面来修改 exec 命令来直接使用 env 命令来查看容器内环境变量的功能.
提供一个函数，可根据指定的 pid 来获取对应进程的环境变量.
复制
func getEnvsByPid(pid string) []string {
path := fmt.Sprintf("/proc/%s/environ", pid)
contentBytes ,err := ioutil.ReadFile(path)
if err != nil {
logrus.Errorf("read file %s error %v", path, err)
return nil
}
// divide by '\u0000'
envs := strings.Split(string(contentBytes),"\u0000")
return envs
}
由于进程存放环境变量的位置是 /proc/${pid}/environ ，因此根据给定的 pid 去读取这个文件，可以获取环境变量，在文件的描述中，每个环境变量之间通过 \u0000 分割，因此可以以此标记来获取环境变量数组.
复制
func ExecContainer(containerName string, comArray []string) {
// get the pid according the containerName
pid, err := getContainerPidByName(containerName)
if err != nil {
logrus.Errorf("exec container getContainerPidByName %s error %v", containerName, err)
return
}
// divide command by blank space and combine as a string
cmdStr := strings.Join(comArray, " ")
logrus.Infof("container pid %s", pid)
logrus.Infof("command %s", cmdStr)
cmd := exec.Command("/proc/self/exe", "exec")
cmd.Stdin = os.Stdin
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
err = os.Setenv(ENV_EXEC_PID, pid)
if err != nil {
logrus.Errorf("set env exec pid %s error %v", pid, err)
}
err = os.Setenv(ENV_EXEC_CMD, cmdStr)
if err != nil {
logrus.Errorf("set env exec command %s error %v", cmdStr, err)
}
// get target pid environ (container environ)
containerEnvs := getEnvsByPid(pid)
// set host environ and container environ to exec process
cmd.Env = append(os.Environ(), containerEnvs...)
if err := cmd.Run(); err != nil {
logrus.Errorf("exec container %s error %v", containerName, err)
}
}
这里由于 exec 命令依然要宿主机的一些环境变量，因此将宿主机环境变量和容器环境变量都一起放置到 exec 进程中:
复制
# go run . run -d --name test -e test=123 -e luck=test busybox top
{"level":"info","msg":"whole init command is: top","time":"2023-05-11T14:30:03+08:00"}
# go run . ps
ID NAME PID STATUS COMMAND CREATED
9729397397 test 50040 running top 2023-05-11 14:30:03
# go run . exec test sh
{"level":"info","msg":"container pid 50040","time":"2023-05-11T14:30:17+08:00"}
{"level":"info","msg":"command sh","time":"2023-05-11T14:30:17+08:00"}
/ # env | grep test
test=123
luck=test
/ #
现在可以看到 exec 进程可以获取前面 run 时设置的环境变量了.
Linux 是用网络设备去操作和使用网卡的，系统装了一个网卡后就会为其生成一个网络设备实例，例如 eth0。Linux 支持创建出虚拟化的设备，可通过组合实现多种多样的功能和网络拓扑，这里主要介绍 Veth 和 Bridge.
Linux Veth 。
Veth 时成对出现的虚拟网络设备，发送到 Veth 一端虚拟设备的请求会从另一端的虚拟设备中发出。容器的虚拟化场景中，常会使用 Veth 连接不同的网络 namespace:
复制
# ip netns add ns1
# ip netns add ns2
# ip link add veth0 type veth peer name veth1
# ip link set veth0 netns ns1
# ip link set veth1 netns ns2
# ip netns exec ns1 ip link
1: lo: <LOOPBACK> mtu 65536 qdisc noop state DOWN mode DEFAULT group default qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
4: veth0@if3: <BROADCAST,MULTICAST> mtu 1500 qdisc noop state DOWN mode DEFAULT group default qlen 1000
link/ether 02:bf:18:99:77:ed brd ff:ff:ff:ff:ff:ff link-netns ns2
在 ns1 和 ns2 的namespace 中，除 loopback 的设备以外就只看到了一个网络设备。当请求发送到这个虚拟网络设备时，都会原封不动地从另一个网络 namespace 的网络接口中出来。例如，给两端分别配置不同地址后，向虚拟网络设备的一端发送请求，就能达到这个虚拟网络设备对应的另一端.
复制
# ip netns exec ns1 ifconfig veth0 172.18.0.2/24 up
# ip netns exec ns2 ifconfig veth1 172.18.0.3/24 up
# ip netns exec ns1 route add default dev veth0
# ip netns exec ns2 route add default dev veth1
# ip netns exec ns1 ping -c 1 172.18.0.3
PING 172.18.0.3 (172.18.0.3) 56(84) bytes of data.
64 bytes from 172.18.0.3: icmp_seq=1 ttl=64 time=0.395 ms
--- 172.18.0.3 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 0.395/0.395/0.395/0.000 ms
Linux Bridge 。
进行下一步之前，先删除上一小节创建的 netns:
复制
# ip netns del ns1
# ip netns del ns2
# ip netns list
此时之前创建的两个 netns 被删除.
Bridge 虚拟设备时用来桥接的网络设备，相当于现实世界的交换机，可以连接不同的网络设备，当请求达到 Bridge 设备时，可以通过报文中的 Mac 地址进行广播或转发。例如，创建一个 Bridge 设备，来连接 namespace 中的网络设备和宿主机上的网络:
复制
# ip netns add ns1
# ip link add veth0 type veth peer name veth1
# ip link set veth1 netns ns1
########## 创建网桥
# brctl addbr br0
########## 挂载网络设备
# brctl addif br0 eth0
# brctl addif bro veth0
路由表是 Linux 内核的一个模块，通过定义路由表来决定在某个网络 namespace 中包的流向，从而定义请求会到哪个网络设备上:
复制
# ip link set veth0 up
# ip link set br0 up
# ip netns exec ns1 ifconfig veth1 172.18.0.2/24 up
# ip netns exec ns1 route add default dev veth1
# route add -net 172.18.0.0/24 dev br0
通过设置路由，对 IP 地址的请求就能正确被路由到对应的网络设备上，从而实现通信:
复制
# ifconfig eth0
eth0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST> mtu 1500
inet 172.31.93.218 netmask 255.255.240.0 broadcast 172.31.95.255
inet6 fe80::215:5dff:fe4e:a16a prefixlen 64 scopeid 0x20<link>
ether 00:15:5d:4e:a1:6a txqueuelen 1000 (Ethernet)
RX packets 829 bytes 394161 (394.1 KB)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 90 bytes 10335 (10.3 KB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
########## 在namespace访问宿主机
# ip netns exec ns1 ping -c 1 172.31.93.218
PING 172.31.93.218 (172.31.93.218) 56(84) bytes of data.
64 bytes from 172.31.93.218: icmp_seq=1 ttl=64 time=0.556 ms
--- 172.31.93.218 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 0.556/0.556/0.556/0.000 ms
######### 从宿主机访问namespace的网络地址
# ping -c 1 172.18.0.2
PING 172.18.0.2 (172.18.0.2) 56(84) bytes of data.
64 bytes from 172.18.0.2: icmp_seq=1 ttl=64 time=0.113 ms
--- 172.18.0.2 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 0.113/0.113/0.113/0.000 ms
iptables 是对 Linux 内核的 netfilter 模块进行操作和展示的工具，用来管理包的流动和转送。iptables 定义了一套链式处理的结构，在网络包传输的各个阶段可以使用不同的策略和包进行加工、传送或丢弃。在容器虚拟化技术里，常会用到两种策略，MASQUERADE 和 DNAT，用于容器和宿主机外部的网络通信.
MASQUERADE 。
MASQUERADE 策略可以将请求包中的源地址转换为一个网络设备的地址，例如 [7.1.2 Linux 路由表](#7.1.2 Linux 路由表) 这一小节里，namespace 中网络设备的地址是 172.18.0.2，这个地址虽然在宿主机可以路由到 br0 的网桥，但是到底宿主机外部后，是不知道如何路由到这个 IP 的，所以如果请求外部地址的话，要先通过 MASQUERADE 策略将这个 IP 转换为宿主机出口网卡的 IP:
复制
# sysctl -w net.ipv4.conf.all.forwarding=1
net.ipv4.conf.all.forwarding = 1
# iptables -t nat -A POSTROUTING -s 172.18.0.0/24 -o eth0 -j MASQUERADE
在 namespace 中请求宿主机外部地址时，将 namespace 中源地址转换为宿主机的地址作为源地址，就可以在 namespace 中访问宿主机外的网络了.
DAT 。
iptables 中的 DNAT 策略也是做网络地址的转换，不过它是要更换目标地址，常用于将内部网络地址的端口映射出去。例如，上面例子的 namespace 如果要提供服务给宿主机之外的应用要怎么办呢？外部应用没办法直接路由到 172.18.0.2 这个地址，这时候可以用 DNAT 策略.
复制
# iptables -t nat -A PREROUTING -p tcp --dport 80 -j DNAT --to-destination 172.18.0.2:80
这样就可以把宿主机上的 80 端口的 TCP 请求转发到 namespace 的 172.18.0.2:80，从而实现外部应用的调用.
网络是容器的一个集合，在这个网络上的容器可以相互通信.
复制
type Network struct {
Name string // network name
IpRange *net.IPNet // address
Driver string // network driver name
}
网络端点用于连接网络与容器，保证容器内部与网络的通信.
复制
type Endpoint struct {
ID string `json:"id"`
Device netlink.Veth `json:"dev"`
IPAddress net.IP `json:"ip"`
MacAddress net.HardwareAddr `json:"mac"`
Network *Network
PortMapping []string
}
网络端点的信息传输需要靠网络功能的两个组件配合完成，分别为网络驱动和 IPAM.
网络驱动是网络功能的一个组件，不同驱动对网络的创建、连接、销毁策略不同，通过在创建网络时指定不同的网络驱动来定义使用哪个驱动做网络的配置.
复制
type NetworkDriver interface {
Name() string // driver name
Create(subnet string, name string) (*Network, error)
Delete(network Network) error
Connect(network *Network, endpoint *Endpoint) error
Disconnect(network Network, endpoint *Endpoint) error
}
IPAM 也是网络功能的一个组件，用于网络 IP 地址的分配和释放，包括容器的 IP 和网络网关的 IP。主要功能如下:
ipam.Allocate(*net.IPNet) 从指定的 subnet 网段中分配 IP ipam.Release(*net.IPNet, net.IP) 从指定的 subnet 网段中释放掉指定的 IP 在构建下面的函数之前，先来补充一些书上没写的:
复制
var (
defaultNetworkPath = "/var/run/simple-docker/network/network/" // 默认网络配置信息存储位置
drivers = map[string]NetworkDriver{} // 驱动字典，存储驱动信息
networks = map[string]*Network{} // 网络字段，存储网络信息
)
复制
func CreateNetwork(driver, subnet, name string) error {
_, cidr, _ := net.ParseCIDR(subnet)
// allocate gateway ip by IPAM
gatewayIP, err := ipAllocator.Allocate(cidr)
if err != nil {
return err
}
cidr.IP = gatewayIP
nw, err := drivers[driver].Create(cidr.String(), name)
if err != nil {
return err
}
// save network info
return nw.dump(defaultNetworkPath)
}
其中，network.dump 和 network.load 方法是将这个网络的配置信息保存在文件系统中，或从网络的配置目录中的文件读取到网络的配置.
复制
func (nw *Network) dump(dumpPath string) error {
if _, err := os.Stat(dumpPath); err != nil {
if os.IsNotExist(err) {
os.MkdirAll(dumpPath, 0644)
} else {
return err
}
}
nwPath := path.Join(dumpPath, nw.Name)
// create file while empty file, write only, no file
nwFile, err := os.OpenFile(nwPath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644)
if err != nil {
logrus.Errorf("error: %v", err)
return err
}
defer nwFile.Close()
nwJson, err := json.Marshal(nw)
if err != nil {
logrus.Errorf("error: %v", err)
return err
}
_, err = nwFile.Write(nwJson)
if err != nil {
logrus.Errorf("error: %v", err)
return err
}
return nil
}
func (nw *Network) load(dumpPath string) error {
nwConfigFile, err := os.Open(dumpPath)
if err != nil {
return err
}
defer nwConfigFile.Close()
nwJson := make([]byte, 2000)
n, err := nwConfigFile.Read(nwJson)
if err != nil {
return err
}
err = json.Unmarshal(nwJson[:n], nw)
if err != nil {
logrus.Errorf("error load nw info: %v", err)
return err
}
return nil
}
复制
func Connect(networkName string, cinfo *container.ContainerInfo) error {
network, ok := networks[networkName]
if !ok {
return fmt.Errorf("no Such Network: %s", networkName)
}
ip, err := ipAllocator.Allocate(network.IpRange)
if err != nil {
return err
}
ep := &Endpoint{
ID: fmt.Sprintf("%s-%s", cinfo.Id, networkName),
IPAddress: ip,
Network: network,
PortMapping: cinfo.PortMapping,
}
if err = drivers[network.Driver].Connect(network, ep); err != nil {
return err
}
if err = configEndpointIpAddressAndRoute(ep, cinfo); err != nil {
return err
}
return configPortMapping(ep, cinfo)
}
从网络配置的目录中加载所有的网络配置信息:
复制
func Init() error {
var bridgeDriver = BridgeNetworkDriver{}
drivers[bridgeDriver.Name()] = &bridgeDriver
if _, err := os.Stat(defaultNetworkPath); err != nil {
if os.IsNotExist(err) {
os.MkdirAll(defaultNetworkPath, 0644)
} else {
return err
}
}
filepath.Walk(defaultNetworkPath, func(nwPath string, info os.FileInfo, err error) error {
// skip if dir
if info.IsDir() {
return nil
}
if strings.HasSuffix(nwPath, "/") {
return nil
}
// load filename as network name
_, nwName := path.Split(nwPath)
nw := &Network{
Name: nwName,
}
if err := nw.load(nwPath); err != nil {
logrus.Errorf("error load network: %s", err)
}
// save network info to network dic
networks[nwName] = nw
return nil
})
return nil
}
遍历展示创建的网络:
复制
func ListNetwork() {
w := tabwriter.NewWriter(os.Stdout, 12, 1, 3, ' ', 0)
fmt.Fprint(w, "NAME\tIpRange\tDriver\n")
for _, nw := range networks {
fmt.Fprintf(w, "%s\t%s\t%s\n",
nw.Name,
nw.IpRange.String(),
nw.Driver,
)
}
if err := w.Flush(); err != nil {
logrus.Errorf("Flush error %v", err)
return
}
}
复制
func DeleteNetwork(networkName string) error {
nw, ok := networks[networkName]
if !ok {
return fmt.Errorf("no Such Network: %s", networkName)
}
if err := ipAllocator.Release(nw.IpRange, &nw.IpRange.IP); err != nil {
return fmt.Errorf("error Remove Network gateway ip: %s", err)
}
if err := drivers[nw.Driver].Delete(*nw); err != nil {
return fmt.Errorf("error Remove Network DriverError: %s", err)
}
return nw.remove(defaultNetworkPath)
}
删除网络的同时也删除配置目录的网络配置文件:
复制
func (nw *Network) remove(dumpPath string) error {
if _, err := os.Stat(path.Join(dumpPath, nw.Name)); err != nil {
if os.IsNotExist(err) {
return nil
} else {
return err
}
} else {
return os.Remove(path.Join(dumpPath, nw.Name))
}
}
现在转到 ipam.go .
复制
const ipamDefaultAllocatorPath = "/var/run/simple-docker/network/ipam/subnet.json"
type IPAM struct {
SubnetAllocatorPath string
Subnets *map[string]string
}
// 初始化一个IPAM对象，并指定默认分配信息存储位置
var ipAllocator = &IPAM{
SubnetAllocatorPath: ipamDefaultAllocatorPath,
}
反序列化读取网段分配信息和序列化保存网段分配信息:
复制
func (ipam *IPAM) load() error {
if _, err := os.Stat(ipam.SubnetAllocatorPath); err != nil {
if os.IsNotExist(err) {
return nil
} else {
return err
}
}
subnetConfigFile, err := os.Open(ipam.SubnetAllocatorPath)
if err != nil {
return err
}
defer subnetConfigFile.Close()
subnetJson := make([]byte, 2000)
n, err := subnetConfigFile.Read(subnetJson)
if err != nil {
return err
}
err = json.Unmarshal(subnetJson[:n], ipam.Subnets)
if err != nil {
logrus.Errorf("Error dump allocation info, %v", err)
return err
}
return nil
}
func (ipam *IPAM) dump() error {
ipamConfigFileDir, _ := path.Split(ipam.SubnetAllocatorPath)
if _, err := os.Stat(ipamConfigFileDir); err != nil {
if os.IsNotExist(err) {
os.MkdirAll(ipamConfigFileDir, 0644)
} else {
return err
}
}
subnetConfigFile, err := os.OpenFile(ipam.SubnetAllocatorPath, os.O_TRUNC|os.O_WRONLY|os.O_CREATE, 0644)
if err != nil {
return err
}
defer subnetConfigFile.Close()
ipamConfigJson, err := json.Marshal(ipam.Subnets)
if err != nil {
return err
}
_, err = subnetConfigFile.Write(ipamConfigJson)
if err != nil {
return err
}
return nil
}
复制
func (ipam *IPAM) Allocate(subnet *net.IPNet) (ip net.IP, err error) {
ipam.Subnets = &map[string]string{}
err = ipam.load()
if err != nil {
logrus.Errorf("error dump allocation info, %v", err)
}
_, subnet, _ = net.ParseCIDR(subnet.String())
one, size := subnet.Mask.Size()
if _, exist := (*ipam.Subnets)[subnet.String()]; !exist {
// 用0填满网段的配置，1<<uint8(size-one)表示这个网段中有多少个可用地址
// size-one时子网掩码后面的网络位数，2^(size-one)表示网段中的可用IP数
// 2^(size-one)等价于1<<uint8(size-one)
(*ipam.Subnets)[subnet.String()] = strings.Repeat("0", 1<<uint8(size-one))
}
// 这里的原理建议大家看看原著
for c := range (*ipam.Subnets)[subnet.String()] {
if (*ipam.Subnets)[subnet.String()][c] == '0' {
ipalloc := []byte((*ipam.Subnets)[subnet.String()])
// go的字符串创建后不能修改，先用byte存储
ipalloc[c] = '1'
(*ipam.Subnets)[subnet.String()] = string(ipalloc)
//
ip = subnet.IP
// 通过网段的IP与上面的偏移相加得出分配的IP，由于IP是一个uint的一个数组，需要通过数组中的每一项加所需要的值，例 // 如网段是172.16.0.0/12，数组序号是65555，那就要在[172,16,0,0]上依次加
// [uint8(65555 >> 24), uint8(65555 >> 16), uint8(65555 >> 8), uint(65555 >> 4)]，即[0,1,0,19]，
// 那么获得的IP就是172.17.0.19
for t := uint(4); t > 0; t-- {
[]byte(ip)[4-t] += uint8(c >> ((t - 1) * 8))
}
// 由于此处IP是从1开始分配的，所以最后再加1，最终得到分配的IP是172.16.0.20
ip[3]++
break
}
}
ipam.dump()
return
}
复制
func (ipam *IPAM) Release(subnet *net.IPNet, ipaddr *net.IP) error {
ipam.Subnets = &map[string]string{}
_, subnet, _ = net.ParseCIDR(subnet.String())
err := ipam.load()
if err != nil {
logrus.Errorf("Error dump allocation info, %v", err)
}
c := 0
// 将IP转换为4个字节的表示方式
releaseIP := ipaddr.To4()
// 由于IP是从1开始分配的，所以转换成索引减1
releaseIP[3] -= 1
for t := uint(4); t > 0; t -= 1 {
// 和分配IP相反，释放IP获得索引的方式是IP的每一位相减后分别左移将对应的数值加到索引上
c += int(releaseIP[t-1]-subnet.IP[t-1]) << ((4 - t) * 8)
}
ipalloc := []byte((*ipam.Subnets)[subnet.String()])
ipalloc[c] = '0'
(*ipam.Subnets)[subnet.String()] = string(ipalloc)
ipam.dump()
return nil
}
根据书上，写到这里就开始测试了，但是我们看看 IDE，红海一片，所以我们接着实现.
复制
func (d *BridgeNetworkDriver) Create(subnet string, name string) (*Network, error) {
ip, ipRange, _ := net.ParseCIDR(subnet)
ipRange.IP = ip
n := &Network{
Name: name,
IpRange: ipRange,
Driver: d.Name(),
}
err := d.initBridge(n)
if err != nil {
logrus.Errorf("error init bridge: %v", err)
}
return n, err
}
复制
func (d *BridgeNetworkDriver) initBridge(n *Network) error {
// 创建bridge虚拟设备
bridgeName := n.Name
if err := createBridgeInterface(bridgeName); err != nil {
return fmt.Errorf("eror add bridge: %s, error: %v", bridgeName, err)
}
// 设置bridge设备的地址和路由
gatewayIP := *n.IpRange
gatewayIP.IP = n.IpRange.IP
if err := setInterfaceIP(bridgeName, gatewayIP.String()); err != nil {
return fmt.Errorf("error assigning address: %s on bridge: %s with an error of: %v", gatewayIP, bridgeName, err)
}
// 启动bridge设备
if err := setInterfaceUP(bridgeName); err != nil {
return fmt.Errorf("error set bridge up: %s, error: %v", bridgeName, err)
}
// 设置iptables的SNAT规则
if err := setupIPTables(bridgeName, n.IpRange); err != nil {
return fmt.Errorf("error setting iptables for %s: %v", bridgeName, err)
}
return nil
}
复制
func createBridgeInterface(bridgeName string) error {
_, err := net.InterfaceByName(bridgeName)
if err == nil || !strings.Contains(err.Error(), "no such network interface") {
return err
}
// create *netlink.Bridge object
la := netlink.NewLinkAttrs()
la.Name = bridgeName
br := &netlink.Bridge{LinkAttrs: la}
if err := netlink.LinkAdd(br); err != nil {
return fmt.Errorf("bridge creation failed for bridge %s: %v", bridgeName, err)
}
return nil
}
复制
func setInterfaceIP(name string, rawIP string) error {
retries := 2
var iface netlink.Link
var err error
for i := 0; i < retries; i++ {
iface, err = netlink.LinkByName(name)
if err == nil {
break
}
logrus.Debugf("error retrieving new bridge netlink link [ %s ]... retrying", name)
time.Sleep(2 * time.Second)
}
if err != nil {
return fmt.Errorf("abandoning retrieving the new bridge link from netlink, Run [ ip link ] to troubleshoot the error: %v", err)
}
ipNet, err := netlink.ParseIPNet(rawIP)
if err != nil {
return err
}
addr := &netlink.Addr{
IPNet: ipNet,
Peer: ipNet,
Label: "",
Flags: 0,
Scope: 0,
Broadcast: nil,
}
return netlink.AddrAdd(iface, addr)
}
复制
func setInterfaceUP(interfaceName string) error {
iface, err := netlink.LinkByName(interfaceName)
if err != nil {
return fmt.Errorf("error retrieving a link named [ %s ]: %v", iface.Attrs().Name, err)
}
if err := netlink.LinkSetUp(iface); err != nil {
return fmt.Errorf("error enabling interface for %s: %v", interfaceName, err)
}
return nil
}
复制
func setupIPTables(bridgeName string, subnet *net.IPNet) error {
iptablesCmd := fmt.Sprintf("-t nat -A POSTROUTING -s %s ! -o %s -j MASQUERADE", subnet.String(), bridgeName)
cmd := exec.Command("iptables", strings.Split(iptablesCmd, " ")...)
//err := cmd.Run()
output, err := cmd.Output()
if err != nil {
logrus.Errorf("iptables Output, %v", output)
}
return err
}
复制
func (d *BridgeNetworkDriver) Delete(network Network) error {
bridgeName := network.Name
br, err := netlink.LinkByName(bridgeName)
if err != nil {
return err
}
return netlink.LinkDel(br)
}
复制
func (d *BridgeNetworkDriver) Connect(network *Network, endpoint *Endpoint) error {
bridgeName := network.Name
br, err := netlink.LinkByName(bridgeName)
if err != nil {
return err
}
la := netlink.NewLinkAttrs()
la.Name = endpoint.ID[:5]
la.MasterIndex = br.Attrs().Index
endpoint.Device = netlink.Veth{
LinkAttrs: la,
PeerName: "cif-" + endpoint.ID[:5],
}
if err = netlink.LinkAdd(&endpoint.Device); err != nil {
return fmt.Errorf("error Add Endpoint Device: %v", err)
}
if err = netlink.LinkSetUp(&endpoint.Device); err != nil {
return fmt.Errorf("error Add Endpoint Device: %v", err)
}
return nil
}
回到 network.go 。
复制
func configEndpointIpAddressAndRoute(ep *Endpoint, cinfo *container.ContainerInfo) error {
peerLink, err := netlink.LinkByName(ep.Device.PeerName)
if err != nil {
return fmt.Errorf("fail config endpoint: %v", err)
}
defer enterContainerNetns(&peerLink, cinfo)()
interfaceIP := *ep.Network.IpRange
interfaceIP.IP = ep.IPAddress
if err = setInterfaceIP(ep.Device.PeerName, interfaceIP.String()); err != nil {
return fmt.Errorf("%v,%s", ep.Network, err)
}
if err = setInterfaceUP(ep.Device.PeerName); err != nil {
return err
}
if err = setInterfaceUP("lo"); err != nil {
return err
}
_, cidr, _ := net.ParseCIDR("0.0.0.0/0")
defaultRoute := &netlink.Route{
LinkIndex: peerLink.Attrs().Index,
Gw: ep.Network.IpRange.IP,
Dst: cidr,
}
if err = netlink.RouteAdd(defaultRoute); err != nil {
return err
}
return nil
}
复制
func enterContainerNetns(enLink *netlink.Link, cinfo *container.ContainerInfo) func() {
f, err := os.OpenFile(fmt.Sprintf("/proc/%s/ns/net", cinfo.Pid), os.O_RDONLY, 0)
if err != nil {
logrus.Errorf("error get container net namespace, %v", err)
}
nsFD := f.Fd()
runtime.LockOSThread()
if err = netlink.LinkSetNsFd(*enLink, int(nsFD)); err != nil {
logrus.Errorf("error set link netns , %v", err)
}
origns, err := netns.Get()
if err != nil {
logrus.Errorf("error get current netns, %v", err)
}
if err = netns.Set(netns.NsHandle(nsFD)); err != nil {
logrus.Errorf("error set netns, %v", err)
}
return func() {
netns.Set(origns)
origns.Close()
runtime.UnlockOSThread()
f.Close()
}
}
复制
func configPortMapping(ep *Endpoint, cinfo *container.ContainerInfo) error {
for _, pm := range ep.PortMapping {
portMapping := strings.Split(pm, ":")
if len(portMapping) != 2 {
logrus.Errorf("port mapping format error, %v", pm)
continue
}
iptablesCmd := fmt.Sprintf("-t nat -A PREROUTING -p tcp -m tcp --dport %s -j DNAT --to-destination %s:%s",
portMapping[0], ep.IPAddress.String(), portMapping[1])
cmd := exec.Command("iptables", strings.Split(iptablesCmd, " ")...)
//err := cmd.Run()
output, err := cmd.Output()
if err != nil {
logrus.Errorf("iptables Output, %v", output)
continue
}
}
return nil
}
写到这里，代码还是有很多 bug 的，例如， BridgeNetworkDriver 未完全继承 NetworkDriver 的所有函数.
复制
func (d *BridgeNetworkDriver) Disconnect(network Network, endpoint *Endpoint) error {
return nil
}
现在终于可以测试了.
首先创建一个网桥:
复制
# go run . network create --driver bridge --subnet 192.168.10.1/24 testbridge
然后启动两个容器:
复制
# go run . run -it -net testbridge busybox sh
{"level":"info","msg":"Start initiating...","time":"2023-05-20T19:24:53+08:00"}
{"level":"info","msg":"whole init command is: sh","time":"2023-05-20T19:24:53+08:00"}
{"level":"info","msg":"Current location is /root/mnt/8116248511","time":"2023-05-20T19:24:53+08:00"}
{"level":"info","msg":"Find path: /bin/sh","time":"2023-05-20T19:24:53+08:00"}
/ # ifconfig
cif-81162 Link encap:Ethernet HWaddr 16:62:68:81:E0:A9
inet addr:192.168.10.2 Bcast:192.168.10.255 Mask:255.255.255.0
inet6 addr: fe80::1462:68ff:fe81:e0a9/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:14 errors:0 dropped:0 overruns:0 frame:0
TX packets:6 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:1820 (1.7 KiB) TX bytes:516 (516.0 B)
lo Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
inet6 addr: ::1/128 Scope:Host
UP LOOPBACK RUNNING MTU:65536 Metric:1
RX packets:0 errors:0 dropped:0 overruns:0 frame:0
TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:0 (0.0 B) TX bytes:0 (0.0 B)
/ #
记住这个 IP： 192.168.10.2 ，然后进入另一个容器:
复制
# go run . run -it -net testbridge busybox sh
{"level":"info","msg":"Start initiating...","time":"2023-05-20T19:26:24+08:00"}
{"level":"info","msg":"whole init command is: sh","time":"2023-05-20T19:26:24+08:00"}
{"level":"info","msg":"Current location is /root/mnt/9558830402","time":"2023-05-20T19:26:24+08:00"}
{"level":"info","msg":"Find path: /bin/sh","time":"2023-05-20T19:26:24+08:00"}
/ # ifconfig
cif-95588 Link encap:Ethernet HWaddr 42:18:0A:73:33:CA
inet addr:192.168.10.3 Bcast:192.168.10.255 Mask:255.255.255.0
inet6 addr: fe80::4018:aff:fe73:33ca/64 Scope:Link
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
RX packets:10 errors:0 dropped:0 overruns:0 frame:0
TX packets:6 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:1248 (1.2 KiB) TX bytes:516 (516.0 B)
lo Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
inet6 addr: ::1/128 Scope:Host
UP LOOPBACK RUNNING MTU:65536 Metric:1
RX packets:0 errors:0 dropped:0 overruns:0 frame:0
TX packets:0 errors:0 dropped:0 overruns:0 carrier:0
collisions:0 txqueuelen:1000
RX bytes:0 (0.0 B) TX bytes:0 (0.0 B)
/ # ping 192.168.10.2
PING 192.168.10.2 (192.168.10.2): 56 data bytes
64 bytes from 192.168.10.2: seq=0 ttl=64 time=2.619 ms
64 bytes from 192.168.10.2: seq=1 ttl=64 time=0.086 ms
^C
--- 192.168.10.2 ping statistics ---
2 packets transmitted, 2 packets received, 0% packet loss
round-trip min/avg/max = 0.086/1.352/2.619 ms
/ #
可以看到，两个容器网络互通.
下面来试一下访问外部网络。我用的 WSL，默认的 nat 是关闭的，前期各种设置 iptables 规则什么的，都无法访问容器外部的网络，直到发现一篇帖子里说到，需要打开内核的 nat 功能，要将文件 /proc/sys/net/ipv4/ip_forward 内的值改为1（默认是0）。执行 sysctl -w net.ipv4.ip_forward=1 即可.
修改之后，继续测试.
容器默认是没有 DNS 服务器的，需要我们手动添加:
复制
/ # ping cn.bing.com
ping: bad address 'cn.bing.com'
/ # echo -e "nameserver 8.8.8.8" > /etc/resolv.conf
/ # ping cn.bing.com
PING cn.bing.com (202.89.233.101): 56 data bytes
64 bytes from 202.89.233.101: seq=0 ttl=113 time=38.419 ms
64 bytes from 202.89.233.101: seq=1 ttl=113 time=39.011 ms
^C
--- cn.bing.com ping statistics ---
3 packets transmitted, 2 packets received, 33% packet loss
round-trip min/avg/max = 38.419/38.715/39.011 ms
/ #
然后再来测试容器映射端口到宿主机供外部访问:
复制
# go run . run -it -p 90:90 -net testbridge busybox sh
{"level":"info","msg":"Start initiating...","time":"2023-05-20T19:39:07+08:00"}
{"level":"info","msg":"whole init command is: sh","time":"2023-05-20T19:39:07+08:00"}
{"level":"info","msg":"Current location is /root/mnt/3445154844","time":"2023-05-20T19:39:07+08:00"}
{"level":"info","msg":"Find path: /bin/sh","time":"2023-05-20T19:39:07+08:00"}
/ # nc -lp 90
然后访问宿主机的 80 端口，看看能不能转发到容器里:
复制
# telnet 172.31.93.218 90
Trying 172.31.93.218...
telnet: Unable to connect to remote host: Connection refused
开始我以为是我哪里码错了，然后拿作者的代码来跑，并放到虚拟机上跑，发现并不是自己的问题，那只能这样测试了:
复制
# telnet 192.168.10.3 90
Trying 192.168.10.3...
Connected to 192.168.10.3.
Escape character is '^]'.
出现这样的字眼后，容器和宿主机之间就可以通信了.
七天用 Go 写个 docker（第一天） | Go 技术论坛 (learnku.com) 。
使用 GoLang 从零开始写一个 Docker（概念篇）-- 《自己动手写 Docker》读书笔记 - 掘金 (juejin.cn) 。
编译带有 AUFS 支持的 WSL 内核 - 徐天乐 :: 个人博客 (xtlsoft.top) 。
如何让WSL2使用自己编译的内核 - 知乎 (zhihu.com) 。
goland时间格式化time.Now().Format_golang time.now().format_好狗不见的博客-CSDN博客 。
自己动手写Docker系列 -- 5.7实现通过容器制作镜像 - 掘金 (juejin.cn) 。
iptable端口重定向 MASQUERADE_tycoon1988的博客-CSDN博客 。
最后此篇关于自己动手写Docker学习笔记的文章就讲到这里了,如果你想了解更多关于自己动手写Docker学习笔记的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。
29
4
0
关闭。这个问题是opinion-based .它目前不接受答案。 想要改进这个问题？ 更新问题，以便 editing this post 可以用事实和引用来回答它. 关闭 9 年前。 Improve
介绍篇 什么是MiniApis？ MiniApis的特点和优势 MiniApis的应用场景 环境搭建 系统要求 安装MiniApis 配置开发环境 基础概念 MiniApis架构概述
我正在从“JavaScript 圣经”一书中学习 javascript，但我遇到了一些困难。我试图理解这段代码: function checkIt(evt) { evt = (evt) ? e
package com.fastone.www.javademo.stringintern; /** * * String.intern()是一个Native方法， * 它的作用是：如果字
您会推荐哪些资源来学习 AppleScript。我使用具有 Objective-C 背景的传统 C/C++。 我也在寻找有关如何更好地开发和从脚本编辑器获取更快文档的技巧。示例提示是“查找要编写脚本的
关闭。这个问题不满足Stack Overflow guidelines .它目前不接受答案。 想改善这个问题吗？更新问题，使其成为 on-topic对于堆栈溢出。 4年前关闭。 Improve thi
关闭。这个问题不满足Stack Overflow guidelines .它目前不接受答案。 想改善这个问题吗？更新问题，使其成为 on-topic对于堆栈溢出。 7年前关闭。 Improve thi
关闭。这个问题不符合 Stack Overflow guidelines 。它目前不接受答案。 想改善这个问题吗？更新问题，以便堆栈溢出为 on-topic。 6年前关闭。 Improve this
我是塞内加尔的阿里。我今年60岁(也许这是我真正的问题-笑脸!!!)。 我正在学习Flutter和Dart。今天，我想使用给定数据模型的列表(它的名称是Mortalite，请参见下面的代码)。 我尝试
关闭。这个问题是off-topic .它目前不接受答案。 想改进这个问题？ Update the question所以它是on-topic对于堆栈溢出。 9年前关闭。 Improve this que
学习 Cappuccino 的最佳来源是什么？我从事“传统”网络开发，但我对这个新框架非常感兴趣。请注意，我对 Objective-C 毫无了解。 最佳答案 如上所述，该网站是一个好地方，但还有一些其
我正在学习如何使用 hashMap，有人可以检查我编写的这段代码并告诉我它是否正确吗？这个想法是有一个在公司工作的员工列表，我想从 hashMap 添加和删除员工。 public class Staf
我正在尝试将 jQuery 与 CoffeScript 一起使用。我按照博客中的说明操作，指示使用 $ -> 或 jQuery -> 而不是 .ready() 。我玩了一下代码，但我似乎无法理解我出错
还在学习，还有很多问题，所以这里有一些。我正在进行 javascript -> PHP 转换，并希望确保这些做法是正确的。是$dailyparams->$calories = $calories;一条
我目前正在学习 SQL，以便从我们的 Magento 数据库制作一个简单的 RFM 报告，我目前可以通过导出两个查询并将它们粘贴到 Excel 模板中来完成此操作，我想摆脱 Excel 模板。 我认为
我知道我很可能会因为这个问题而受到抨击，但没有人问，我求助于你。这是否是一个正确的 javascript > php 转换 - 在我开始不良做法之前，我想知道这是否是解决此问题的正确方法。 JavaS
除了 Ruby-Doc 之外，哪些来源最适合获取一些示例和教程，尤其是关于 Ruby 中的 Tk/Tile？我发现自己更正常了 http://www.tutorialspoint.com/ruby/r
我只在第一次收到警告。这正常吗？ >>> cv=LassoCV(cv=10).fit(x,y) C:\Python27\lib\site-packages\scikit_learn-0.14.1-py
按照目前的情况，这个问题不适合我们的问答形式。我们希望答案得到事实、引用或专业知识的支持，但这个问题可能会引发辩论、争论、投票或扩展讨论。如果您觉得这个问题可以改进并可能重新打开，visit the
As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be
我是一名优秀的程序员,十分优秀！