文接 containerd 源码分析：创建 container（二）
启动 task
上节介绍了创建 task，task 创建之后将返回 response 给 ctr。接着，ctr 调用 task.Start 启动容器。
1// containerd/client/task.go
2func (t *task) Start(ctx context.Context) error {
3 r, err := t.client.TaskService().Start(ctx, &tasks.StartRequest{
4 ContainerID: t.id,
5 })
6 if err != nil {
7 ...
8 }
9 t.pid = r.Pid
10 return nil
11}
12
13// containerd/api/services/tasks/v1/tasks_grpc.pb.go
14func (c *tasksClient) Start(ctx context.Context, in *StartRequest, opts ...grpc.CallOption) (*StartResponse, error) {
15 out := new(StartResponse)
16 err := c.cc.Invoke(ctx, "/containerd.services.tasks.v1.Tasks/Start", in, out, opts...)
17 if err != nil {
18 return nil, err
19 }
20 return out, nil
21}
ctr 调用 contaienrd 的 /containerd.services.tasks.v1.Tasks/Start 接口创建 task。进入 containerd 查看提供该服务的插件：
1// containerd/plugins/services/tasks/service.go
2func (s *service) Start(ctx context.Context, r *api.StartRequest) (*api.StartResponse, error) {
3 return s.local.Start(ctx, r)
4}
5
6// containerd/plugins/services/tasks/local.go
7func (l *local) Start(ctx context.Context, r *api.StartRequest, _ ...grpc.CallOption) (*api.StartResponse, error) {
8 t, err := l.getTask(ctx, r.ContainerID)
9 if err != nil {
10 return nil, err
11 }
12 p := runtime.Process(t)
13 if r.ExecID != "" {
14 if p, err = t.Process(ctx, r.ExecID); err != nil {
15 return nil, errdefs.ToGRPC(err)
16 }
17 }
18 // 启动 task: shimTask.Start
19 if err := p.Start(ctx); err != nil {
20 return nil, errdefs.ToGRPC(err)
21 }
22 state, err := p.State(ctx)
23 if err != nil {
24 return nil, errdefs.ToGRPC(err)
25 }
26 return &api.StartResponse{
27 Pid: state.Pid,
28 }, nil
29}
30
31// containerd/core/runtime/v2/shim.go
32func (s *shimTask) Start(ctx context.Context) error {
33 _, err := s.task.Start(ctx, &task.StartRequest{
34 ID: s.ID(),
35 })
36 if err != nil {
37 return errdefs.FromGRPC(err)
38 }
39 return nil
40}
41
42// containerd/api/runtime/task/v2/shim_ttrpc.pb.go
43func (c *taskClient) Start(ctx context.Context, req *StartRequest) (*StartResponse, error) {
44 var resp StartResponse
45 if err := c.client.Call(ctx, "containerd.task.v2.Task", "Start", req, &resp); err != nil {
46 return nil, err
47 }
48 return &resp, nil
49}
经过 containerd 各个插件的层层调用，最终走到 containerd.task.v2.Task.Start ttrpc 服务。提供 containerd.task.v2.Task.Start 服务的是 containerd-shim-runc-v2：
1// containerd/cmd/containerd-shim-runc-v2/task/service.go
2// Start a process
3func (s *service) Start(ctx context.Context, r *taskAPI.StartRequest) (*taskAPI.StartResponse, error) {
4 // 根据 task 的 StartRequest 获得 container 的 metadata
5 container, err := s.getContainer(r.ID)
6 if err != nil {
7 return nil, err
8 }
9
10 ...
11 p, err := container.Start(ctx, r)
12 if err != nil {
13 handleStarted(container, p)
14 return nil, errdefs.ToGRPC(err)
15 }
16 ...
17}
调用 Container.Start 启动容器进程：
1// containerd/cmd/containerd-shim-runc-v2/runc/container.go
2// Start a container process
3func (c *Container) Start(ctx context.Context, r *task.StartRequest) (process.Process, error) {
4 p, err := c.Process(r.ExecID)
5 if err != nil {
6 return nil, err
7 }
8 if err := p.Start(ctx); err != nil {
9 return p, err
10 }
11 ...
12}
Container.Start 调用 Process.Start 启动容器进程。启动容器后 runc init 将退出，将容器的主进程交由 runc init 的父进程 shim：
1# ps -ef | grep 138915
2root 138915 1 0 15:52 ? 00:00:00 /usr/bin/containerd-shim-runc-v2 -namespace default -id nginx1 -address /run/containerd/containerd.sock
3root 138934 138915 0 15:52 ? 00:00:00 nginx: master process nginx -g daemon off;
通过这样的处理，容器进程就和 containerd 没关系了，容器不再受 containerd 的影响，仅和它的 shim 有关系，被 shim 管理，这也是为什么要引入 shim 的原因。
containerd
从上述 containerd 创建 container 的分析可以看出，containerd 中插件之间的调用是分层的。contianerd 架构如下：
containerd 创建 container 的示意图如下：
ctr 创建的 container 的交互流程图如下：
小结
containerd 源码分析系列文章介绍了 contianerd 是如何创建 container 的，完整了从 kubernetes 到容器创建这一条线。