从零开始写 Docker(五)---基于 overlayfs 实现写操作隔离

本文为从零开始写 Docker 系列第五篇，在 pivotRoot 基础上通过 overlayfs 实现写操作隔离，达到容器中写操作和宿主机互不影响。

<!--more-->

---

完整代码见：https://github.com/lixd/mydocker
欢迎 Star

---

推荐阅读以下文章对 docker 基本实现有一个大致认识：

• 核心原理：深入理解 Docker 核心原理：Namespace、Cgroups 和 Rootfs
• 基于 namespace 的视图隔离：探索 Linux Namespace：Docker 隔离的神奇背后

• 基于 cgroups 的资源限制

  • 初探 Linux Cgroups：资源控制的奇妙世界
  • 深入剖析 Linux Cgroups 子系统：资源精细管理
  • Docker 与 Linux Cgroups：资源隔离的魔法之旅
• 基于 overlayfs 的文件系统：Docker 魔法解密：探索 UnionFS 与 OverlayFS
• 基于 veth pair、bridge、iptables 等等技术的 Docker 网络：揭秘 Docker 网络：手动实现 Docker 桥接网络

---

开发环境如下：

root@mydocker:~# lsb_release -a
No LSB modules are available.
Distributor ID:    Ubuntu
Description:    Ubuntu 20.04.2 LTS
Release:    20.04
Codename:    focal
root@mydocker:~# uname -r
5.4.0-74-generic

---

注意：需要使用 root 用户

1. 概述

上一篇中已经实现了使用宿主机 /root/busybox 目录作为容器的根目录，但在容器内对文件的操作仍然会直接影响到宿主机的 /root/busybox 目录。
本节要进一步进行容器和镜像隔离，实现在容器中进行的操作不会对镜像(宿主机/root/busybox目录)产生任何影响的功能。

什么是 overlayfs？

overlayfs 是 UFS 的一种实现，UnionFS 全称为 Union File System ，是一种为 Linux FreeBSD NetBSD 操作系统设计的，把其他文件系统联合到一个联合挂载点的文件系统服务。

它使用 branch 不同文件系统的文件和目录“透明地”覆盖，形成一个单一一致的文件系统。

这些 branches 或者是 read-only 或者是 read-write 的，所以当对这个虚拟后的联合文件系统进行写操作的时候，系统是真正写到了一个新的文件中。看起来这个虚拟后的联合文件系统是可以对任何文件进行操作的，但是其实它并没有改变原来的文件，这是因为 unionfs 用到了一个重要的资管管理技术叫写时复制。

写时复制（copy-on-write，下文简称 CoW），也叫隐式共享，是一种对可修改资源实现高效复制的资源管理技术。

它的思想是，如果一个资源是重复的，但没有任何修改，这时候并不需要立即创建一个新的资源，这个资源可以被新旧实例共享。

创建新资源发生在第一次写操作，也就是对资源进行修改的时候。通过这种资源共享的方式，可以显著地减少未修改资源复制带来的消耗，但是也会在进行资源修改的时候增减小部分的开销。

UnionFS，最主要的功能是将多个不同位置的目录联合挂载（union mount）到同一个目录下。

比如，我现在有两个目录 A 和 B，它们分别有两个文件：

$ tree
.
├── A
│  ├── a
│  └── x
└── B
  ├── b
  └── x

然后，我使用联合挂载的方式，将这两个目录挂载到一个公共的目录 C 上：

$ mkdir C
$ mount -t aufs -o dirs=./A:./B none ./C

这时，我再查看目录 C 的内容，就能看到目录 A 和 B 下的文件被合并到了一起：

$ tree ./C
./C
├── a
├── b
└── x

可以看到，在这个合并后的目录 C 里，有 a、b、x 三个文件，并且 x 文件只有一份。这，就是“合并”的含义。

这就是联合文件系统，目的就是将多个文件联合在一起成为一个统一的视图。

UFS 有多种实现，例如 AUFS、Overlayfs 等，这里使用比较主流的 Overlayfs。

关于 Overlayfs 详细介绍可以看一下这篇文章：Docker 魔法解密：探索 UnionFS 与 OverlayFS

里面详细介绍了 overlayfs 各个特性，以及 docker 中是如何使用 Overlayfs 的。

这里对需要用到部分做简要说明:

首先，overlayfs 一般分为 lower、upper、merged 和 work 4个目录。

• lower 只读层，该层数据不会被修改
• upper 可读写层，所有修改都发生在这一层，即使是修改的 lower 中的数据。
• merged 视图层，可以看到 lower、upper 中的所有内容
• work 则是 overlayfs 内部使用

在本文实现中使用我们的镜像目录(busybox 目录) 作为 lower 目录，这样可以保证镜像内容部被修改。

merged 目录由于可以看到全部内容，因此作为容器 rootfs 目录，即 pivotRoot 会切换到 merged 目录。

upper 目录则是用于保存容器中的修改，因为 overlayfs 中所有修改都会发生在这里。

---

如果你对云原生技术充满好奇，想要深入了解更多相关的文章和资讯，欢迎关注微信公众号。

搜索公众号【探索云原生】即可订阅

---

2. Mount Overlayfs

Docker 在使用镜像启动一个容器时，会新建2个layer: write layer和 container-init layer。

write layer是容器唯一的 可读写层；而 container-init layer 是为容器新建的只读层，用来存储容器启动时传入的系统信息(不过在实际的场景下，它们并不是以write layer和container-init layer命名的)。最后把write layer、container-init layer 和相关镜像的 layers 都 mount 到一个 mnt 目录下，然后把这个 mnt 目录作为容器启动的根目录。

同样的，我们在容器启动前，也需要先 mount 好 overlayfs 目录，然后执行 privotRoot 时直接切换到 mount 好的 overlayfs merge 目录即可。

NewWorkSpace 函数是用来创建容器文件系统的，它包括 createLower、createDirs和mountOverlayFS。
分为以下步骤：

• 1）准备 busybox 目录，之前都是手动解压准备 /root/busybox 目录，这次把解压逻辑加入到代码中。只需要准备好 busybox.tar 文件即可。容器启动时自动将 busybox.tar 解压到 busybox 目录下，作为容器的只读层。
• 2）准备 overlayfs 目录，创建好挂载 overlayfs 需要的 upper、work 和 merged 目录
• 3）实现 mount overlayfs，将 merged 目录作为挂载点，然后把 busybox、upper 挂载到 merged 目录。
• 4）更新 pivotRoot 调用目录，将 rootfs 从宿主机目录 root/busybox 切换到上一步中挂载的／root/merged 目录
• 最后 NewParentProcess 函数中将容器使用的宿主机目录 root/busybox 替换成／root/merged。

// NewWorkSpace Create an Overlay2 filesystem as container root workspace
func NewWorkSpace(rootPath string) {
    createLower(rootPath)
    createDirs(rootPath)
    mountOverlayFS(rootPath)
}

// createLower 将busybox作为overlayfs的lower层
func createLower(rootURL string) {
    // 把busybox作为overlayfs中的lower层
    busyboxURL := rootURL + "busybox/"
    busyboxTarURL := rootURL + "busybox.tar"
    // 检查是否已经存在busybox文件夹
    exist, err := PathExists(busyboxURL)
    if err != nil {
        log.Infof("Fail to judge whether dir %s exists. %v", busyboxURL, err)
    }
    // 不存在则创建目录并将busybox.tar解压到busybox文件夹中
    if !exist {
        if err := os.Mkdir(busyboxURL, 0777); err != nil {
            log.Errorf("Mkdir dir %s error. %v", busyboxURL, err)
        }
        if _, err := exec.Command("tar", "-xvf", busyboxTarURL, "-C", busyboxURL).CombinedOutput(); err != nil {
            log.Errorf("Untar dir %s error %v", busyboxURL, err)
        }
    }
}

// createDirs 创建overlayfs需要的的upper、worker目录
func createDirs(rootURL string) {
    upperURL := rootURL + "upper/"
    if err := os.Mkdir(upperURL, 0777); err != nil {
        log.Errorf("mkdir dir %s error. %v", upperURL, err)
    }
    workURL := rootURL + "work/"
    if err := os.Mkdir(workURL, 0777); err != nil {
        log.Errorf("mkdir dir %s error. %v", workURL, err)
    }
}

// mountOverlayFS 挂载overlayfs
func mountOverlayFS(rootURL string, mntURL string) {
    // mount -t overlay overlay -o lowerdir=lower1:lower2:lower3,upperdir=upper,workdir=work merged
    // 创建对应的挂载目录
    if err := os.Mkdir(mntURL, 0777); err != nil {
        log.Errorf("Mkdir dir %s error. %v", mntURL, err)
    }
    // 拼接参数
    // e.g. lowerdir=/root/busybox,upperdir=/root/upper,workdir=/root/merged
    dirs := "lowerdir=" + rootURL + "busybox" + ",upperdir=" + rootURL + "upper" + ",workdir=" + rootURL + "work"
    // dirs := "dirs=" + rootURL + "writeLayer:" + rootURL + "busybox"
    cmd := exec.Command("mount", "-t", "overlay", "overlay", "-o", dirs, mntURL)
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr
    if err := cmd.Run(); err != nil {
        log.Errorf("%v", err)
    }
}

接下来，在 NewParentProcess 函数中将容器使用的宿主机目录／root/busybox 替换成root/mnt 。这样 ，使用 OverlayFS 系统启动容器的代码就完成了。

func NewParentProcess(tty bool) (*exec.Cmd, *os.File) {
    // 省略其他代码
    cmd.ExtraFiles = []*os.File{readPipe}
    mntURL := "/root/merged/"
    rootURL := "/root/"
    NewWorkSpace(rootURL, mntURL)
    cmd.Dir = mntURL
    return cmd, writePipe
}

3. Unmount Overlayfs

Docker 会在删除容器的时候，把容器对应 WriteLayer 和 Container-init Layer 删除，而保留镜像所有的内容。本节中在容器退出的时候也会删除 upper、work 和 merged 目录只保留作为镜像的 lower 层目录即 busybox。

具体步骤如下：

• 1）unmount overlayfs：将/root/merged目录挂载解除
• 2）删除其他目录：删除之前为 overlayfs 准备的 upper、work、merged 目录

由于 overlayfs 的特性，所有修改操作都发生在 upper 目录，因此目录删除后容器对文件系统的更改，就都已经抹去了。

DeleteWorkSpace 函数包括 umountOverlayFS 和 deleteDirs。

// DeleteWorkSpace Delete the AUFS filesystem while container exit
func DeleteWorkSpace(rootURL string, mntURL string) {
    umountOverlayFS(mntURL)
    deleteDirs(rootURL)
}

func umountOverlayFS(mntURL string) {
    cmd := exec.Command("umount", mntURL)
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr
    if err := cmd.Run(); err != nil {
        log.Errorf("%v", err)
    }
    if err := os.RemoveAll(mntURL); err != nil {
        log.Errorf("Remove dir %s error %v", mntURL, err)
    }
}

func deleteDirs(rootURL string) {
    writeURL := rootURL + "upper/"
    if err := os.RemoveAll(writeURL); err != nil {
        log.Errorf("Remove dir %s error %v", writeURL, err)
    }
    workURL := rootURL + "work"
    if err := os.RemoveAll(workURL); err != nil {
        log.Errorf("Remove dir %s error %v", workURL, err)
    }
}

4. 测试

首先将busybox.tar 放到 /root 目录下：

$ ls
busybox.tar

然后启动我们的容器

root@mydocker:~/feat-overlayfs/mydocker# ./mydocker run -it /bin/sh
{"level":"info","msg":"resConf:\u0026{ 0  }","time":"2024-01-16T13:36:38+08:00"}
{"level":"info","msg":"enter NewWorkSpace","time":"2024-01-16T13:36:38+08:00"}
{"level":"info","msg":"enter createLower","time":"2024-01-16T13:36:38+08:00"}
{"level":"info","msg":"busybox:/root/busybox busybox.tar:/root/busybox.tar","time":"2024-01-16T13:36:38+08:00"}

再次查看宿主机的 /root 目录：

root@mydocker:~# ls /root
busybox  busybox.tar  merged  upper  work

可以看到，多了几个目录：busybox、merged、upper、work。

在容器中新建一个文件：

/ # echo KubeExplorer > tmp/hello.txt
/ # ls /tmp
hello.txt
/ # cat /tmp/hello.txt
KubeExplorer

然后切换到宿主机：

root@mydocker:~# ls busybox/tmp
root@mydocker:~# ls upper/tmp
hello.txt
root@mydocker:~# ls merged/tmp
hello.txt

可以发现，这个新创建的文件居然不在 busybox 目录，而是在 upper 中，然后 merged 目录中也可以看到。

这就是 overlayfs 的作用了。

写操作不会修改 lower 目录(busybox)，而是发生在 upper 中，即在 upper 中 tmp 目录并创建了 hello.txt 文件。

而 merged 作为挂载点自然是能够看到 hello.txt 文件的。

最后在容器中执行 exit 退出容器。

/ # exit

然后再次查看宿主机上的 root 文件夹内容。

root@mydocker:~# ls /root
busybox  busybox.tar

可以看到，upper、work 和 merged 目录被删除，作为镜像的 busybox 层仍然保留。

并且 busybox 中的内容未被修改：

root@mydocker:~# ls /root/busybox
bin  dev  etc  home  proc  root  sys  tmp  usr  var

至此，基本实现了 Docker 的效果：

• 1）镜像中的文件不会被修改
• 2）容器中的修改不会影响宿主机
• 3）容器退出后，修改内容丢失

5. 小结

overlayfs 引入具体流程如下：

• 1）自动解压 busybox.tar 到 busybox 作为 lower 目录，类似 docker 镜像层
• 2）容器启动前准备好 lower、upper、work、merged 目录并 mount 到 merged 目录

• 3）容器启动后使用 pivotRoot 将 rootfs 切换到 merged 目录

  • 后续容器中的修改由于 overlayfs 的特性，都会发生在 upper 目录中，而不会影响到 lower 目录
• 4）容器停止后 umount 并移除upper、work、merged 目录

---

---

如果你对云原生技术充满好奇，想要深入了解更多相关的文章和资讯，欢迎关注微信公众号。

搜索公众号【探索云原生】即可订阅

---

最后在推荐一下 Docker 魔法解密：探索 UnionFS 与 OverlayFS

---

完整代码见：https://github.com/lixd/mydocker
欢迎 Star

相关代码见 feat-overlayfs 分支,测试脚本如下：

需要提前在 /root 目录准备好 busybox.tar 文件，具体看上一篇文章第二节。

# 克隆代码
git clone -b feat-overlayfs https://github.com/lixd/mydocker.git
cd mydocker
# 拉取依赖并编译
go mod tidy
go build .
# 测试 查看文件系统是否变化
./mydocker run -it  /bin/ls