从零开始写 Docker(十一)---实现 mydocker exec 进入容器内部

docker-enter:用于输入现有容器的docker工具。 该工具依赖docker和setns 什么是docker-enter docker-enter是一个简单的程序,可让您访问正在运行的Docker容器。 这类似于nsenter BUT,但没有所有错误和依赖项。 此外,docker-enter充分利用了docker本身,从而可以使用容器的简短ID(ID的2-3个开头字符)。 请记住,此工具需要安装docker才能运行。 但是,由于您要输入一个容器,这意味着您已经安装了它,因此不必大惊小怪。 示范: manos@box:~$ docker run -d ubuntu sleep 9999999 73d6cfac58c1b8ade19ec485b249f5a7bf44840bdeeebf36cd675f05625b47ab manos@box:~$ sudo docker-enter 73d [sudo] password for manos: root@73d6cfac5 立即下载

mydocker-exec.png

本文为从零开始写 Docker 系列第十一篇,实现类似 docker exec 的功能,使得我们能够进入到指定容器内部。


完整代码见: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. 概述

上一篇已经实现了mydocker logs 命令,可以查看容器日志了。本篇主要实现 mydocker exec,让我们可以直接进入到容器内部,查看容器内部的文件、调试应用程序、执行命令等等。

下面这篇文章分析了 Docker 是如何使用 Linux Namespace 来实现视图隔离的,那么 mydocker exec 也是需要在 Namespace 上做文章。

[探索 Linux Namespace:Docker 隔离的神奇背后]

2. 核心原理

docker exec 实则是将当前进程添加到指定容器对应的 namespace 中,从而可以看到容器中的进程信息、网络信息等。

因此我们的 mydocker exec 具体实现包括两部分:

  • 根据容器 ID 找到对应 PID,然后找到 Namespace
  • 将当前进程切换到对应 Namespace

setns

将进程加入到对应的 Namespace 很简单,Linux提供了 setns 系统调用给我们使用。

setns 是一个系统调用,可以根据提供的 PID 再次进入到指定的 Namespace 中。它需要先打开/proc/[pid/ns/文件夹下对应的文件,然后使当前进程进入到指定的 Namespace 中。

但是用 Go 来实现则存在一个致命问题:setns 调用需要单线程上下文,而 GoRuntime 是多线程的。

准确的说是 MountNamespace。

Linux 的 Namespace 是一种资源隔离机制,它允许将一组进程的视图隔离到系统的不同部分,比如 PID Namespace、Network Namespace 等。

setns 系统调用允许进程加入(或重新进入)到指定的 Namespace 中。由于 Namespace 涉及到整个进程的资源隔离,因此需要在进程的上下文中执行,以确保进程及其所有线程都在相同的 Namespace 中。

Go Runtime 是多线程的,这意味着 Go 程序通常会有多个线程在同时运行。这种多线程模型与 setns 调用所需的单线程上下文不兼容。

Goroutine 会随机在底层 OS 线程之间切换,而不是固定在某个线程,因此在 Go 中执行 setns 不能准确的知道是操作到哪个线程了,结果是不确定的,因此需要特殊处理。

这个问题对 Go 本身来说没有太好的解决办法,#14163 是 Github 上对一些解决方案的讨论,不过最终还是被拒绝了。

不过好消息是 C 语言可以通过 gcc 的 扩展 attribute((constructor)) 来实现程序启动前执行特定代码,因此 Go 就可以通过 cgo 嵌入 这样的一段 C 代码来完成 runtime 启动前执行特定的 C 代码。

runC 中的 nsenter 也是借助 cgo 实现的。

具体代码如下:

//go:build linux && !gccgo
// +build linux,!gccgo

package nsenter

/*
#cgo CFLAGS: -Wall
extern void nsexec();
void __attribute__((constructor)) init(void) {
	// something
}
*/
import "C"

这段代码就会在 Go Runtime 启动前执行这里定义的 init() 函数,我们只需要把 setns 的调用放在这个 init 方法中即可。

cgo

cgo 是一个很炫酷的功能,允许 Go 程序去调用 C 的函数与标准库。你只需要以一种特殊的方式在 Go 的源代码里写出需要调用的 C 的代码,cgo 就可以把你的 C 源码文件和 Go 文件整合成一个包。

下面举一个最简单的例子,在这个例子中有两个函数一Random 和 Seed,在
它们里面调用了 C 的 random 和 srandom 函数。

package main

/*
#include <stdlib.h>
*/
import "C"
import (
    "fmt"
)

func main() {
    Seed(123)
    // Output:Random:  128959393
    fmt.Println("Random: ", Random())
}

// Seed 初始化随机数产生器
func Seed(i int) {
    C.srandom(C.uint(i))
}

// Random 产生一个随机数
func Random() int {
    return int(C.random())
}

这段代码导入了一个叫 C 的包,但是你会发现在 Go 标准库里面并没有这个包,那是因为这根本就不是一个真正的包,而只是 Cgo 创建的一个特殊命名空间,用来与 C 的命名空间交流。

这两个函数都分别调用了 C 里面的 random 和 uint 函数,然后对它们进行了类型转换。这就实现了 Go 代码里面调用 C 的功能。

3. 实现

首先,自然是需要在 C 中实现 setns 核心逻辑,根据 PID 实现 Namespace 切换。

其次,由于使用 C 的 constructor 方式,以 init 形式执行的 setns 这段代码,意味这,执行任何 mydocker 命令的时候这段代码都会执行,因此需要限制,只有 mydocker exec 时才切换 Namespace。

大致流程如下图所示:

mydocker-exec-process.png

setns

setns 的 C 实现具体如下:

package nsenter

/*
#define _GNU_SOURCE
#include <unistd.h>
#include <errno.h>
#include <sched.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>

__attribute__((constructor)) void enter_namespace(void) {
   // 这里的代码会在Go运行时启动前执行,它会在单线程的C上下文中运行
	char *mydocker_pid;
	mydocker_pid = getenv("mydocker_pid");
	if (mydocker_pid) {
		fprintf(stdout, "got mydocker_pid=%s\n", mydocker_pid);
	} else {
		fprintf(stdout, "missing mydocker_pid env skip nsenter");
		// 如果没有指定PID就不需要继续执行,直接退出
		return;
	}
	char *mydocker_cmd;
	mydocker_cmd = getenv("mydocker_cmd");
	if (mydocker_cmd) {
		fprintf(stdout, "got mydocker_cmd=%s\n", mydocker_cmd);
	} else {
		fprintf(stdout, "missing mydocker_cmd env skip nsenter");
		// 如果没有指定命令也是直接退出
		return;
	}
	int i;
	char nspath[1024];
	// 需要进入的5种namespace
	char *namespaces[] = { "ipc", "uts", "net", "pid", "mnt" };

	for (i=0; i<5; i++) {
		// 拼接对应路径,类似于/proc/pid/ns/ipc这样
		sprintf(nspath, "/proc/%s/ns/%s", mydocker_pid, namespaces[i]);
		int fd = open(nspath, O_RDONLY);
		// 执行setns系统调用,进入对应namespace
		if (setns(fd, 0) == -1) {
			fprintf(stderr, "setns on %s namespace failed: %s\n", namespaces[i], strerror(errno));
		} else {
			fprintf(stdout, "setns on %s namespace succeeded\n", namespaces[i]);
		}
		close(fd);
	}
	// 在进入的Namespace中执行指定命令,然后退出
	int res = system(mydocker_cmd);
	exit(0);
	return;
}
*/
import "C"

为什么要这么写,前面 setns 部分已经解释了,这里简单提一下,这里主要使用了构造函数,然后导入了 C 模块,一旦这个包被引用,它就会在所有 Go Runtime 启动之前执行,这样就避免了 Go 多线程导致的无法执行 setns 的问题。

即:这段程序执行完毕后,Go 程序才会执行。

同时,为了避免执行其他命令的时候这段 setns 的逻辑影响到其他功能,因此,在这段 C 代码前面一开始的位置就添加了环境变量检测,没有对应的环境变量时,就直接退出。

    mydocker_cmd = getenv("mydocker_cmd");
		if (mydocker_cmd) {
       // fprintf(stdout, "got mydocker_cmd=%s\n", mydocker_cmd);
    } else {
       // fprintf(stdout, "missing mydocker_cmd env skip nsenter");
       // 如果没有指定命令也是直接退出
       return;
    }

对于不使用 exec 功能的 Go 代码,只要不设置对应的环境变量,这段 C 代码就不会运行,这样就不会影响原来的逻辑。

注意:只有在你的 Go 应用程序中注册、导入了这个包,才会调用这个构造函数。
就像这样:

import (
    _ "mydocker/nsenter"
)

使用 cgo 我们无法直接获取传递给程序的参数,可用的做法是,通过 go exec 创建一个自身运行进程,然后通过传递环境变量的方式,传递给 cgo 参数值。

体现在 runc 中就是 runc create → runc init ,runc 中有很多细节,他通过环境变量传递 netlink fd,然后进行通信。

execCommand

在 main_command.go 中增加一个 execCommand,具体如下:

var execCommand = cli.Command{
    Name:  "exec",
    Usage: "exec a command into container",
    Action: func(context *cli.Context) error {
       // 如果环境变量存在,说明C代码已经运行过了,即setns系统调用已经执行了,这里就直接返回,避免重复执行
       if os.Getenv(EnvExecPid) != "" {
          log.Infof("pid callback pid %v", os.Getgid())
          return nil
       }
       // 格式:mydocker exec 容器名字 命令,因此至少会有两个参数
       if len(context.Args()) < 2 {
          return fmt.Errorf("missing container name or command")
       }
       containerName := context.Args().Get(0)
       // 将除了容器名之外的参数作为命令部分
       var commandArray []string
       for _, arg := range context.Args().Tail() {
          commandArray = append(commandArray, arg)
       }
       ExecContainer(containerName, commandArray)
       return nil
    },
}

然后添加到 main 函数中去:

func main(){
    // 省略其他内容
    app.Commands = []cli.Command{
       initCommand,
       runCommand,
       commitCommand,
       listCommand,
       logCommand,
       execCommand,
    }
}

这里主要是将获取到的容器名和需要的命令处理完成后,交给下面的函数,下面看一下 ExecContainer 的实现。

ExecContainer

exec 命令核心实现就是 ExecContainer 方法。

// nsenter里的C代码里已经出现mydocker_pid和mydocker_cmd这两个Key,主要是为了控制是否执行C代码里面的setns.
const (
	EnvExecPid = "mydocker_pid"
	EnvExecCmd = "mydocker_cmd"
)

func ExecContainer(containerId string, comArray []string) {
	// 根据传进来的容器名获取对应的PID
	pid, err := getPidByContainerId(containerId)
	if err != nil {
		log.Errorf("Exec container getContainerPidByName %s error %v", containerId, err)
		return
	}

	cmd := exec.Command("/proc/self/exe", "exec")
	cmd.Stdin = os.Stdin
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr

	// 把命令拼接成字符串,便于传递
	cmdStr := strings.Join(comArray, " ")
	log.Infof("container pid:%s command:%s", pid, cmdStr)
	_ = os.Setenv(EnvExecPid, pid)
	_ = os.Setenv(EnvExecCmd, cmdStr)

	if err = cmd.Run(); err != nil {
		log.Errorf("Exec container %s error %v", containerId, err)
	}
}

首先是通过ContainerId 找到进程 PID,具体实现如下:

因为之前已经记录了容器信息,因此这里直接读取对应文件就可以找到了。

func getPidByContainerId(containerId string) (string, error) {
	// 拼接出记录容器信息的文件路径
	dirPath := fmt.Sprintf(container.InfoLocFormat, containerId)
	configFilePath := path.Join(dirPath, container.ConfigName)
	// 读取内容并解析
	contentBytes, err := os.ReadFile(configFilePath)
	if err != nil {
		return "", err
	}
	var containerInfo container.Info
	if err = json.Unmarshal(contentBytes, &containerInfo); err != nil {
		return "", err
	}
	return containerInfo.Pid, nil
}

然后则是通过 exec 简单 fork 出了一个进程,并把这个进程的标准输入输出都绑定到宿主机的 stdin、stdout、stderr 上。

    cmd := exec.Command("/proc/self/exe", "exec")
    cmd.Stdin = os.Stdin
    cmd.Stdout = os.Stdout
    cmd.Stderr = os.Stderr

    // 把命令拼接成字符串,便于传递
    cmdStr := strings.Join(comArray, " ")

最关键的是设置环境变量的这两句:

    _ = os.Setenv(EnvExecPid, pid)
    _ = os.Setenv(EnvExecCmd, cmdStr)

设置了这两个环境变量,于是在新的进程里,前面的 nsenter 部分的 C 代码就会执行到 setns 部分逻辑,从而将进程加入到对应的 Namespace 中进行操作了。

C 代码中根据环境变量拿到 PID 和要执行的命令,首先根据 PID 找到对应 Namespace,然后将当前进程加入到该 Namespace 然后执行具体命令。

这也是 mydocker exec 命令要实现的效果。

而执行其他命令时,由于没有指定这两个环境变量,因此那段 C 代码不会执行到 setns 这里。

这时应该就可以明白前面一段 C 代码的意义了 。

mydocker_pid = getenv("mydocker_pid");
if (mydocker_pid) {
    // fprintf(stdout, "got mydocker_pid=%s\n", mydocker_pid);
} else {
    // 如果没有指定PID就不需要继续执行,直接退出
    return;
}

执行 exec 命令就会设置这两个环境变量,那么问题来了,执行 exec 之后环境变量就已经存在了,C 代码也运行了,那么再次执行 exec 命令岂不是会重复执行 setns 系统调用?

为了避免重复执行,在 execCommand 中加了如下判断:如果对应环境变量已经存在了就直接返回,啥也不执行。

因为环境变量存在就代表着 C 代码执行了,即setns系统调用执行了,也就是当前已经在这个 namespace 里了。

var execCommand = cli.Command{
    Name:  "exec",
    Usage: "exec a command into container",
    Action: func(context *cli.Context) error {
       // 如果环境变量存在,说明C代码已经运行过了,即setns系统调用已经执行了,这里就直接返回,避免重复执行
       if os.Getenv(EnvExecPid) != "" {
          log.Infof("pid callback pid %v", os.Getgid())
          return nil
       }
       // 省略其他内容
    },
}

至此, mydocker exec 命令实现就完成了,核心就是 setns 系统调用

4. 测试

首先编译最新的 mydocker,然后启动一个后台容器,这里直接把 name 指定为 test,方便观察。

这里要运行交互式命令,例如 top,保证容器能在后台一直运行。

root@mydocker:~/feat-exec/mydocker# go build  .
root@mydocker:~/feat-exec/mydocker# ./mydocker run -d -name test top
{"level":"info","msg":"createTty false","time":"2024-01-30T09:48:33+08:00"}
{"level":"info","msg":"resConf:\u0026{ 0  }","time":"2024-01-30T09:48:33+08:00"}
{"level":"info","msg":"busybox:/root/busybox busybox.tar:/root/busybox.tar","time":"2024-01-30T09:48:33+08:00"}
{"level":"error","msg":"mkdir dir /root/merged error. mkdir /root/merged: file exists","time":"2024-01-30T09:48:33+08:00"}
{"level":"error","msg":"mkdir dir /root/upper error. mkdir /root/upper: file exists","time":"2024-01-30T09:48:33+08:00"}
{"level":"error","msg":"mkdir dir /root/work error. mkdir /root/work: file exists","time":"2024-01-30T09:48:33+08:00"}
{"level":"info","msg":"mount overlayfs: [/usr/bin/mount -t overlay overlay -o lowerdir=/root/busybox,upperdir=/root/upper,workdir=/root/work /root/merged]","time":"2024-01-30T09:48:33+08:00"}
{"level":"info","msg":"command all is top","time":"2024-01-30T09:48:33+08:00"}

然后查看容器 ID

root@mydocker:~/feat-exec/mydocker# ./mydocker ps
ID           NAME        PID         STATUS      COMMAND     CREATED
2147624410   test        180358      running     top         2024-01-30 09:48:33

然后执行 exec 命令并指定 Id 为 2147624410 进入该容器

root@mydocker:~/feat-exec/mydocker# ./mydocker exec 2147624410 sh
{"level":"info","msg":"container pid:180358 command:sh","time":"2024-01-30T09:48:42+08:00"}
got mydocker_pid=180358
got mydocker_cmd=sh
setns on ipc namespace succeeded
setns on uts namespace succeeded
setns on net namespace succeeded
setns on pid namespace succeeded
setns on mnt namespace succeeded
/ # ps -e
PID   USER     TIME  COMMAND
    1 root      0:00 top
    6 root      0:00 sh
    7 root      0:00 ps -e

在容器内部执行 ps -ef 可以发现 PID 为 1 的进程为 top,这也就意味着已经成功进入到了容器内部。

说明我们的 mydocker exec 命令实现是成功了。

5. 小结

本篇主要实现 mydocker exec 命令,和 docker 实现基本类似,通过 setns 系统调用将当前进程加入到容器所在 Namespace 即可。

比较关键的一点在于,Go Runtime 是多线程的,和 setns 冲突,因此需要使用 Cgo 以constructor 方式在 Go Runtime 启动之前执行 setns 调用。

最后就是根据是否存在指定环境变量来防止重复执行。


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



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

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

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

# 克隆代码
git clone -b feat-exec https://github.com/lixd/mydocker.git
cd mydocker
# 拉取依赖并编译
go mod tidy
go build .
# 测试 
./mydocker run -d -name c1 top
# 查看容器 Id
./mydocker ps
# 根据 Id 执行 exec 进入对应容器
./mydocker exec ${containerId}
VS2022打包C#安装包(最新、最全) 阅读详情

相关推荐

IKM 测试题 - Java SE 8 评估测试题目

IKM 测试题 - Java SE 8 评估测试题目

licheng11y的博客 1317

setns对当前进程无效问题的排查(getpid获取值不变)

1)复现流程及lxc的处理 demo1程序与执行结果如下,此时在容器内部看不到执行的程序。 int main() { int ret, fd, pid; printf("father pid old:%d\n", getpid()); fd = open("/dev/ns", O_RDWR); ret = ioctl(fd, 24635); // parm is dst ns proces...

Pencc的专栏 1335

Ubuntu桌面消失?可能是lightdm配置在捣鬼:详细解析/etc/lightdm.conf的优先级机制与实战修复

本文详细解析了Ubuntu系统因lightdm显示管理器配置错误导致桌面消失的问题。通过分析/etc/lightdm.conf的优先级加载机制,提供了从systemctl诊断、调试模式运行到实战修复配置语法错误(如缺失[Seat:*]组)的完整方案。文章还探讨了在系统无法启动时使用chroot或恢复模式进行高级救援,并对比了lightdm与gdm3在NVIDIA驱动环境下的不同表现,帮助用户高效恢复图形界面。

weixin_29313547的博客 420

unshare与setns函数

作用:分离进程执行上下文的各个部分,允许进程(或线程)解除当前与其他进程(或线程)部分共享的执行上下文;unshare() 允许进程在不创建新进程的情况下控制(主要是取消共享)其共享的执行上下文。当使用 fork(2) 或 vfork(2) 创建新进程时,有的执行上下文,比如命名空间是隐式共享的,即如果你不显式的指定,那么默认创建的子进程或子线程都在同一个命名空间当中。使用clone(2)创建进程或者线程式,有的执行上下文,比如虚拟内存需要显式的指定。

tangzhangyin的专栏 1457

再生龙(clonezilla)镜像比目标盘大——基于centos8.5

再生龙恢复到小盘遇到的问题及处理,首先是修改分区大小,进入dracut模式后再尝试恢复临时系统。

u010101453的博客 3693

堆内存管理核心逻辑 超详细复习笔记

本文详细解析了堆内存管理的核心逻辑,包括初始化、分配和释放三个关键环节。系统通过全局堆管理结构体和链表机制实现动态内存管理:初始化时标记整块内存为空闲;分配时遍历链表查找合适空闲块并进行分割;释放时定位内存块头并重新标记为空闲,支持相邻块合并以减少碎片。文章对比了链表式管理和线性分配的优缺点,指出链表式更灵活但实现复杂,线性分配简单但无法释放。最后总结了常见错误(如指针回推错误、碎片问题)和扩展知识(不同内存管理算法)。这套机制是理解嵌入式系统和RTOS内存管理的基础。

2502_92009732的博客 1205

linux 进程隔离Namespace 学习

linux 进程隔离Namespace 学习

岳来的博客 3280

手把手教你用RSoft BPM仿真一个1x2光分束器:从参数设置到结果分析全记录

本文详细介绍了使用RSoft BPM模块设计和仿真1×2光分束器的完整流程,包括参数设置、结构建模、仿真配置和结果分析。通过实战指南,帮助读者掌握光波导器件的仿真技术,实现50:50功率分配的设计目标,适用于光通信和集成光学领域的研究与应用。

weixin_30545945的博客 546

在CentOS中使用setns系统调用

系统调用setns是内核在3.0引入的一个新的系统调用,参考http://kernelnewbies.org/Linux_3.0#head-69fb31d5d1d284f3a95e56d0ec43a2b23c30c4f3 centos6.5的内核支持该系统调用,但用户态的glibc(2.12)并不支持该系统调用。 考虑下面的示例,引自http://man7.org/linux/man-pa

s1986q的专栏 3754

Anthropic API接入指南:连接失败、403鉴权与Claude Code集成排查

在AI应用开发中,API接入与鉴权机制是开发者绕不开的基础工程问题。无论是调用云端模型服务还是自建网关,网络连通性、HTTP状态码语义、模型路由映射都会直接影响服务可用性。本文从通用的网络诊断与鉴权原理出发,梳理了从TCP连接失败到403权限拒绝的典型链路,并深入解析网关模型路由匹配机制。在此基础上,进一步说明如何通过环境变量完成Claude Code与VS Code的本地集成,以及一套基于Python的可复现接入方案。内容涵盖Anthropic API高频报错定位、curl冒烟测试、SDK工程化实践,适合

weixin_28743405的博客 470

矢量网络分析仪VNA的校准之SOLT方法

作者:杭州冥鸿电子科技有限公司 邮箱:huanglong@deepelec.com S参数的测量方法有两种,一种是基于扫频测量的原理(VNA),另外一种是基于快沿阶跃响应的原理(TDR)。 下图是VNA的原理框图,主要包括以下部分: (1)激励信号源:提供感兴趣的频率范围内的入射信号; (2)信号分离装置:含功分器和定向耦合器,分离出入射,反射和传输信号; (3)接收机:...

u010018619的博客 2万+

Docker--进入容器内部的方法

本文介绍如何进入docker容器的内部进行操作。

IT利刃出鞘的博客 3万+

UDS诊断服务基础详解之二19服务

本文主要介绍UDS统一诊断服务的19 01服务,包含状态位和故障码的解析以及19 01服务的具体说明

车载网络小D的博客 1万+

【mydocker】容器的进阶[ 4 ]

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

weixin_73815624的博客 1780

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

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

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

gitblog_00665的博客 704

lwip-2.0.3

lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

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

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

gitblog_00337的博客 1065

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

从零自制docker-14-【实现 mydocker commit 打包容器成镜像】

这个归档文件内部的所有文件和目录结构,每一项占一行,但并不会展开或提取这个归档文件的实际内容。返回的是一个字节切片,包含命令执行后的输出文本。piveroot切换工作目录到/merged后,通过docker commit将此时工作目录的文件系统保存下来,使用tar包将该文件系统打包为tar文件。它接受一个可变数量的字符串参数,第一个参数是命令名,后面的参数是传递给该命令的各个选项和参数。: 这是一个变量,代表要创建的归档文件的名称(包括路径)。综上所述,这段代码的功能是:在Go程序中执行一个命令,使用。

llovewuzhengzi的博客 1068

动手实现一个docker引擎-4-进阶:实现mydocker的ps/exec/logs/envs等命令

docker容器引擎实现系列

文杰的博客 2002

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

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

探索云原生 696

Docker:构造简单容器

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

xftony的博客 622

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

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

LXYDSF的博客 2458

【fork/exec /proc/self/exe: no such file or directory】namespace里面mount /proc 后,退出后要重新mount

根据mydocker项目实现了简单的docker后,发现在容器中mount /proc 后, 结束程序,再执行就会报错: {"level":"error","msg":"fork/exec /proc/self/exe: no such file or directory","time":"2019-05-30T20:49:35+08:00"} 水平有限,不知道问题出在哪,于是去github上找...

风格色的博客 3917

Docker 基础知识 + 实操

部分图片来自于网上部分博主。

2301_80387628的博客 623

01_手动构建自己开发学习所需的镜像

本文介绍了如何基于RockyLinux官方镜像构建自定义Docker镜像,包括JDK和MariaDB等开发工具。由于DockerHub在国内访问受限,作者通过阿里云镜像获取RockyLinux的ARM架构镜像(Minimal和UBI版本),并详细说明了镜像加载、标签管理和重复镜像处理的方法。文章还演示了从Oracle官网下载多版本JDK(8/11/17/21/25)并准备构建镜像的步骤,为后续开发环境搭建提供基础。整个过程注重镜像安全性和稳定性,适合学习Docker和自定义镜像的用户参考。

ShiJunzhiCome的博客 659

容器核心技术之Namespace

Namespace Linux Namespace 是一种 Linux Kernel 提供的资源隔离方案: • 系统可以为进程分配不同的 Namespace; • 并保证不同的 Namespace 资源独立分配、进程彼此隔离,即 不同的 Namespace 下的进程互不干扰 Linux主要的Namespace如下: Linux内核代码Namespace实现 进程数据结构 struct task_struct { ... /* namespaces */ struct n

qq_29767087的博客 1208

setns系统调用及示例

setns 系统调用允许进程加入现有 Linux 命名空间,实现资源隔离。文章介绍了 setns 的功能、参数和返回值,以及相关错误码和类似函数。示例代码演示了如何创建新 Mount 命名空间并在其中挂载文件系统,该操作仅在子进程命名空间内可见。使用 setns 需要 root 权限,主要用于容器技术实现进程资源隔离。

悟空看八戒烤熟了没的专栏c)4Upqt4SeVk 943
上一篇: 从零开始写 Docker(十)---实现 mydocker logs 查看容器日志
下一篇: 从零开始写 Docker(十二)---实现 mydocker stop 停止容器
探索云原生
博客等级 码龄9年 730粉丝 131原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值