从零开始写 Docker(一)---实现 mydocker run 命令

mydockergithub 自己动手学docker的部分gitHub源码,不是很全,用来自己学习 立即下载

implement-run-cmd.png

本文为从零开始写 Docker 系列第一篇,主要实现 mydocker run 命令,构造了一个具有基本的 Namespace 隔离的简单容器。


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

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



本文主要实现我们的第一个命令 mydocker run,类似于 docker run -it [command]。

docker run 命令是通过创建新的 namespace 对新的进程进行视图隔离。

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

urfave/cli 工具

主要用到了 urfave/cli 来实现命令行工具,具体用法参考官方文档。

两个常用 cli 库对比:

urfave/cli 比较简洁,实现简单的 cli 工具推荐使用。
spf13/cobra 功能强大,实现复杂的 cli 工具推荐使用。

一个简单的 urfave/cli Demo 如下:

// urfaveCli cli 包简单使用,具体可以参考官方文档
func urfaveCli() {
	app := cli.NewApp()

	// 指定全局参数
	app.Flags = []cli.Flag{
		cli.StringFlag{
			Name:  "lang, l",
			Value: "english",
			Usage: "Language for the greeting",
		},
		cli.StringFlag{
			Name:  "config, c",
			Usage: "Load configuration from `FILE`",
		},
	}
	// 指定支持的命令列表
	app.Commands = []cli.Command{
		{
			Name:    "complete",
			Aliases: []string{"c"},
			Usage:   "complete a task on the list",
			Action: func(c *cli.Context) error {
				log.Println("run command complete")
				for i, v := range c.Args() {
					log.Printf("args i:%v v:%v\n", i, v)
				}
				return nil
			},
		},
		{
			Name:    "add",
			Aliases: []string{"a"},
			// 每个命令下面还可以指定自己的参数
			Flags: []cli.Flag{cli.Int64Flag{
				Name:  "priority",
				Value: 1,
				Usage: "priority for the task",
			}},
			Usage: "add a task to the list",
			Action: func(c *cli.Context) error {
				log.Println("run command add")
				for i, v := range c.Args() {
					log.Printf("args i:%v v:%v\n", i, v)
				}
				return nil
			},
		},
	}

	err := app.Run(os.Args)
	if err != nil {
		log.Fatal(err)
	}
}

具体效果如下:

$ go run main.go -h
NAME:
   main - A new cli application

USAGE:
   main [global options] command [command options] [arguments...]

COMMANDS:
   complete, c  complete a task on the list
   add, a       add a task to the list
   help, h      Shows a list of commands or help for one command

GLOBAL OPTIONS:
   --lang value, -l value  Language for the greeting (default: "english")
   --config FILE, -c FILE  Load configuration from FILE
   --help, -h              show help

可以看到指定的指令和参数,就是这么简单。

具体实现

目录结构

mydocker 项目当前目录结构如下:

$ tree .
.
├── LICENSE
├── Makefile
├── README.md
├── container
│   ├── container_process.go
│   └── init.go
├── example
│   └── main.go
├── go.mod
├── go.sum
├── main.go
├── main_command.go
└── run.go
  • main.go 作为项目入口
  • main_command.go 中包含了所有的 command
  • run.go 则是 run 命令核心逻辑
  • container 目录则是一些 container 的核心实现

main.go

首先是 main 文件:

使用 urfave/cli 提供 的命令行工具定义了 mydocker 的几个基本命令,包括 runCommand和 initCommand ,然后在 app.Before 内初始化 logrus 的日志配置。

package main

import (
	"os"

	log "github.com/sirupsen/logrus"

	"github.com/urfave/cli"
)

const usage = `mydocker is a simple container runtime implementation.
			   The purpose of this project is to learn how docker works and how to write a docker by ourselves
			   Enjoy it, just for fun.`

func main() {
	app := cli.NewApp()
	app.Name = "mydocker"
	app.Usage = usage

	app.Commands = []cli.Command{
		initCommand,
		runCommand,
	}

	app.Before = func(context *cli.Context) error {
		// Log as JSON instead of the default ASCII formatter.
		log.SetFormatter(&log.JSONFormatter{})

		log.SetOutput(os.Stdout)
		return nil
	}

	if err := app.Run(os.Args); err != nil {
		log.Fatal(err)
	}
}

main_command.go

main_command 中包含了具体的命令定义:

var runCommand = cli.Command{
	Name: "run",
	Usage: `Create a container with namespace and cgroups limit
			mydocker run -it [command]`,
	Flags: []cli.Flag{
		cli.BoolFlag{
			Name:  "it", // 简单起见,这里把 -i 和 -t 参数合并成一个
			Usage: "enable tty",
		},
	},
	/*
		这里是run命令执行的真正函数。
		1.判断参数是否包含command
		2.获取用户指定的command
		3.调用Run function去准备启动容器:
	*/
	Action: func(context *cli.Context) error {
		if len(context.Args()) < 1 {
			return fmt.Errorf("missing container command")
		}
		cmd := context.Args().Get(0)
		tty := context.Bool("it")
		Run(tty, cmd)
		return nil
	},
}

var initCommand = cli.Command{
	Name:  "init",
	Usage: "Init container process run user's process in container. Do not call it outside",
	/*
		1.获取传递过来的 command 参数
		2.执行容器初始化操作
	*/
	Action: func(context *cli.Context) error {
		log.Infof("init come on")
		cmd := context.Args().Get(0)
		log.Infof("command: %s", cmd)
		err := container.RunContainerInitProcess(cmd, nil)
		return err
	},
}

要实现 run 命令我们需要实现 run、init 两个命令。

run.go

接着看下 Run 函数做了写什么:

// Run 执行具体 command
/*
这里的Start方法是真正开始前面创建好的command的调用,它首先会clone出来一个namespace隔离的
进程,然后在子进程中,调用/proc/self/exe,也就是调用自己,发送init参数,调用我们写的init方法,
去初始化容器的一些资源。
*/
func Run(tty bool, cmd string) {
	parent := container.NewParentProcess(tty, cmd)
	if err := parent.Start(); err != nil {
		log.Error(err)
	}
	_ = parent.Wait()
	os.Exit(-1)
}

Run 命令主要调用 NewParentProcess 构建 os/exec.Cmd 对象并执行,执行完成立马退出。

注意区分 os/exec 包中的 Cmd 对象和 urfave/cli 包中的 command 对象。

// NewParentProcess 启动一个新进程
/*
这里是父进程,也就是当前进程执行的内容。
1.这里的/proc/se1f/exe调用中,/proc/self/ 指的是当前运行进程自己的环境,exec 其实就是自己调用了自己,使用这种方式对创建出来的进程进行初始化
2.后面的args是参数,其中init是传递给本进程的第一个参数,在本例中,其实就是会去调用initCommand去初始化进程的一些环境和资源
3.下面的clone参数就是去fork出来一个新进程,并且使用了namespace隔离新创建的进程和外部环境。
4.如果用户指定了-it参数,就需要把当前进程的输入输出导入到标准输入输出上
*/
func NewParentProcess(tty bool, command string) *exec.Cmd {
	args := []string{"init", command}
	cmd := exec.Command("/proc/self/exe", args...)
	cmd.SysProcAttr = &syscall.SysProcAttr{
		Cloneflags: syscall.CLONE_NEWUTS | syscall.CLONE_NEWPID | syscall.CLONE_NEWNS |
			syscall.CLONE_NEWNET | syscall.CLONE_NEWIPC,
	}
	if tty {
		cmd.Stdin = os.Stdin
		cmd.Stdout = os.Stdout
		cmd.Stderr = os.Stderr
	}
	return cmd
}

可以看到,NewParentProcess 方法构建的命令为 /proc/self/exe,这个表示调用当前文件,我们后续编译出来是二进制文件是 mydocker,那么这个命令执行的就是 mydocker。
第一个参数为 init,也就是说这个命令最终会执行mydocker init 这个命令。

这也就是为什么我们除了实现 run 命令之外,还要实现一个 init 命令。

另外比较重要的就是关于 tty 的:

	if tty {
		cmd.Stdin = os.Stdin
		cmd.Stdout = os.Stdout
		cmd.Stderr = os.Stderr
	}

将 cmd 的输入和输出连接到终端,以便我们可以与命令进行交互,并看到命令的输出。

即:cmd 可以从标准输入读取输入,也可以把结果打印到标准输出或者错误输出上。

那么当我们执行mydocker run -it /bin/ls 这种命令时,最后的 /bin/ls 就会作为标准输入给到容器进程,因此容器进程就会执行 /bin/ls 命令,列出当前目录下的文件。

init.go

最后再看下 initCommand 的具体内容:

// RunContainerInitProcess 启动容器的init进程
/*
这里的init函数是在容器内部执行的,也就是说,代码执行到这里后,容器所在的进程其实就已经创建出来了,
这是本容器执行的第一个进程。
使用mount先去挂载proc文件系统,以便后面通过ps等系统命令去查看当前进程资源的情况。
*/
func RunContainerInitProcess(command string, args []string) error {
	log.Infof("command:%s", command)
	defaultMountFlags := syscall.MS_NOEXEC | syscall.MS_NOSUID | syscall.MS_NODEV
	_ = syscall.Mount("proc", "/proc", "proc", uintptr(defaultMountFlags), "")
	argv := []string{command}
	if err := syscall.Exec(command, argv, os.Environ()); err != nil {
		log.Errorf(err.Error())
	}
	return nil
}

这里 Mount 意思如下:

  • MS_NOEXEC 在本文件系统 许运行其 程序。

  • MS_NOSUID 在本系统中运行程序的时候, 允许 set-user-ID set-group-ID

  • MS_NOD 这个参数是自 Linux 2.4 ,所有 mount 的系统都会默认设定的参数。

本函数最后的syscall.Exec是最为重要的一句黑魔法,正是这个系统调用实现了完成初始化动作并将用户进程运行起来的操作。

首先,使用 Docker 创建起来一个容器之后,会发现容器内的第一个程序,也就是 PID 为 1 的那个进程,是指定的前台进程。但是,我们知道容器创建之后,执行的第一个进程并不是用户的进程,而是 init 初始化的进程。 这时候,如果通过 ps 命令查看就会发现,容器内第一个进程变成了自己的 init,这和预想的是不一样的。

有没有什么办法把自己的进程变成 PID 为 1 的进程呢?

这里 execve 系统调用就是用来做这件事情的。

syscall.Exec 这个方法,其实最终调用了 Kernel 的 int execve(const char *filename, char *const argv[], char *const envp[);这个系统函数。它的作用是执行当前 filename 对应的程序,它会覆盖当前进程的镜像、数据和堆栈等信息,包括 PID,这些都会被将要运行的进程覆盖掉。

也就是说,调用这个方法,将用户指定的进程运行起来,把最初的 init 进程给替换掉,这样当进入到容器内部的时候,就会发现容器内的第一个程序就是我们指定的进程了。

这其实也是目前 Docker 使用的容器引擎 runC 的实现方式之一。

具体启动流程如下图:

mydocker-run-exec-process.png

  • 1)流程开始,用户手动执行 mydocker run 命令
  • 2)urfave/cli 工具解析传递过来的参数
  • 3)解析完成后发现第一个参数是 run,于是执行 run 命令,调用 runCommand 方法,该方法中继续调用 NewParentProcess 函数构建一个 cmd 对象
  • 4)NewParentProcess 将构建好的 cmd 对象返回给 runCommand 方法
  • 5)runCommand 方法中调用 cmd.exec 执行上一步构建好的 cmd 对象
  • 6)容器启动后,根据 cmd 中传递的参数,/proc/self/exe init 实则最终会执行 mydocker init 命令,初始化容器环境
  • 7)init 命令内部实现就是通过 mount 命令挂载 proc 文件系统
  • 8)容器创建完成,整个流程结束

测试

root@mydocker:~/mydocker# go build .
root@mydocker:~/mydocker# ./mydocker run -it /bin/sh
{"level":"info","msg":"init come on","time":"2024-01-03T14:44:35+08:00"}
{"level":"info","msg":"command: /bin/sh","time":"2024-01-03T14:44:35+08:00"}
{"level":"info","msg":"command:/bin/sh","time":"2024-01-03T14:44:35+08:00"}
# ps -ef
UID          PID    PPID  C STIME TTY          TIME CMD
root           1       0  0 09:47 pts/1    00:00:00 /bin/sh
root           5       1  0 09:47 pts/1    00:00:00 ps -ef

在容器运行 ps 时,可以发现 /bin/sh 程是容器内的第一个进程, PID 为 1。 ps 进程是 PID 为 1 的父进程创建出来的。

来对比 Docker 运行的容器的效果,如下:

[root@docker ~]# docker run -it ubuntu /bin/sh
# ps -ef
UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 01:49 pts/0    00:00:00 /bin/sh
root         7     1  0 01:49 pts/0    00:00:00 ps -ef

不能说很相似,只能说是一模一样了。

这里的 /bin/sh 是一个会在前台一直运行的进程,那么可以试一下如果指定一个运行完就会退出的进程会是什么效果:

root@mydocker:~/mydocker# ./mydocker run -it /bin/ls
{"level":"info","msg":"init come on","time":"2024-01-03T14:51:48+08:00"}
{"level":"info","msg":"command: /bin/ls","time":"2024-01-03T14:51:48+08:00"}
{"level":"info","msg":"command:/bin/ls","time":"2024-01-03T14:51:48+08:00"}
LICENSE  Makefile  README.md  container  example  go.mod  go.sum  main.go  main_command.go  mydocker  run.go

运行了一下 ls 命令,发现容器启动起来以后,打印出了当前目录的内容,然后便退出了,这个结果和 Docker 要求容器必须有一个一直在前台运行的进程的要求一致。

由于没有 chroot ,所以目前的系统文件系统是继承自父进程的。

至此,我们的 mydocker run 命令就算是实现完成,基本能实现 docker run 的效果。

小结

run 命令实现中感觉几个比较重要的点:

  • /proc/self/exe:调用自身 init 命令,初始化容器环境
  • tty:实现交互
  • Namespace 隔离:通过在 fork 时指定对应 Cloneflags 来实现创建新 Namespace
  • proc 隔离:通过重新 mount /proc 文件系统来实现进程信息隔离
  • execve 系统调用:使用指定进程覆盖 init 进程

/proc/self/exe

/proc/self/exe 是 Linux 系统中的一个符号链接,它指向当前进程的可执行文件。这个路径是一个虚拟路径,实际上并不对应于文件系统中的一个文件,而是通过 /proc 文件系统提供的一种方式来访问进程相关的信息。

具体而言,/proc/self 是一个指向当前进程自身的符号链接,而 exe 则是一个特殊的文件,通过这个文件可以访问当前进程的可执行文件。因此,/proc/self/exe 实际上是当前进程可执行文件的路径。

也就是说在 mydocker run 命令中执行的 /proc/self/exe init 实际上最终执行的是 mydocker init,即 run 命令会调用 init 命令来初始化容器环境。

tty

	if tty {
		cmd.Stdin = os.Stdin
		cmd.Stdout = os.Stdout
		cmd.Stderr = os.Stderr
	}

当用户指定 -it 参数时,就将 cmd 的输入和输出连接到终端,以便我们可以与命令进行交互,并看到命令的输出。

Namespace 隔离

	cmd := exec.Command("/proc/self/exe", args...)
	cmd.SysProcAttr = &syscall.SysProcAttr{
		Cloneflags: syscall.CLONE_NEWUTS | syscall.CLONE_NEWPID | syscall.CLONE_NEWNS |
			syscall.CLONE_NEWNET | syscall.CLONE_NEWIPC,
	}

fork 新进程时,通过指定 Cloneflags 会创建对应的 Namespace 以实现隔离,这里包括 UTS(主机名)、PID(进程 ID)、挂载点、网络、IPC 等方面的隔离。

proc 隔离

/proc 文件系统是一个虚拟的文件系统,提供了对内核和运行中进程的信息的访问。通过挂载 /proc,系统中的许多信息和控制接口可以通过文件的形式在这个目录下找到。

例如,你可以通过 /proc 查看系统的一些信息,如进程列表、内存使用情况、CPU 信息等。

比如当前机器上的进程信息:

[root@docker ~]# ls /proc
1     1147  16     18531  20     247    325  350  468  632  74    79   85    908        cmdline    driver       ioports    kpagecgroup  misc          pressure     stat           tty
10    1150  16968  18533  20728  3      326  351  491  633  75    8    86    978        consoles   execdomains  irq        kpagecount   modules       sched_debug  swaps          uptime
100   1152  17     18534  21     31652  327  352  508  635  76    80   87    acpi       cpuinfo    fb           kallsyms   kpageflags   mounts        schedstat    sys            version
1094  1155  18     18549  22     31797  333  353  544  637  7675  813  88    buddyinfo  crypto     filesystems  kcore      loadavg      mtrr          scsi         sysrq-trigger  vmallocinfo
11    13    18433  18550  244    31818  347  354  587  641  7694  82   8897  bus        devices    fs           keys       locks        net           self         sysvipc        vmstat
1100  14    18435  19     245    323    348  355  6    643  77    832  89    capi       diskstats  interrupts   key-users  mdstat       pagetypeinfo  slabinfo     thread-self    zoneinfo
1141  15    18505  2      246    324    349  4    620  73   78    84   9     cgroups    dma        iomem        kmsg       meminfo      partitions    softirqs     timer_list

而在容器环境中,为了和宿主机的 /proc 环境隔离,因此在 mydocker init 命令中我们会重新挂载 /proc 文件系统,即:

syscall.Mount("proc", "/proc", "proc", uintptr(defaultMountFlags), "")

对应 mount 命令为:

mount -t proc proc /proc

而当前进程在 fork 时指定了syscall.CLONE_NEWPID 等等标记,因此是在新的 Namespace 中的,那就意味着看不到宿主机上的进程信息,那么重新挂载后的 /proc 文件系统自然也就只有当前 Namespace 下的进程信息。

这也就是为什么在容器中执行 ps 命令只能看到容器中的进程信息

execve 系统调用

execve 系统调用用于取代当前进程的映像(即,当前进程的可执行文件),并用一个新的程序来替代。

原型如下:

int execve(const char *filename, char *const argv[], char *const envp[);
  • filename 参数指定了要执行的新程序的文件路径。
  • argv 参数是一个字符串数组,包含了新程序的命令行参数。数组的第一个元素通常是新程序的名称,随后的元素是命令行参数。
  • envp 参数是一个字符串数组,包含了新程序执行时使用的环境变量。

execve 的工作方式是加载指定的程序文件,并将它替代当前进程的内存映像。因此,执行 execve 后,原进程的代码、数据等内容都会被新程序的内容替代。

即:它的作用是执行当前 filename 对应的程序,它会覆盖当前进程的镜像、数据和堆栈等信息,包括 PID,这些都会被将要运行的进程覆盖掉。

在 Go 中的调用方式为 syscall.Exe。 通过该系统调用,可以使用用户指定的命令启动新进程来覆盖 mydocker 进程作为容器环境中的 PID 1 进程。

即:在 init 命令中解析拿到用户指定的命令并通过 syscall.Exe 使用该命令创建新进程来覆盖 mydocker 进程。

这也就是为什么我们执行 mydocker run -it /bin/sh 后 sh 会成为 PID 1 进程。

看到这里的话,mydocker run 命令的具体实现及其关键点,都完整介绍了一遍了,再回过头来看一下具体流程,应该就更清晰了:
mydocker-run-exec-process.png

  • 1)流程开始,用户手动执行 mydocker run 命令
  • 2)urfave/cli 工具解析传递过来的参数
  • 3)解析完成后发现第一个参数是 run,于是执行 run 命令,调用 runCommand 方法,该方法中继续调用 NewParentProcess 函数构建一个 cmd 对象
  • 4)NewParentProcess 将构建好的 cmd 对象返回给 runCommand 方法
  • 5)runCommand 方法中调用 cmd.exec 执行上一步构建好的 cmd 对象
  • 6)容器启动后,根据 cmd 中传递的参数,/proc/self/exe init 实则最终会执行 mydocker init 命令,初始化容器环境
  • 7)init 命令内部实现就是通过 mount 命令挂载 proc 文件系统
  • 8)容器创建完成,整个流程结束

FAQ

以下是在实现 mydocker run 命令时可能出现的问题

对应代码已经提交,使用本仓库代码不会出现该问题

fork/exec /proc/self/exe: no such file or directory

在正常第二次 mydocker 命令时出现该错误,具体如下:

root@mydocker:~/mydocker# ./mydocker run -it /bin/ls
{"level":"info","msg":"init come on","time":"2024-01-03T15:07:27+08:00"}
{"level":"info","msg":"command: /bin/ls","time":"2024-01-03T15:07:27+08:00"}
{"level":"info","msg":"command:/bin/ls","time":"2024-01-03T15:07:27+08:00"}
LICENSE  Makefile  README.md  container  example  go.mod  go.sum  main.go  main_command.go  mydocker  run.go
root@mydocker:~/mydocker# ./mydocker run -it /bin/ls
{"level":"error","msg":"fork/exec /proc/self/exe: no such file or directory","time":"2024-01-03T15:07:28+08:00"}
原因

这个是因为代码中会将容器进程的 proc 信息挂载为 proc 文件系统,具体代码如下:

// container/init.go#RunContainerInitProcess 方法
	defaultMountFlags := syscall.MS_NOEXEC | syscall.MS_NOSUID | syscall.MS_NODEV
_ = syscall.Mount("proc", "/proc", "proc", uintptr(defaultMountFlags), "")

这部分代码会在 mydocker init 中执行,也就是说实际上是在容器进程中执行的 mount,当我们的 mydocker 进程运行结束退出后,容器进程就消失了。

而在引入了 systemd 之后的 linux 中,mount namespace 是 shared by default,也就是说宿主机上的 /proc 目录也被影响了。

即:宿主机 /proc 目录的内容依旧是运行 mydocker 时的信息,而此时因为 mydocker 已经退出了,对应的进程信息自然就不存在了,所以会在执行 mydocker run 中的 /proc/self/exe 这个命令时出现这个错误。

解决方案

临时解决方案:在宿主机手动执行一次 mount,重新挂载 /proc 目录,即可将 /proc 目录恢复为正常数据

mount -t proc proc /proc

后续每次运行 mydocker 命令都会破坏掉 /proc 目录数据。

永久解决方案:将 mount 事件显式指定为 private 即可避免挂载事件外泄,这样就不会破坏宿主机 /proc 目录数据了。
具体代码调整如下:

// container/init.go#RunContainerInitProcess 方法
// systemd 加入linux之后, mount namespace 就变成 shared by default, 所以你必须显示声明你要这个新的mount namespace独立。
// 即 mount proc 之前先把所有挂载点的传播类型改为 private,避免本 namespace 中的挂载事件外泄。
syscall.Mount("", "/", "", syscall.MS_PRIVATE|syscall.MS_REC, "")
// 如果不先做 private mount,会导致挂载事件外泄,后续再执行 mydocker 命令时 /proc 文件系统异常
// 可以执行 mount -t proc proc /proc 命令重新挂载来解决
// ---分割线---
defaultMountFlags := syscall.MS_NOEXEC | syscall.MS_NOSUID | syscall.MS_NODEV
_ = syscall.Mount("proc", "/proc", "proc", uintptr(defaultMountFlags), "")

核心为这一句:

syscall.Mount("", "/", "", syscall.MS_PRIVATE|syscall.MS_REC, "")

把所有挂载点的传播类型改为 private,避免本 namespace 中的挂载事件外泄。

相关讨论:#33、#41#issuecomment-478799767、#58


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

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


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

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

# 克隆代码
git clone -b feat-run https://github.com/lixd/mydocker.git
cd mydocker
# 拉取依赖并编译
go mod tidy
go build .
# 测试
./mydocker run -it /bin/ls
激光定位算法竞技场:hdl_localization与Cartographer/AMCL的横向技术解剖 本文深入对比了hdl_localization、Cartographer和AMCL三种激光定位算法的技术原理与性能表现。通过UKF-NDT融合、图优化和粒子滤波等核心技术,分析了各算法在结构化环境、动态环境和大尺度场景下的适应性。实验数据表明,Cartographer在全局一致性上表现最优,而AMCL在动态环境中更具鲁棒性。文章还提供了算法选型指南和参数调优技巧,为工程实践提供参考。 阅读详情

相关推荐

【科研绘图】【数据拟合曲线】:附Origin详细画图流程

拟合曲线图

weixin_50236590的博客 4万+

探秘MyDocker:一款轻量级的Docker管理工具

是一个简洁而强大的Docker管理工具,专为简化日常Docker操作而设计。它由lixindong开发并维护,以其简单易用和高效的特性赢得了开发者们的青睐。本文将深入解析其技术特点、应用场景和优势,帮助你更好地理解和利用这个项目。 ## 项目简介 MyDocker是一个基于Python编写的命令行工具,目标是提供一种更直观、更便捷的方式来管理和运行你的Docker容器。相比Docker原生的复

gitblog_00065的博客 680

论文分享 - OctoMap八叉树建图原理

论文:OctoMap:An Efficient Probabilistic 3D Mapping Framework Based on Octrees。

一只废佐_的博客 2542

docker研习—长文解读开源项目mydocker

Start命令执行后容器创建,并在容器内将init进程由用户进程替换;当NewParentProcess将command实体交给run函数后,作为父进程的mydocker会执行Start()方法,在cmd实体得到执行时他预先被注册进去的调用自身init的指令会被执行,此时进入了子进程中,继续执行该函数。syscall.Exec这里的系统调用并非将命令运行一下那么简单,他用到的是kernel里的execve命令,这个系统调用会将当前进程用传入的filename对应的程序进程覆盖掉,包括pid也会被替换。

Donnnn_的博客 337

OpenTCS打造移动机器人交通管制系统(四)

先分析下OpenTCS的一些策略方面的东西,这是OpenTCS的基础。 首先需要先明确下OpenTCS内核中的三个概念: 路由(Route) : 决定了车辆通过什么样的方式和算法来获得一段路径,未来车辆将沿着此路径运行。 派遣(Dispacher): 决定了一个订单应该关联哪一辆小车,即为订单分配车辆和为车辆分配订单。 调度(schedule):狭义上的调度,交通管制的核心,决定了何时分配...

白色冰激凌的技术专栏 5272

Modbus4J vs EasyModbus4J:哪个Java库更适合你的工业项目?

本文深入对比了Java领域两大Modbus通信库Modbus4J与EasyModbus4J。Modbus4J设计稳健、类型安全,适合复杂业务集成;EasyModbus4J基于Netty,在高并发场景下性能更优。文章从架构、性能、API及生产环境多维度分析,为工业物联网项目选型提供决策依据。

weixin_28475533的博客 316

Docker——基础篇

文章目录一. 问题背景 一. 问题背景 笔者对docker仅处于认知阶段,准备使用docker搭建一些应用集群(比如MySQL、redis)

Android_la的博客 1625

深入解析AMBA5 AXI与ACE协议:从基础到高级应用

本文深入解析了AMBA5 AXI与ACE协议的核心机制与应用。AXI协议通过分离通道、突发传输和乱序完成实现高性能数据传输,而ACE协议在此基础上构建了硬件级缓存一致性解决方案,通过监听机制和状态模型确保多核系统数据统一。文章还探讨了在异构计算等复杂场景下的实战应用与AMBA5的新特性。

cc789的博客 964

mydocker

Docker容器特点 + 与虚拟机比较 + LinuxNamespace + Linux Cgroups + Union File System + Linux proc 文件系统 + Linux虚拟网络设备 + Linux Bridge + Linux 路由表 + Linux

2301_79890350的博客 1096

通讯接口应用笔记3:使用W5500实现Modbus TCP服务器

  前面我们设计实现了W5500的驱动程序,也讲解了驱动的使用方式。在最近一次的项目应用中,正好有一个使用W5500实现TCP通讯的需求,所以我们就使用该驱动程序轻松实现。这一篇中我们就来说一说基于我们W5500通讯驱动程序实现TCP通讯的过程。 1、应用需求   在本次应用中,要求实现一个基于W5500的Modbus TCP服务器。这个需求的描述虽然只有一句话,但是这个需求的内容可不简单。我们首先来分析一下这个需求的具体内容。   为了实现基于W5500的Modbus TCP服务器,我们必先须基于W550

木南创智 5500

FOC电机控制中电流采样延迟补偿的原理和方法

摘要: FOC电机控制中,电流采样、计算与PWM更新存在固有延迟(约1.5个PWM周期),导致相位滞后,限制电流环带宽。主流补偿方法包括: 一阶前向预测法:基于历史电流值预测未来电流,抵消延迟,工程应用广泛; 相位超前补偿:通过s/z域校正器设计实现等效预测; 状态观测器法(如龙伯格观测器):通过电机模型闭环估计状态,兼具噪声抑制和参数辨识能力,但复杂度高。实际需注意参数敏感性、离散化精度及延迟时间校准,避免过补偿风险。一阶预测法因平衡效果与复杂度成为工业首选。

jifengzhiling的博客 2237

从零开始写 Docker(十六)---容器网络实现(上):为容器插上”网线”

本文为从零开始写 Docker 系列第十六篇,利用 linux 下的 Veth、Bridge、iptables 等等相关技术,构建容器网络模型,为容器插上”网线“。

探索云原生 1452

2011-2024年间各省数字普惠金融指数数据(覆盖广度、使用深度和数字化程度)

2、指标:数字金融普惠指数、数字金融覆盖广度指数、数字金融使用深度指数、普惠金融数字化程度指数、数字金融使用深度指数下属的支付、保险、货币基金、信用服务、投资、信贷等分类指数。中国各省的数字普惠金融指数数据,从数字金融覆盖广度、数字金融使用深度和普惠金融数字化程度3个维度来构建数字普惠金融指标体系。数字普惠金融指数一共3个维度、33项具体指标。全套指数包含数字金融覆盖广度指数、数字金融使用深度指数和普惠金融数字化程度指数,以及数字金融使用深度指数下属的支付、保险、货币基金、信用服务、投资、信贷等分类指数。

【优快云】 1万+

从零开始写 Docker(六)---实现 mydocker run -v 支持数据卷挂载

上一篇中基于 overlayfs 实现了容器和宿主机文件系统间的写操作隔离。但是一旦容器退出,容器可读写层的所有内容都会被删除。那么,如果用户需要持久化容器里的部分数据该怎么办呢?docker volume 就是用来解决这个问题的。启动容器时通过-v参数创建 volume 即可实现数据持久化。本节将会介绍如何实现将宿主机的目录作为数据卷挂载到容器中,并且在容器退出后,数据卷中的内容仍然能够保存在宿主机上。具体实现主要依赖于 linux 的 bind mount 功能。bind mount。

探索云原生 1307

VC中sqlite的使用

在VC中对sqlite的使用,实现数据库大批数据的快速插入,读取数据库中的数据在ListCtrl中显示

蓝牙模块HM-10手册

蓝牙模块HM-10手册,该手册对蓝牙模块HM-10进行了详细的介绍和使用方法以及一些AT指令。

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

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

探索云原生 1232

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

从零开始写 Docker(十五)---实现 mydocker run -e 支持环境变量传递

本文为从零开始写 Docker 系列第十五篇,实现 `mydocker run -e`, 支持在启动容器时指定环境变量,让容器内运行的程序可以使用外部传递的环境变量。

探索云原生 696

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员,提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列,各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性,请参见数据手册。有关 ARM Cortex™-M4F 内核的信息,请参见《Cortex™-M4F 技术参考手册》。

从零开始写 Docker(八)---实现 mydocker run -d 支持后台运行容器

经过前面的 7 篇文章,我们已经基本实现了一个简单的 docker 了。不过与 Docker 创建的容器相比,我们还缺少以下功能1)指定后台运行容器,也就是 detach 功能2)通过 docker ps 查看目前处于运行中的容器3)通过docker logs 查看容器的输出4)通过 docker exec 进入到一个已经创建好了的容器中后续几篇文章主要就是一一实现这些功能,本文首先实现让容器后台运行。

探索云原生 1025

容器生命周期管理:mydocker如何实现run、stop、exec命令

mydocker是一个基于《自己动手写docker》实现的容器引擎,提供了完整的容器生命周期管理功能,包括容器的创建(run)、停止(stop)和命令执行(exec)等核心操作。本文将深入解析mydocker如何实现这些关键命令,帮助新手理解容器技术的基本原理。 ## 🚀 容器创建:run命令的实现原理 run命令是mydocker最核心的功能之一,负责创建并启动一个新的容器。其实现逻辑主要

gitblog_00665的博客 704

如何从零开始自己动手写Docker:完整实践指南

GitHub 加速计划的 mydocker 项目是《自己动手写Docker》一书的配套源码,通过这个项目,开发者可以深入理解Docker底层原理,从零开始构建一个简易但功能完整的容器引擎。本教程将带你了解这个项目的核心价值、基本结构以及如何开始实践,帮助你快速掌握容器技术的精髓。 [![自己动手写Docker书籍封面](https://raw.gitcode.com/gh_mirrors/my/

gitblog_00337的博客 1065

从零自制docker-15-【实现 mydocker run -d 支持后台运行容器】

然后之前在后面发现upper中出现root是调用相关命令就会出现root,但当时没有啥修改的文件,这次全的busybox发现出现了下面的这个,那么确实就是因为调用命令引起的日志记录的变化导致的。当时是容器在挂载前就找相关命令,找到的这个是宿主机上的,但我们要的是在pivoroot后的根目录下的相关命令的路径,所以后面运行这个宿主机上的路径会显示路径找不到,因为此时是以容器的根目录为相对参考。加入的,因为我最后关闭了主进程最后自动删除cgroup的函数),最终可以看到top进程在后台运行。

llovewuzhengzi的博客 1323

从零自制docker-13-【实现 mydocker run -v 支持数据卷挂载】

注意由于先挂载overlayfs再绑定挂载,此时绑定挂载点已经不属于overlayfs了,所以在绑定里面的修改将不会有overlayfs的机制(绑定挂载点如果在lower,但此时由于是绑定挂载,相当于并没有挂载到overlayfs,所以overlayfs机制对该挂载点不会生效,相当于lower层绑定挂载点变化,但upper层不会变化,merged绑定挂载点变化)此时先卸载绑定挂载点,因为绑定挂载点在overlayfs里面,如果先卸载overlayfs就会发现里面还有一个挂载点,此时卸载就会失败,

llovewuzhengzi的博客 1101

Docker:构造简单容器

Github-blog 优快云-blog 最近在看《自己动手写Docker》 这本书,打算边看边整理吧。人家写的很赞,逻辑很清晰,我只是按照我自己的思路整理一遍,加深理解,详细的内容还是请看原书吧。 实现目标 实现类似docker run的命令,通过命令行创建相应容器,具体的输入命令是: ./mydocker run -ti /bin/sh 命令中包含的三个参数分别为:...

xftony的博客 622

Docker学习笔记(全网最详细)

尚硅谷周阳老师Docker经典教程,本来是脑图,但为了增强记忆达到实践效果,就整理了下笔记,欢迎各位大佬评论指点.

LXYDSF的博客 2458

【Docker】Docker的使用与介绍

Docker的基础使用与介绍

HR的博客 320

制作mqttserver容器docker镜像

(1)根目录下新建mydocker文件夹 #mkdir /mydocker #cd /mydocker (2)构建dockerfile #vim dockerfile_mqttserver { FROM centos WORKDIR /var/apps/mqtt ADD mosquitto-1.4.5.tar.gz /var/apps/mqtt ADD paho.mqtt.c.tar.gz /va...

qq_37198420的博客 734

Publish-Docker-Github-Action终极教程:从基础配置到高级用法全解析

GitHub Actions 已经成为现代软件开发中不可或缺的 CI/CD 工具,而 **Publish-Docker-Github-Action** 则是 Docker 镜像发布领域的终极解决方案。这个强大的 GitHub Action 能够自动化 Docker 镜像的构建和发布流程,让开发者专注于核心业务逻辑。无论你是 Docker 新手还是经验丰富的 DevOps 工程师,本指南将为你提供从

gitblog_00671的博客 755
上一篇: 揭秘 Docker 网络:手动实现 Docker 桥接网络
下一篇: 从零开始写 Docker(二)---优化:使用匿名管道传递参数
探索云原生
博客等级 码龄9年 730粉丝 131原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值