从零开始写 Docker(十四)---重构:实现容器间 rootfs 隔离

Docker 镜像读写层核心概念:rootfs、Union mount、image以及layser原理详解 阅读详情

refacotr-isolate-rootfs.png

本文为从零开始写 Docker 系列第十四篇,实现容器间的 rootfs 隔离,使得多个容器间互不影响。


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

推荐阅读以下文章对 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. 概述

虽然之前通过 pivotRoot、overlayfs 实现了容器和宿主机的 rootfs 隔离,但是多个容器还是共用的一个rootfs,多容器之间会互相影响。

之前容器都是用的宿主机上的 /root/merged 目录作为自己的 rootfs,当启动多个容器时可写层会互相影响。

本篇通过为每个容器单独准备一个 rootfs 来实现隔离,使得我们多个容器之间互不影响。

2. 实现

为了实现该功能,需要做以下工作:

  • 修改 mydocker commit 命令,实现对不同容器进行打包镜像的功能。
  • 修改 mydocker run 命令,用户可以指定不同镜像,并为每个容器分配单独的隔离文件系统
    • 根据镜像名称找到对应 tar 文件,解压后作为overlay 中的 lower 目录进行挂载
  • 修改 mydocker rm 命令,删除容器时顺带删除文件系统

这三处调整实际上都是对宿主机上容器 rootfs 目录的调整,把 rootfs 从原来的 /root/merged 调整为 /var/lib/mydocker/overlay2/{containerID}/merged ,这样实现容器之间的隔离。

docker 也是使用的var/lib/docker/overlay2/{containerID}/merged 目录作为 rootfs.可以使用docker inspect {containerID} -f '{{json .GraphDriver}}' 命令查看。

2.1 commit 命令更新

之前 commit 命令直接把/root/merged 目录压缩为 tar 作为镜像,现在需要根据 containerID 以/var/lib/mydocker/overlay2/{containerID}/merged 格式来拼接目录。

首先,在 main_command.go 文件中修改 commitCommand,将用户输入参数改为 containerID 和 imageName,并调用 commitContainer 方法实现 commit 操作。

var commitCommand = cli.Command{
	Name:  "commit",
	Usage: "commit container to image,e.g. mydocker commit 123456789 myimage",
	Action: func(context *cli.Context) error {
		if len(context.Args()) < 2 {
			return fmt.Errorf("missing container name and image name")
		}
		containerID := context.Args().Get(0)
		imageName := context.Args().Get(1)
		return commitContainer(containerID, imageName)
	},
}

然后 commitContainer 中调整一下压缩路径,根据 containerID 拼接要压缩的目录

var ErrImageAlreadyExists = errors.New("Image Already Exists")

func commitContainer(containerID, imageName string) error {
	mntPath := utils.GetMerged(containerID)
	imageTar := utils.GetImage(imageName)
	exists, err := utils.PathExists(imageTar)
	if err != nil {
		return errors.WithMessagef(err, "check is image [%s/%s] exist failed", imageName, imageTar)
	}
	if exists {
		return ErrImageAlreadyExists
	}
	log.Infof("commitContainer imageTar:%s", imageTar)
	if _, err = exec.Command("tar", "-czf", imageTar, "-C", mntPath, ".").CombinedOutput(); err != nil {
		return errors.WithMessagef(err, "tar folder %s failed", mntPath)
	}
	return nil
}

2.2 run 命令更新, 实现隔离文件系统

run 命令改动比较大, 需要把涉及到目录的都进行调整。

改动点:

  • 1)runCommand 命令中添加 imageName 参数,让用户可以指定镜像启动容器
  • 2)启动容器时, rootfs 部分需要根据 containerID 拼接目录
runCommand

runCommand 命令中添加 imageName 作为第一个参数输入

var runCommand = cli.Command{
	Action: func(context *cli.Context) error {
		// 省略其他内容
		// get image name
		imageName := cmdArray[0]
		cmdArray = cmdArray[1:]

		tty := context.Bool("it")
		detach := context.Bool("d")

		// Run方法增加对应参数
		Run(tty, cmdArray, resConf, volume, containerName, imageName)
		return nil
	},
}

相关方法都要增加 imageName 参数:

func Run(tty bool, comArray []string, res *subsystems.ResourceConfig, volume, containerName, imageName string) {
	containerId := container.GenerateContainerID() // 生成 10 位容器 id

	// start container
	parent, writePipe := container.NewParentProcess(tty, volume, containerId, imageName)
	if parent == nil {
		log.Errorf("New parent process error")
		return
	}
	if err := parent.Start(); err != nil {
		log.Errorf("Run parent.Start err:%v", err)
		return
	}

	// record container info
	err := container.RecordContainerInfo(parent.Process.Pid, comArray, containerName, containerId)
	if err != nil {
		log.Errorf("Record container info error %v", err)
		return
	}

	// 创建cgroup manager, 并通过调用set和apply设置资源限制并使限制在容器上生效
	cgroupManager := cgroups.NewCgroupManager("mydocker-cgroup")
	defer cgroupManager.Destroy()
	_ = cgroupManager.Set(res)
	_ = cgroupManager.Apply(parent.Process.Pid, res)

	// 在子进程创建后才能通过pipe来发送参数
	sendInitCommand(comArray, writePipe)
	if tty { // 如果是tty,那么父进程等待,就是前台运行,否则就是跳过,实现后台运行
		_ = parent.Wait()
		container.DeleteWorkSpace(containerId, volume)
		container.DeleteContainerInfo(containerId)
	}
}
rootfs 相关调整

rootfs 相关目录定义成变量,并提供相应的 Get 方法,调用时指定 containerID 即可拿到对应目录。

// 容器相关目录
const (
	ImagePath       = "/var/lib/mydocker/image/"
	RootPath        = "/var/lib/mydocker/overlay2/"
	lowerDirFormat  = RootPath + "%s/lower"
	upperDirFormat  = RootPath + "%s/upper"
	workDirFormat   = RootPath + "%s/work"
	mergedDirFormat = RootPath + "%s/merged"
	overlayFSFormat = "lowerdir=%s,upperdir=%s,workdir=%s"
)

func GetRoot(containerID string) string { return RootPath + containerID }

func GetImage(imageName string) string { return fmt.Sprintf("%s%s.tar", ImagePath, imageName) }

func GetLower(containerID string) string {
	return fmt.Sprintf(lowerDirFormat, containerID)
}

func GetUpper(containerID string) string {
	return fmt.Sprintf(upperDirFormat, containerID)
}

func GetWorker(containerID string) string {
	return fmt.Sprintf(workDirFormat, containerID)
}

func GetMerged(containerID string) string { return fmt.Sprintf(mergedDirFormat, containerID) }

func GetOverlayFSDirs(lower, upper, worker string) string {
	return fmt.Sprintf(overlayFSFormat, lower, upper, worker)
}

另外则是 NewWorkSpace 和 DeleteWorkSpace 这两个方法以及其内部的一系列方法涉及到的路径全改成动态的,根据 containerID 进行拼接:

这里贴一下 NewWorkSpace 和 DeleteWorkSpace 两个方法:

// NewWorkSpace Create an Overlay2 filesystem as container root workspace
/*
1)创建lower层
2)创建upper、worker层
3)创建merged目录并挂载overlayFS
4)如果有指定volume则挂载volume
*/
func NewWorkSpace(volume, imageName, containerName string) {
	err := createLower(imageName)
	if err != nil {
		log.Errorf("createLower err:%v", err)
		return
	}
	err = createUpperWorker(containerName)
	if err != nil {
		log.Errorf("createUpperWorker err:%v", err)
		return
	}
	err = mountOverlayFS(containerName)
	if err != nil {
		log.Errorf("mountOverlayFS err:%v", err)
		return
	}
	if volume != "" {
		volumeURLs := volumeUrlExtract(volume)
		if len(volumeURLs) == 2 && volumeURLs[0] != "" && volumeURLs[1] != "" {
			err = mountVolume(containerName, volumeURLs)
			if err != nil {
				log.Errorf("mountVolume err:%v", err)
				return
			}
		} else {
			log.Infof("volume parameter input is not correct.")
		}
	}
}
// DeleteWorkSpace Delete the OverlayFS filesystem while container exit
/*
和创建相反
1)有volume则卸载volume
2)卸载并移除merged目录
3)卸载并移除upper、worker层
*/
func DeleteWorkSpace(volume, containerName string) error {
	// 如果指定了volume则需要先umount volume
	if volume != "" {
		volumeURLs := volumeUrlExtract(volume)
		length := len(volumeURLs)
		if length == 2 && volumeURLs[0] != "" && volumeURLs[1] != "" {
			err := umountVolume(containerName, volumeURLs)
			if err != nil {
				return errors.Wrap(err, "umountVolume")
			}
		}
	}
	// 然后umount整个容器的挂载点
	err := umountOverlayFS(containerName)
	if err != nil {
		return errors.Wrap(err, "umountOverlayFS")
	}
	// 最后移除相关文件夹
	err = removeUpperWorker(containerName)
	if err != nil {
		return errors.Wrap(err, "removeUpperWorker")
	}
	return nil
}

至此,基本改动完成了,创建出的每个容器都会单独在/var/lib/mydocker/overlay2/ 目录下生成一个 rootfs 目录,这样就避免了多个容器之间互相影响。

2.3 更新 rm 命令

之前,由于对应的文件系统因为是共用的,所以没有删除, rm 命令只把容器信息删了,这次对 rm 命令进行调整,删除时也把文件系统删了。

func removeContainer(containerId string, force bool) {
	containerInfo, err := getInfoByContainerId(containerId)
	if err != nil {
		log.Errorf("Get container %s info error %v", containerId, err)
		return
	}

	switch containerInfo.Status {
	case container.STOP: // STOP 状态容器直接删除即可
		// 先删除配置目录,再删除rootfs 目录
		if err = container.DeleteContainerInfo(containerId); err != nil {
			log.Errorf("Remove container [%s]'s config failed, detail: %v", containerId, err)
			return
		}
		container.DeleteWorkSpace(containerId, containerInfo.Volume)
	case container.RUNNING: // RUNNING 状态容器如果指定了 force 则先 stop 然后再删除
		if !force {
			log.Errorf("Couldn't remove running container [%s], Stop the container before attempting removal or"+
				" force remove", containerId)
			return
		}
		log.Infof("force delete running container [%s]", containerId)
		stopContainer(containerId)
		removeContainer(containerId, force)
	default:
		log.Errorf("Couldn't remove container,invalid status %s", containerInfo.Status)
		return
	}
}

增加了下面这一句:

container.DeleteWorkSpace(containerId, containerInfo.Volume)

3. 测试

rootfs 调整

用 busybox.tar 镜像启动一个容器,然后查看/var/lib/mydocker/overlay2/ 目录下是否生成对应内容。

首先在/var/lib/mydocker/image/目录准备好镜像

root@mydocker:~# mv busybox.tar /var/lib/mydocker/image/

然后使用该镜像启动容器

root@mydocker:~/refactor-isolate-rootfs/mydocker# go build .
root@mydocker:~/refactor-isolate-rootfs/mydocker# ./mydocker run -d -name rootfs busybox top
{"level":"info","msg":"createTty false","time":"2024-02-22T13:34:12+08:00"}
{"level":"info","msg":"resConf:\u0026{ 0  }","time":"2024-02-22T13:34:12+08:00"}
{"level":"info","msg":"lower:/var/lib/mydocker/overlay2/5341624332/lower image.tar:/var/lib/mydocker/image/busybox.tar","time":"2024-02-22T13:34:12+08:00"}
{"level":"info","msg":"mount overlayfs: [/usr/bin/mount -t overlay overlay -o lowerdir=/var/lib/mydocker/overlay2/5341624332/lower,upperdir=/var/lib/mydocker/overlay2/5341624332/upper,workdir=/var/lib/mydocker/overlay2/5341624332/work /var/lib/mydocker/overlay2/5341624332/merged]","time":"2024-02-22T13:34:12+08:00"}
{"level":"info","msg":"command all is top","time":"2024-02-22T13:34:12+08:00"}

查看容器

root@mydocker:~/refactor-isolate-rootfs/mydocker# ./mydocker ps
ID           NAME        PID         STATUS      COMMAND     CREATED
5341624332   rootfs      219016      running     top         2024-02-22 13:34:12

查看/var/lib/mydocker/overlay2 目录下是否生成对应内容

root@mydocker:/var/lib/mydocker/overlay2# cd /var/lib/mydocker/overlay2/5341624332
root@mydocker:/var/lib/mydocker/overlay2/5341624332# ls
lower  merged  upper  work
root@mydocker:/var/lib/mydocker/overlay2/5341624332# ls lower
bin  dev  etc  home  proc  root  sys  tmp  usr  var
root@mydocker:/var/lib/mydocker/overlay2/5341624332# ls merged/
bin  dev  etc  home  proc  root  sys  tmp  usr  var

可以看到,在/var/lib/mydocker/overlay2/{containerID} 目录下生成了,lower、merged、upper、work 等 overlay2 目录。

其中 lower 中的内容由镜像解压得到,merged 则是容器 rootfs 挂载点。

然后进入容器创建文件

root@mydocker:~/refactor-isolate-rootfs/mydocker# ./mydocker exec 5341624332 /bin/sh
{"level":"info","msg":"container pid:219016 command:/bin/sh","time":"2024-02-22T13:37:42+08:00"}
got mydocker_pid=219016
got mydocker_cmd=/bin/sh
/ # echo KubeExplorer > a.txt
/ # cat a.txt
KubeExplorer

接着到对应 merged 目录查看文件是否存在

root@mydocker:/var/lib/mydocker/overlay2/5341624332# ls merged/
a.txt  bin  dev  etc  home  proc  root  sys  tmp  usr  var
root@mydocker:/var/lib/mydocker/overlay2/5341624332# cat merged/a.txt
KubeExplorer

至此,说明 rootfs 调整一切正常。

commit 命令

接下来测试一下 mydocker commit 命令,把刚才启动的容器提交为镜像。

root@mydocker:~/refactor-isolate-rootfs/mydocker# ./mydocker ps
ID           NAME        PID         STATUS      COMMAND     CREATED
5341624332   rootfs      219016      running     top         2024-02-22 13:34:12
root@mydocker:~/refactor-isolate-rootfs/mydocker# ./mydocker commit 5341624332 busybox-with-custom
{"level":"info","msg":"commitContainer imageTar:/var/lib/mydocker/image/busybox-with-custom.tar","time":"2024-02-22T13:43:33+08:00"}

然后查看 var/lib/mydocker/image/ 目录是否生成了对应的镜像文件

root@mydocker:/var/lib/mydocker/overlay2/5341624332# cd /var/lib/mydocker/image/
root@mydocker:/var/lib/mydocker/image# ls
busybox-with-custom.tar  busybox.tar

busybox-with-custom.tar 就是 commit 命令生成的镜像。

接下来使用该镜像启动一个容器,查看之前创建的文件是否存在

root@mydocker:~/refactor-isolate-rootfs/mydocker# ./mydocker run -d -name rootfs2 busybox-with-custom top
{"level":"info","msg":"createTty false","time":"2024-02-22T13:45:53+08:00"}
{"level":"info","msg":"resConf:\u0026{ 0  }","time":"2024-02-22T13:45:53+08:00"}
{"level":"info","msg":"lower:/var/lib/mydocker/overlay2/8118341786/lower image.tar:/var/lib/mydocker/image/busybox-with-custom.tar","time":"2024-02-22T13:45:53+08:00"}
{"level":"info","msg":"mount overlayfs: [/usr/bin/mount -t overlay overlay -o lowerdir=/var/lib/mydocker/overlay2/8118341786/lower,upperdir=/var/lib/mydocker/overlay2/8118341786/upper,workdir=/var/lib/mydocker/overlay2/8118341786/work /var/lib/mydocker/overlay2/8118341786/merged]","time":"2024-02-22T13:45:53+08:00"}
{"level":"info","msg":"command all is top","time":"2024-02-22T13:45:53+08:00"}

进入容器查看内容

root@mydocker:~/refactor-isolate-rootfs/mydocker# ./mydocker ps
ID           NAME        PID         STATUS      COMMAND     CREATED
5341624332   rootfs      219016      running     top         2024-02-22 13:34:12
8118341786   rootfs2     219109      running     top         2024-02-22 13:45:53
root@mydocker:~/refactor-isolate-rootfs/mydocker# ./mydocker exec 8118341786 /bin/sh
{"level":"info","msg":"container pid:219109 command:/bin/sh","time":"2024-02-22T13:46:14+08:00"}
got mydocker_pid=219109
got mydocker_cmd=/bin/sh
/ # cat a.txt
KubeExplorer

可以看到,提交的镜像中包含了我们新建的 a.txt 文件,说明 commit 命令也是正常的。

rm 命令

最后测试一下 mydocker rm 命令,能否删除镜像配置和对应的 rootfs 目录。

ps 命令拿到 id

root@mydocker:~/refactor-isolate-rootfs/mydocker# ./mydocker ps
ID           NAME        PID         STATUS      COMMAND     CREATED
5341624332   rootfs      219016      running     top         2024-02-22 13:34:12
8118341786   rootfs2     219109      running     top         2024-02-22 13:45:53

根据 id 删除容器

root@mydocker:~/refactor-isolate-rootfs/mydocker# ./mydocker rm 5341624332 -f
{"level":"info","msg":"force delete running container [5341624332]","time":"2024-02-22T13:47:36+08:00"}
{"level":"info","msg":"umountOverlayFS,cmd:/usr/bin/umount /var/lib/mydocker/overlay2/5341624332/merged","time":"2024-02-22T13:47:36+08:00"}

查看一下 /var/lib/mydocker/overlay2 中的 rootfs 目录是否删除

cd /var/lib/mydocker/overlay2
root@mydocker:/var/lib/mydocker/overlay2# ls

可以看到,容器相关目录都被移除了。

4. 小结

本小节主要完善了容器的文件系统,在/var/lib/mydocker/overlay2/ 目录下为每个容器单独分配一个 rootfs,避免了多容器之间互相影响。


**【从零开始写 Docker 系列】**持续更新中,搜索公众号【探索云原生】订阅,阅读更多文章。



完整代码见:https://github.com/lixd/mydocker
欢迎关注~

相关代码见 refactor-isolate-rootfs 分支,测试脚本如下:

需要提前在 /var/lib/mydocker/image 目录准备好 busybox.tar 文件,具体见第四篇第二节。

# 克隆代码
git clone -b refactor-isolate-rootfs https://github.com/lixd/mydocker.git
cd mydocker
# 拉取依赖并编译
go mod tidy
go build .
# 测试 
./mydocker run -d -name c1 busybox top
# 查看容器 Id
./mydocker ps
# stop 停止指定容器
./mydocker rm ${containerId} -f
Docker 之 bootfs 和 rootfs概述 在 Docker 技术中,理解 bootfs(boot file system)和 rootfs(root file system)的概念对于深入掌握容器技术至关重要。这两个文件系统是 Docker 镜像和容器运行的基础。 阅读详情

相关推荐

Docker生态系统全景解析:从容器化原理到PHP+MySQL实战编排

容器化(Containerization)是一种通过操作系统命名空间(Namespaces)和控制组(Cgroups)实现进程隔离与资源约束的技术范式,其核心价值在于消除环境漂移、保障应用交付一致性。它并非简单封装工具,而是重构了软件构建、分发与运行的全生命周期——镜像作为分层只读文件系统,容器作为轻量级进程沙箱,Docker Compose 则提供声明式服务编排能力。该技术已深度融入CI/CD流水线、微服务架构及云原生基础设施,广泛应用于PHP、Python、Node.js等多语言栈的本地开发、测试环境搭

chouzu8463的博客 388

Docker Base:Rootfs

在 Linux 操作系统中,这两部分是分开存放的,操作系统只有在开机启动时才会加载指定版本的内核镜像。。所以宿主机操作系统的内核,它对于该机器上的所有容器来说是一个全局变量,牵一发而动全身。由于 rootfs 的存在,容器才有了一个被反复宣传至今的重要特性:一致性。由于 rootfs 里打包的不只是应用,而是整个操作系统的文件和目录,也就意味着,应用以及它运行所需要的所有依赖,都被封装在了一起。有了容器镜像“打包操作系统”的能力,这个最基础的依赖环境也终于变成了应用沙盒的一部分。

summer_fish的专栏 1005

SpringBoot容器化部署实战:从裸机到Docker的工程范式升级

容器化是现代Java应用交付的核心范式,其本质在于将运行环境与代码打包为可验证、可复制、可回滚的原子单元。相比裸机部署依赖人工对齐JDK版本、时区、内核参数等易漂移配置,Docker通过镜像固化rootfs、隔离进程资源、解耦构建与运行,显著降低环境不确定性风险。SpringBoot项目尤其受益于容器化——它天然适配分层镜像、健康检查与配置外置机制,结合openjdk:17-jre-slim-bookworm等生产就绪基础镜像,可实现跨PVE、K8s等平台的一致性交付。本文聚焦SpringBoot与Dock

weixin_33743703的博客 378

【云原生生态圈】:Docker核心技术全面总结

本文将分别讲解什么是Docker,如何安装Docker,Docker的镜像操作,Docker容器操作,以实战为线索,逐步深入Docker相关知识,打造完整的Docker学习体系,可查阅,可复习,建议收藏。

Learning_xzj的博客 1万+

Docker底层原理与生产级实践:从内核隔离到镜像安全

容器化是现代软件交付的核心范式,其本质依托Linux内核的namespaces进程隔离、cgroups资源控制与OverlayFS分层存储三大机制。理解这些底层原理,才能真正掌握Docker为何能实现轻量级虚拟化、环境一致性与快速分发。技术价值在于解耦开发与运行环境、加速CI/CD流水线、支撑微服务弹性伸缩。典型应用场景包括本地开发环境复现、Kubernetes集群应用封装、私有镜像仓库搭建及多阶段构建优化。本文深入剖析Docker Engine、containerd与runc的分层架构,并结合Ubuntu

weixin_33737134的博客 391

Spring Boot+Vue项目Docker容器化实战指南

容器化技术通过Docker实现环境隔离与快速部署,已成为现代应用开发的标准实践。其核心原理是利用操作系统级虚拟化技术打包应用及其依赖,形成轻量级、可移植的容器镜像。在微服务架构下,Docker Compose工具能有效管理多容器应用的编排与通信。本文以Spring Boot后端+Vue前端的典型全栈项目为例,详解容器化部署全流程,包括多阶段构建优化镜像体积、Nginx路由配置解决前后端分离问题,以及生产环境下的健康检查与资源限制设置。特别针对国内开发者提供了Maven/NPM镜像加速方案,并分享容器网络通信

weixin_34348805的博客 361

Docker容器技术原理(三)rootfs

前言 我们之前介绍过了 Linux 最基础的两种技术,Namespace 和 Cgroups。Namespace 的作用是隔离,它可以让进程只能看到 Namespace 里面的世界;Cgroups 的作用是限制,给这个世界围上了一堵墙。这样,这个进程便真的与世隔绝了。 现在世界已经有了墙,那么如果容器低头看向了地面,它能看到什么呢?或者说,容器里的进程看到的文件系统又是什么样子的呢? Change Root 你可能会说这是一个 Mount Namespace 的问题,容器里的应用进程,理应看到一份完

傅红雪的专栏 3194

Docker Engine底层原理与企业级容器排错实战

容器技术本质是Linux内核能力的封装,Docker Engine并非单一软件,而是由dockerd、containerd和runc构成的分层运行时协议栈。其核心依赖cgroup、namespace、overlayfs等内核机制,决定了容器隔离性、资源控制与镜像分层行为。理解这一原理,是解决‘docker run失败’‘镜像拉取异常’‘Kubernetes节点NotReady’等高频问题的技术根基。在云原生落地中,它直接关联Ubuntu安装docker的版本兼容性、阿里云ECS预装Docker的运行时适配、

weixin_34242331的博客 488

【mydocker】容器的进阶[ 4 ]

docker的-d后台运行,commit打包为镜像,ps,logs,exec,rm,-e命令以及容器间隔离。

weixin_73815624的博客 1780

别再傻傻分不清了!K8s节点上docker、ctr、crictl命令到底该用哪个?(附场景对照表)

本文深入解析Kubernetes节点运维中docker、ctr和crictl命令的区别与适用场景,帮助开发者正确选择工具进行容器管理。通过详细的对比表格和实际案例,揭示各命令的设计目标、权限隔离及最佳实践,提升K8s生产环境运维效率。

weixin_30788239的博客 457

Ubuntu 16.04 + Docker 安全审计实战:Docker Bench for Security 精准加固指南

Docker 安全审计是容器化生产环境的基础保障,其核心在于配置合规性验证而非漏洞扫描。基于 CIS Docker Benchmark 的 Docker Bench for Security 工具,以 Bash 脚本形式实现轻量、可靠、低依赖的配置检查,特别适配 Ubuntu 16.04 这类 EOL 但仍在工业场景广泛使用的系统。它深度解析 daemon.json 配置、校验 auditd 日志规则覆盖、验证 docker.sock 权限与 systemd 服务状态,将抽象安全标准转化为可执行的工程动作。

weixin_30340617的博客 404

2020容器技术演进:从隔离机制到云原生操作系统

容器技术已超越轻量级进程隔离的初级概念,演进为支撑大规模分布式系统的云原生基础设施核心。其底层依赖Linux Namespaces、Cgroups与Rootfs的深度协同,而真实生产中三者交互失效(如cgroups v1 swap限制缺失、PID namespace嵌套断层、musl/glibc ABI不兼容)常引发P99延迟飙升、进程统计失真或GPU驱动加载失败等典型故障。随着OCI/CRI/CNI标准成熟及eBPF、Service Mesh、Serverless容器化落地,运维重心从语法操作转向运行时治

dingguayi7025的博客 415

Docker生态系统组件解析:从dockerd到runc的分层架构

容器技术本质是操作系统内核能力(namespaces、cgroups、overlayfs)的封装与编排。Docker并非单一工具,而是由dockerd、containerd、runc、buildkit、docker-compose和registry构成的标准化分层系统——runc作为OCI兼容的执行器调用内核接口,containerd作为工业级运行时管理生命周期,dockerd作为用户入口代理API请求。这种分层设计保障了故障隔离、可调试性与跨平台一致性,支撑微服务部署、CI/CD构建和本地开发环境标准化等

weixin_34183910的博客 558

Ubuntu 16.04 下 LXD 容器化实践:系统级隔离与 ZFS 存储调优

Linux 容器技术中,LXD 是基于 cgroups 和 namespaces 构建的系统容器(System Container)运行时,区别于进程级容器(如 Docker),它完整支持 systemd、journalctl 和传统 init 流程,适用于需全栈 OS 兼容性的 CI/CD、测试环境与轻量虚拟化场景。其核心价值在于以接近虚拟机的操作体验,提供远低于 KVM 的资源开销和高于 Docker 的系统完整性。关键技术支撑包括 user_namespaces 内核特性启用、ZFS 存储后端的快照/

weixin_30420305的博客 396

Docker 生态全景图:从容器运行时到服务发现的工程实践

Docker 不是单一命令行工具,而是由 containerd、runc、buildkit、libnetwork、overlay2 等深度耦合组件构成的分布式系统。其核心原理在于分层解耦与协同调度:runc 实现 OCI 运行时标准,containerd 管理生命周期,dockerd 提供开发者接口;网络依赖 libnetwork 抽象与 overlay/vxlan 协议栈;服务发现本质是 DNS+Raft 或外部 KV 的状态同步。这一架构带来显著技术价值——高隔离性、可复现构建、跨主机服务自动寻址与弹性

weixin_30326515的博客 362

Docker run 实战避坑指南:从镜像启动到服务可用的完整链路

容器启动不是简单执行命令,而是Linux内核级的进程沙盒化过程,涉及namespace隔离、cgroup资源控制与overlay2联合挂载等底层机制。理解docker run本质,需掌握CMD/ENTRYPOINT优先级、-v挂载路径顺序、-p端口映射规则及--network网络模式差异。这些知识直接决定Nginx、Python或Node.js服务能否稳定对外提供访问。本文聚焦新手高频卡点——容器秒退、日志不可查、网络不通、挂载失效等真实问题,结合docker ps、docker logs、docker e

354

在容器部署上Docker不一定最佳

本文讲的是在容器部署上Docker不一定最佳,【编者的话】很多时候,大家都把Docker跟容器等同起来,它确实能够解决运维中众多的问题,如:APP运行环境打包、容器移植性高、提供分层文件系统等特性;但是还有很多容器技术被忽略了,如LXC;而在某些特定环境下,Docker确实是有它的软肋,下文就是阐述这个问题的。 这是我去年在LinuxCon Eur...

weixin_34267123的博客 216

E5071C 网络分析仪使用指南

E5071C 网络分析仪是 Keysight(原 Agilent)推出的一款高性能矢量网络分析仪,广泛应用于射频(RF)和微波(MW)电路设计、天线测试、滤波器优化等领域。它以高精度、宽频率范围(9 kHz–20 GHz)、出色的动态范围和灵活的测量功能著称。本文将详细介绍 E5071C 的基本操作方法,帮助用户快速上手并高效使用该设备。

2501_90901792的博客 4192

Docker底层原理与工程实践:从环境一致性到生产部署

容器技术是解决软件运行环境不一致问题的核心基础设施,其本质基于Linux Namespace和Cgroups实现进程隔离与资源管控。通过镜像分层、声明式构建和网络命名空间等机制,Docker将开发、测试与生产环境的差异收敛为可版本化、可复现的配置代码。它不仅支撑学生课程项目一键交付,更赋能企业级多服务编排、安全扫描与可观测性建设。在云原生演进背景下,掌握Docker的底层逻辑(如runc运行时、COPY语义、--network模式)与工程规范(如.dockerignore、多阶段构建、非root用户)已成为

weixin_30682415的博客 367

“迎圣诞,拿大奖” 活动赛题 Web-SQLi

1. php中sprintf()函数漏洞原理及其利用; 2. mysql盲注语法及python脚本; 3. sqlmap的需要进一步学习;

qq_34106499的博客 674

STK之Commu模块之三仿真卫星通信链路参数计算

考虑上述衰减的影响,可以得到卫星接收机输入端的载波功 [C] = [PT] +[GT] +[GR] -[L] -[L1] -[L2] (

juanhuokang2681的博客 8268
上一篇: 从零开始写 Docker(十三)---实现 mydocker rm 删除容器
下一篇: 从零开始写 Docker(十五)---实现 mydocker run -e 支持环境变量传递
探索云原生
博客等级 码龄9年 730粉丝 131原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值