Docker基础之containerd的两个组件：container和process

最新推荐文章于 2023-06-14 19:29:26 发布
最新推荐文章于 2023-06-14 19:29:26 发布
阅读量716 收藏
点赞数
分类专栏： Docker容器技术 文章标签： Linux 运维 docker
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_43405302/article/details/121588771
版权

一、container结构体函数

type container struct {
	// 存储运行时状态信息的路径
	root        string //containerd的工作目录
	id          string
	bundle      string
	runtime     string
	runtimeArgs []string
	shim        string
	processes   map[string]*process
	labels      []string
	oomFds      []int
	//比较chroot和pivot_root
	noPivotRoot bool
	timeout     time.Duration
}
// 生成一个container，并把state信息记录在state.json文件中
func New(opts ContainerOpts) (Container, error) {
	c := &container{
		root:        opts.Root,
		id:          opts.ID,
		bundle:      opts.Bundle,
		labels:      opts.Labels,
		processes:   make(map[string]*process),
		runtime:     opts.Runtime,
		runtimeArgs: opts.RuntimeArgs,
		shim:        opts.Shim,
		noPivotRoot: opts.NoPivotRoot,
		timeout:     opts.Timeout,
	}
	//创建state.json
	if err := os.Mkdir(filepath.Join(c.root, c.id), 0755); err != nil {
		return nil, err
	}
	f, err := os.Create(filepath.Join(c.root, c.id, StateFile))
	if err != nil {
		return nil, err
	}
	defer f.Close()
	if err := json.NewEncoder(f).Encode(state{
		Bundle:      c.bundle,
		Labels:      c.labels,
		Runtime:     c.runtime,
		RuntimeArgs: c.runtimeArgs,
		Shim:        c.shim,
		NoPivotRoot: opts.NoPivotRoot,
	}); err != nil {
		return nil, err
	}
	return c, nil
}

1、 container的Start()函数

func (c *container) Start(checkpointPath string, s Stdio) (Process, error) {
	//创建容器初始化进程工作的根目录
	processRoot := filepath.Join(c.root, c.id, InitProcessID)
	if err := os.Mkdir(processRoot, 0755); err != nil {
		return nil, err
	}
	//生成命令cmd：shim {containerID} {bundleDirPath} runc，工作目录为process目录processRoot；containerd-shim 会调用`runc create {containerID}`
	cmd := exec.Command(c.shim,
		c.id, c.bundle, c.runtime,
	)
	cmd.Dir = processRoot //指定cmd命令执行的工作目录，这里是init命令
	cmd.SysProcAttr = &syscall.SysProcAttr{
		Setpgid: true,
	}
	//读取bundle目录下的config.json文件
	spec, err := c.readSpec()
	if err != nil {
		return nil, err
	}
	config := &processConfig{
		checkpoint: checkpointPath,
		root:       processRoot,
		//InitProcessID = "init" 所有容器的初始化进程
		id:          InitProcessID,
		c:           c,
		stdio:       s,
		spec:        spec,
		processSpec: specs.ProcessSpec(spec.Process),
	}
	//根据构建的进程配置文件config，创建一个type process struct对象
	p, err := newProcess(config)
	if err != nil {
		return nil, err
	}
	if err := c.createCmd(InitProcessID, cmd, p); err != nil {
		return nil, err
	}
	return p, nil
}

2、func Exec()函数
docker exec cmd根据传入的参数生成一个p Process，此时，宿主机上会再执行一个contaninerd-shim，把cmd传递给contaninerd-shim。 如果再加上docker start时的init进程，宿主机上会同时存在两个contaninerd-shim进程。

func (c *container) Exec(pid string, pspec specs.ProcessSpec, s Stdio) (pp Process, err error) {
	//生成exec cmd的工作目录
	processRoot := filepath.Join(c.root, c.id, pid)
	if err := os.Mkdir(processRoot, 0755); err != nil {
		return nil, err
	}
	defer func() {
		if err != nil {
			c.RemoveProcess(pid)
		}
	}()
	//和初始化进程类似，通过containerd-shim执行,cmd.Dir = processRoot ，其值和初始化进程是不一样的,shim正是根据process.json中的相关属性来判断是Start()还是Exec()
	cmd := exec.Command(c.shim,
		c.id, c.bundle, c.runtime,
	)
	cmd.Dir = processRoot //指定cmd的工作目录
	cmd.SysProcAttr = &syscall.SysProcAttr{
		Setpgid: true,
	}
	spec, err := c.readSpec()
	if err != nil {
		return nil, err
	}
	config := &processConfig{
		exec:        true,
		id:          pid,
		root:        processRoot,
		c:           c,
		processSpec: pspec,
		spec:        spec,
		stdio:       s,
	}
	//config会写入process.json文件
	p, err := newProcess(config)
	if err != nil {
		return nil, err
	}
	if err := c.createCmd(pid, cmd, p); err != nil {
		return nil, err
	}
	return p, nil
}

3、createCmd()函数
createCmd()执行一个前面Start()和Exec()生成的containerd-shim命令。
当具体容器内进程pid生成(由runc生成)后，createCmd会启动一个go routine来等待shim命令的结束。
shim命令一般不会退出。
当shim发生退出时，如果容器内的进程仍在运行，则需要把该进程杀死；如果容器内进程已经不存在，则无需清理工作。

func (c *container) createCmd(pid string, cmd *exec.Cmd, p *process) error {
	p.cmd = cmd
	//执行cmd containerd-shim命令
	if err := cmd.Start(); err != nil {
		close(p.cmdDoneCh)
		if exErr, ok := err.(*exec.Error); ok {
			if exErr.Err == exec.ErrNotFound || exErr.Err == os.ErrNotExist {
				return fmt.Errorf("%s not installed on system", c.shim)
			}
		}
		return err
	}
	go func() {
		//Wait()，等待cmd执行完成
		err := p.cmd.Wait()
		if err == nil {
			p.cmdSuccess = true
		}
		close(p.cmdDoneCh)
	}()
	//waitForCreate，等待进程创建完成
	if err := c.waitForCreate(p, cmd); err != nil {
		return err
	}
	c.processes[pid] = p //记录成功创建的容器中进程pid
	return nil
}

4、Load()函数
Load()函数是读取container的state.json及各进程的process.json，还原container对象

// 读取container的state.json及各进程的process.json，还原container对象。
func Load(root, id, shimName string, timeout time.Duration) (Container, error) {
	var s state
	f, err := os.Open(filepath.Join(root, id, StateFile))
	if err != nil {
		return nil, err
	}
	defer f.Close()
	if err := json.NewDecoder(f).Decode(&s); err != nil {
		return nil, err
	}
	c := &container{
		root:        root,
		id:          id,
		bundle:      s.Bundle,
		labels:      s.Labels,
		runtime:     s.Runtime,
		runtimeArgs: s.RuntimeArgs,
		shim:        s.Shim,
		noPivotRoot: s.NoPivotRoot,
		processes:   make(map[string]*process),
		timeout:     timeout,
	}
	if c.shim == "" {
		c.shim = shimName
	}
	dirs, err := ioutil.ReadDir(filepath.Join(root, id))
	if err != nil {
		return nil, err
	}
	// 一个目录代表一个进程
	for _, d := range dirs {
		//如果容器只有一个初始化进程，那么一个是init文件夹，一个是state.json文件
		if !d.IsDir() {
			continue
		}
		pid := d.Name()
		// 读取var/run/docker/libcontainerd/containerd/{containerID}/init/process.json
		s, err := readProcessState(filepath.Join(root, id, pid))
		if err != nil {
			return nil, err
		}
		p, err := loadProcess(filepath.Join(root, id, pid), pid, c, s)
		if err != nil {
			logrus.WithField("id", id).WithField("pid", pid).Debug("containerd: error loading process %s", err)
			continue
		}
		c.processes[pid] = p
	}
	return c, nil
}

5、readProcessState()函数
readProcessState()函数是读取var/run/docker/libcontainerd/containerd/{containerID}/init/process.json，获取容器中进程状态

//读取var/run/docker/libcontainerd/containerd/{containerID}/init/process.json
func readProcessState(dir string) (*ProcessState, error) {
	f, err := os.Open(filepath.Join(dir, "process.json"))
	if err != nil {
		return nil, err
	}
	defer f.Close()
	var s ProcessState
	if err := json.NewDecoder(f).Decode(&s); err != nil {
		return nil, err
	}
	return &s, nil
}

6、readSpec()函数
readSpec()读取bundle目录下的config.json文件。

//readSpec()读取bundle目录下的config.json文件。
func (c *container) readSpec() (*specs.Spec, error) {
	var spec specs.Spec
	f, err := os.Open(filepath.Join(c.bundle, "config.json"))
	if err != nil {
		return nil, err
	}
	defer f.Close()
	if err := json.NewDecoder(f).Decode(&spec); err != nil {
		return nil, err
	}
	return &spec, nil
}

7、Delete()函数
Delete()先移除containerd目录下的容器目录，然后调用runc delete id删除容器。

//Delete()先移除containerd目录下的容器目录，然后调用runc delete id删除容器。
func (c *container) Delete() error {
	err := os.RemoveAll(filepath.Join(c.root, c.id))
	//调用runc delete {containerID}
	args := c.runtimeArgs
	args = append(args, "delete", c.id)
	if b, derr := exec.Command(c.runtime, args...).CombinedOutput(); err != nil {
		err = fmt.Errorf("%s: %q", derr, string(b))
	}
	return err
}

8、RemoveProcess()函数

//删除指定process的目录。在containerd中，一个process用一个目录表示。
func (c *container) RemoveProcess(pid string) error {
	delete(c.processes, pid)
	return os.RemoveAll(filepath.Join(c.root, c.id, pid))
}

9、Pause()和Resume()

//调用`runc pause {containerID}`挂起一个容器
func (c *container) Pause() error {
	args := c.runtimeArgs
	args = append(args, "pause", c.id)
	b, err := exec.Command(c.runtime, args...).CombinedOutput()
	if err != nil {
		return fmt.Errorf("%s: %q", err.Error(), string(b))
	}
	return nil
}
//与Pause()相对应，Resume()恢复某一容器。
func (c *container) Resume() error {
	args := c.runtimeArgs
	args = append(args, "resume", c.id)
	b, err := exec.Command(c.runtime, args...).CombinedOutput()
	if err != nil {
		return fmt.Errorf("%s: %q", err.Error(), string(b))
	}
	return nil
}

10、Status()函数

//通过runc state {containerID}获取容器的状态信息
func (c *container) Status() (State, error) {
	args := c.runtimeArgs
	args = append(args, "state", c.id)
	out, err := exec.Command(c.runtime, args...).CombinedOutput()
	if err != nil {
		return "", fmt.Errorf("%s: %q", err.Error(), out)
	}
	//我们只需要运行时json输出有一个顶级的Status字段。
	var s struct {
		Status State `json:"status"`
	}
	if err := json.Unmarshal(out, &s); err != nil {
		return "", err
	}
	return s.Status, nil
}

11、waitForCreate()函数

//等待进程process创建结束
func (c *container) waitForCreate(p *process, cmd *exec.Cmd) error {
	wc := make(chan error, 1)
	//新建一个goroutine对象来循环读取pidfile（pid文件其实就记录了一行表示该进程的pid）,如果都到该pid的存在，表示创建成功。
	go func() {
		for {
			if _, err := p.getPidFromFile(); err != nil {
				//读取失败后的处理
				if os.IsNotExist(err) || err == errInvalidPidInt {
					alive, err := isAlive(cmd)
					if err != nil {
						wc <- err
						return
					}
					if !alive {
						// Runc可能无法运行容器，所以让我们从日志中获取错误，否则垫片可能会遇到错误
						messages, err := readLogMessages(filepath.Join(p.root, "shim-log.json"))
						if err != nil {
							wc <- err
							return
						}
						for _, m := range messages {
							if m.Level == "error" {
								wc <- fmt.Errorf("shim error: %v", m.Msg)
								return
							}
						}
						// 没有错误报告从shim返回，检查runc/运行时错误
						messages, err = readLogMessages(filepath.Join(p.root, "log.json"))
						if err != nil {
							if os.IsNotExist(err) {
								err = ErrContainerNotStarted
							}
							wc <- err
							return
						}
						for _, m := range messages {
							if m.Level == "error" {
								wc <- fmt.Errorf("oci runtime error: %v", m.Msg)
								return
							}
						}
						wc <- ErrContainerNotStarted
						return
					}
					time.Sleep(15 * time.Millisecond)
					continue
				}
				wc <- err
				return
			}
			// 日志含义读取pid文件成功
			wc <- nil
			return
		}
	}()
	select {
	//channel wc的容量为1
	case err := <-wc:
		if err != nil {
			return err
		}
		return nil
	case <-time.After(c.timeout):
		cmd.Process.Kill()
		cmd.Wait()
		return ErrContainerStartTimeout
	}
}

二、process 构造函数

表示容器内部运行的一个进程

type process struct {
	root        string 
	id          string //标志符
	pid         int //进程标志符
	exitPipe    *os.File //退出文件管道
	controlPipe *os.File //控制文件管道
	container   *container //容器
	spec        specs.ProcessSpec
	stdio       Stdio //标准io
	cmd         *exec.Cmd //控制台
	cmdSuccess  bool //控制指令执行成功标志符
	cmdDoneCh   chan struct{}
	state       State //状态
	stateLock   sync.Mutex
}

1、 newProcess（）函数

//列出一个新进程的相关参数
func newProcess(config *processConfig) (*process, error) {
	p := &process{
		root:      config.root,
		id:        config.id,
		container: config.c,
		spec:      config.processSpec,
		stdio:     config.stdio,
		cmdDoneCh: make(chan struct{}),
		state:     Running,
	}
	uid, gid, err := getRootIDs(config.spec)
	if err != nil {
		return nil, err
	}
	//创建process.json文件
	f, err := os.Create(filepath.Join(config.root, "process.json"))
	if err != nil {
		return nil, err
	}
	defer f.Close()
	//构建进程状态文件
	ps := ProcessState{
		ProcessSpec: config.processSpec,
		Exec:        config.exec,
		PlatformProcessState: PlatformProcessState{
			Checkpoint: config.checkpoint,
			RootUID:    uid,
			RootGID:    gid,
		},
		Stdin:       config.stdio.Stdin,
		Stdout:      config.stdio.Stdout,
		Stderr:      config.stdio.Stderr,
		RuntimeArgs: config.c.runtimeArgs,
		NoPivotRoot: config.c.noPivotRoot,
	}
	//写入process.json
	if err := json.NewEncoder(f).Encode(ps); err != nil {
		return nil, err
	}
	//根据ExitFile文件路径创建Mkfifo管道对象，并以O_NONBLOCK,O_RDONLY模式打开管道OpenFile等待写入的数据并读取。
	exit, err := getExitPipe(filepath.Join(config.root, ExitFile))
	if err != nil {
		return nil, err
	}
	//根据ControlFile文件路径创建Mkfifo管道对象，以O_NONBLOCK,O_RDWD模式打开管道OpenFile等待写入的数据并读取
	control, err := getControlPipe(filepath.Join(config.root, ControlFile))
	if err != nil {
		return nil, err
	}
	//把fifo管道exit赋给p.exitPipe，后面由monitor的epoll机制来读取该管道
	p.exitPipe = exit
	p.controlPipe = control
	return p, nil
}

2、loadProcess（）函数

//从process.json中还原process的信息
func loadProcess(root, id string, c *container, s *ProcessState) (*process, error) {
	p := &process{
		root:      root,
		id:        id,
		container: c,
		spec:      s.ProcessSpec,
		stdio: Stdio{
			Stdin:  s.Stdin,
			Stdout: s.Stdout,
			Stderr: s.Stderr,
		},
		state: Stopped,
	}
	if _, err := p.getPidFromFile(); err != nil {
		return nil, err
	}
	if _, err := p.ExitStatus(); err != nil {
		if err == ErrProcessNotExited {
			exit, err := getExitPipe(filepath.Join(root, ExitFile))
			if err != nil {
				return nil, err
			}
			p.exitPipe = exit

			control, err := getControlPipe(filepath.Join(root, ControlFile))
			if err != nil {
				return nil, err
			}
			p.controlPipe = control

			p.state = Running
			return p, nil
		}
		return nil, err
	}
	return p, nil
}

3、Signal()函数

// S信号量用于控制进程执行顺序
func (p *process) Signal(s os.Signal) error {
	return syscall.Kill(p.pid, s.(syscall.Signal))
}

4、 process的Start()函数

// Start解除与容器相关的初始化进程的阻塞。
func (p *process) Start() error {
	if p.ID() == InitProcessID {
		var (
			errC = make(chan error, 1)
			args = append(p.container.runtimeArgs, "start", p.container.id)
			cmd  = exec.Command(p.container.runtime, args...)
		)
		go func() {
			//若果runc start执行成功，向errC发送nil
			out, err := cmd.CombinedOutput()
			if err != nil {
				errC <- fmt.Errorf("%s: %q", err.Error(), out)
			}
			errC <- nil
		}()
		select {
		case err := <-errC: //出现error
			if err != nil {
				return err
			}
		case <-p.cmdDoneCh: //cmdDoneCh被关闭之后，判断如果不是成功执行，强制kill掉
			if !p.cmdSuccess {//指令执行不成功的操作
				cmd.Process.Kill()
				cmd.Wait()
				return ErrShimExited
			}
			err := <-errC
			if err != nil {
				return err
			}
		}
	}
	return nil
}
绝域时空
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
docker笔记二——容器（Container）相关命令
apodx的博客
05-05 438
二、容器操作 创建容器 docker run [option] --name=${name} image command [args...] option 选项： -i： 交互式容器 -t：tty，终端 -d：后台运行，并且打印出容器id 示例： docker run -i -t -d --name=centOS1 centos /bin/bash 或者 docker run -itd --name=centOS1 centos /bin/bash 注： 创建的容器名称不能重复 进入容器 方
hive出现内存溢出_hive错误记录：虚拟内存溢出
weixin_26976635的博客
12-24 689
Task with the most failures(4):-----Task ID:task_1562543688229_0006_m_000000URL:http://0.0.0.0:8088/taskdetails.jsp?jobid=job_1562543688229_0006&tipid=task_1562543688229_0006_m_000000-----Diagnost...
calico_node的pod报错不能查看日志
贾文超的博客
03-23 958
calico_node的pod报错不能查看日志。
containerd containerd简介
liwench的博客
11-16 141
目录containerd containerd简介containerd是什么containerd和k8s的关系：docker-containerd的作用Containerd的运行优势Containerd 启动流程参考文档containerd containerd简介 containerd是什么 官方定义为k8s默认的官方容器运行时 containerd和k8s的关系： kubelet通过gr...
containerd系列——什么是containerd？
weixin_43860783的博客
02-09 1745
本篇文章是containerd系列的第一篇文章，对containerd进行了系统的介绍，包括其含义，历史以及基础架构（1.4.x）
Empire：一个基于Docker和亚马逊ECS的自托管PaaS
01-30
Heroku已经能很好的满足很多人的需求，但当我们不断壮大，问题和瓶颈频现，为此我们开始寻求解决之道，首先关注的是开源社区中支持Docker的平台，如Flynn、Deis、CoreOS、Kubernetes等，但都不理想，后通过使用...
docker-camunda-bpm-platform:camunda BPM平台的Docker映像
04-30
Camunda平台Docker映像 该Camunda项目提供了最新的Camunda Platform版本的docker映像。 这些图像可用于演示和测试Camunda平台，也可以使用自己的过程应用程序进行扩展。 计划为每个即将发布的版本（包括Alpha版本）...
Docker基础:网络配置
01-27
大量的互联网应用服务包含多个服务组件，这往往需要多个容器之间通过网络通信进行相互配合。Docker 目前提供了映射容器端口到宿主主机和容器互联机制来为容器提供网络服务。接下来我们将讲述Docker 的网络功能，包括...
docker-headless-vnc-container：具有无头VNC环境的Docker映像集合
02-06
docker-headless-vnc-container：具有无头VNC环境的Docker映像集合
docker-process-mining:用于流程挖掘的Docker映像
05-02
docker-process-mining 用于流程挖掘的Docker映像。 这基本上是在 16.04上运行的带有 JRE 1.8的 6。 所有功劳归功于为ProM做出了贡献的人，ProM是一种出色的过程挖掘工具。 快速开始 启动ProM $ docker run --rm...
Prometheus之PromQL语法详解及使用方法
weixin_43805705的博客
03-24 1161
本文是向大家介绍Prometheus中PromQL的查询语法以及常用语句，可以帮助大家理解和掌握Prometheus的查询语言。
Containerd常用命令
12-08 1228
Containerd学习
Containerd容器管理
班婕妤
04-01 1780
nerdctl 安装 containerd的默认命令行工具（crictl）也不是很好用，和docker也不兼容。 nttlabs贡献了一个名为nerdctl的containerd客户端，可以兼容docker命令行工具。于是我们就可以使用nerdctl来作为docker的替代品了。 nerdctl不仅与docker兼容，而且还支持了更多的功能： 1:支持containerd的命名空间查看，nerdctl不仅可以管理Docker容器，也可以直接管理本地的的Kubernetes pod 2:支持将Do
容器运行时Containerd基础
weixin_38320674的博客
03-26 4699
本文目录：一、安装Containerd二、运行一个busybox镜像三、创建CNI网络四、使containerd容器具备网络功能五、与宿主机共享目录六、与其它容器共享ns七、docker/...
一文搞定 Containerd 的使用
极客神殿
06-14 1175
在学习 Containerd 之前我们有必要对 Docker 的发展历史做一个简单的回顾，因为这里面牵涉到的组件实战是有点多，有很多我们会经常听到，但是不清楚这些组件到底是干什么用的，比如等等。
Docker组件介绍：runc和containerd
phone1126的专栏
11-18 1604
Docker组件介绍：runc和containerd
《Kubernetes命令篇：Containerd常用操作》
东城绝神
03-29 985
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。提示：以下是本篇文章正文内容，下面案例可供参考例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。
Docker基本使用
黎明的奔跑
01-08 381
Docker 一.Docker概述 1.1介绍 Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。容器是完全使用沙盒机制，相互之间不会有任何接口（类似 iPhone 的 app）。几乎没有性能开销,可以很容易地在机器和数据中心中运行。最重要的是,他们不依赖于任何语言、框架或包装系统。 ...
轻量级容器管理工具 Containerd
weixin_47758895的博客
04-07 1405
课程操作系统环境为CentOS7u6。
Docker报错之：OCI runtime exec failed: exec failed: container_linux.go:367: starting container process c
最新发布
11-24
Docker报错之：OCI runtime exec failed: exec failed: container_linux.go:367: starting container process caused: exec: "binbash": executable file not found in $PATH: unknown，这个错误通常是由于容器中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

绝域时空

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值