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

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

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

推荐阅读以下文章对 docker 基本实现有一个大致认识：
- 核心原理：深入理解 Docker 核心原理：Namespace、Cgroups 和 Rootfs
- 基于 namespace 的视图隔离：探索 Linux Namespace：Docker 隔离的神奇背后
- 基于 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
```
相关阅读:
计算机毕业设计Java校园摄影爱好者交流网站(源码+系统+mysql数据库+Lw文档）
Android Retrofit 高级使用与原理
 6、JVM-JVM调优工具与实战
 【Linux】题解：Linux环境基础开发工具——Git
YOLO物体检测系列3：YOLOV3改进解读
 echarts实现柱图的下钻功能
 前端工程化02-复习jQuery当中的插件开发
 LVS-NAT模式部署
 Java 创建线程的方法
 ROS从入门到精通9-1：项目实战之智能跟随机器人原理与实现
原文地址：https://www.cnblogs.com/KubeExplorer/p/18068099

1. 概述

什么是 overlayfs？

2. Mount Overlayfs

3. Unmount Overlayfs

4. 测试

5. 小结