dockerd、contaierd、containerd-shim、runC通信机制分析

版权声明:本文为博主原创文章,遵循 CC 4.0 by-sa 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/Jinhua_Wei/article/details/79874592

整体框架分析

dockerd 底层运行容器需要依赖多个二级制组件:docker daemon, containerd, container-shim, runC,
代码实现上,containerd包含了container-shim代码。同一份代码,通过Makefile编译控制,编译成两个二级制文件。

组件间通信

概括图
"底层通信概括图"

通信流程:
1. docker daemon 模块通过 grpc 和 containerd模块通信:dockerd 由libcontainerd负责和containerd模块进行交换, dockerd 和 containerd 通信socket文件:docker-containerd.sock
2. containerd 在dockerd 启动时被启动,启动时,启动grpc请求监听。containerd处理grpc请求,根据请求做相应动作;
3. 若是start或是exec 容器,containerd 拉起一个container-shim , 并通过exit 、control 文件(每个容器独有)通信;
4. container-shim别拉起后,start/exec/create拉起runC进程,通过exit、control文件和containerd通信,通过父子进程关系和SIGCHLD监控容器中进程状态;
5. 若是top等命令,containerd通过runC二级制组件直接和容器交换;
6. 在整个容器生命周期中,containerd通过 epoll 监控容器文件,监控容器的OOM等事件

NOTE:
containerd,container-shim 组件本质上runC 和dockerd 间的adapter中间件,容器本身有runC单独完成 — 使用runC可以单独完成一个容器部署。

组件通信详细分析

DOCKER DEAMON —> LIBCONTAINERD 组件分析

LIBCONTAINERD 部分主要作用:1,赋值和CONTAINERD进程通信 2,监控CONTAINERD进程状态

LIBCONTAINERD 随DOCKERD启动,启动过程中启动协程监控:1. 和CONTAINERD间的grpc链接情况 2. 监听由CONTAINERD发送过来的消息
启动监控消息协程

//libcontainerd/remote_linux.go
//starEventMonitor() ---> handleEventStream()

func (r *remote) handleEventStream(events containerd.API_EventsClient) {
    for {
        e, err := events.Recv()   // ---> 此为阻塞方法:等待CONTAINERD发送 gRPC消息
...
        if err := container.handleEvent(e); err != nil {
            logrus.Errorf("libcontainerd: error processing state change for %s: %v", e.Id, err)
        }
        ...
}

上面主要代码主要功能就是接收gRPC返回的事件,并调用各自容器来的handleEvent对事件进行处理

//libcontainerd/container_linux.go
func (ctr *container) handleEvent(e *containerd.Event) error {
    ctr.client.lock(ctr.containerID)
    defer ctr.client.unlock(ctr.containerID)
    switch e.Type {
    case StateExit, StatePause, StateResume, StateOOM:
        st := StateInfo{
            CommonStateInfo: CommonStateInfo{
                State:    e.Type,
                ExitCode: e.Status,
            },
            OOMKilled: e.Type == StateExit && ctr.oom,
        }
        if e.Type == StateOOM {
            ctr.oom = true
        }
        if e.Type == StateExit && e.Pid != InitFriendlyName {
            st.ProcessID = e.Pid
            st.State = StateExitProcess
        }

        // Remove process from list if we have exited
        switch st.State {
        case StateExit:
            ctr.clean()
            ctr.client.deleteContainer(e.Id)
        case StateExitProcess:
            ctr.cleanProcess(st.ProcessID)
        }
        ctr.client.q.append(e.Id, func() {
            if err := ctr.client.backend.StateChanged(e.Id, st); err != nil {
                logrus.Errorf("libcontainerd: backend.StateChanged(): %v", err)
            }

            if e.Type == StatePause || e.Type == StateResume {
                ctr.pauseMonitor.handle(e.Type)
            }
            if e.Type == StateExit {
                if en := ctr.client.getExitNotifier(e.Id); en != nil {
                    en.close()
                }
            }
        })

    default:
        logrus.Debugf("libcontainerd: event unhandled: %+v", e)
    }
    return nil
}

handleEvent 函数处理event事件,并将event放入client的队列,等待被调度;
remote.q的目的:保证来自于容一个id容器的grpc包,能安装先进先出的顺序处理。

启动监控gRPC链接协程

//libcontainerd/remote_linux.go
// New()//New creates a fresh instance of libcontainerd remote -> handleConnectionChange()

handleConnectionChange()主要功能:根据gRPC状态判断、确定CONTAINERD的状态,并做相应的处理

CONTAINERD 组件分析

CONTTAINERD的主要功能:
1. 和DOCKERD 的LIBCONTAINERD通信 —> gRPC
2. 和CONTAINER-SHIM 、runC进行通信 —> 进程返回或epoll系统调用方式
3. 简单的调度和任务分发

CONTAINERD 关键组成部分

├── api         //gRPC 事件处理
├── containerd  //CONTAINERD 命令处理 ---> main 主函数
├── runtime     //以容器为单位,处理状态、事件
├── supervisor  //以整体为单位,处理、转发状态、事件

CONTAINERD 启动

CONTAINERD 是随DOCKERD启动而启动的后台进程。
CONTAINERD 启动过程中,主要工作:
1. 启动gRPC服务
gRPC启动后,主要监控事件:

//containerd/api/grpc/types/api.proto
service API {
    rpc GetServerVersion(GetServerVersionRequest) returns (GetServerVersionResponse) {}
    rpc CreateContainer(CreateContainerRequest) returns (CreateContainerResponse) {}
    rpc UpdateContainer(UpdateContainerRequest) returns (UpdateContainerResponse) {}
    rpc Signal(SignalRequest) returns (SignalResponse) {}
    rpc UpdateProcess(UpdateProcessRequest) returns (UpdateProcessResponse) {}
    rpc AddProcess(AddProcessRequest) returns (AddProcessResponse) {}
    rpc CreateCheckpoint(CreateCheckpointRequest) returns (CreateCheckpointResponse) {}
    rpc DeleteCheckpoint(DeleteCheckpointRequest) returns (DeleteCheckpointResponse) {}
    rpc ListCheckpoint(ListCheckpointRequest) returns (ListCheckpointResponse) {}
    rpc State(StateRequest) returns (StateResponse) {}
    rpc Events(EventsRequest) returns (stream Event) {}
    rpc Stats(StatsRequest) returns (StatsResponse) {}
}

处理事件代码://containerd/api/grpc/server/server.go

  1. 启动supervisor.Supervisor 从整体上监控事件:grpc事件、容器OOM事件、容器进程退出事件
    Supervisor的New函数:
//Superviso New函数
...
    monitor, err := NewMonitor()
...
    go s.exitHandler()      //启动协程监控全部的Exit事件,并分发
    go s.oomHandler()       //启动协程监控全部的OOM事件,并分发
    if err := s.restore(); err != nil { //重启以后的容器 --->CONTAINERD进程被杀死,DOCKERD进程重新拉起CONTAINERD场景下生效
        return nil, err
    }
...

exitHandle() 和comHandler()代码

//containerd/supervisor/supervisor.go
func (s *Supervisor) exitHandler() {
    for p := range s.monitor.Exits() {
        e := &ExitTask{
            Process: p,
        }
        e.WithContext(context.Background())
        s.SendTask(e)
    }
}

func (s *Supervisor) oomHandler() {
    for id := range s.monitor.OOMs() {
        e := &OOMTask{
            ID: id,
        }
        e.WithContext(context.Background())
        s.SendTask(e)
    }
}

这两个函数监控,Exit和OOM事件,并通过SendTask发送事件

Supervisor的Start函数干的主要事情:启动一个协程循环等待地处理tasks中的事件

func (s *Supervisor) Start() error {
...
    go func() {
        for i := range s.tasks {
            s.handleTask(i)
        }
    }()
    return nil
}

上述提到SendTask函数:发送事件给s.tasks

func (s *Supervisor) SendTask(evt Task) {
    select {
    case <-evt.Ctx().Done():
        evt.ErrorCh() <- evt.Ctx().Err()
        close(evt.ErrorCh())
    case s.tasks <- evt:
        TasksCounter.Inc(1)
    }
}

Sendtask在api的gRPC事件监控和OOM等事件监控, 改函数将上次事件源,发送给Supervisor协程,Supervisor处理事件: gRPC等事件 —> sendTask —> Supervisor handleTask

handleTask处理不同事件


func (s *Supervisor) handleTask(i Task) {
    var err error
    switch t := i.(type) {
    case *AddProcessTask:
        err = s.addProcess(t)
    case *CreateCheckpointTask:
        err = s.createCheckpoint(t)
    case *DeleteCheckpointTask:
        err = s.deleteCheckpoint(t)
    case *StartTask:
        err = s.start(t)
    case *DeleteTask:
        err = s.delete(t)
    case *ExitTask:
        err = s.exit(t)
    case *GetContainersTask:
        err = s.getContainers(t)
    case *SignalTask:
        err = s.signal(t)
    case *StatsTask:
        err = s.stats(t)
    case *UpdateTask:
        err = s.updateContainer(t)
    case *UpdateProcessTask:
        err = s.updateProcess(t)
    case *OOMTask:
        err = s.oom(t)
    default:
        err = ErrUnknownTask
    }
    if err != errDeferredResponse {
        i.ErrorCh() <- err
        close(i.ErrorCh())
    }
}
  1. 启动多个Supervisor.work协程,并发处理容器创建任务
    在CONTAINER启动时,创建了十个work协程池
//containerd/main.go ---> damon()函数
    wg := &sync.WaitGroup{}
    for i := 0; i < 10; i++ {
        wg.Add(1)
        w := supervisor.NewWorker(sv, wg)
        go w.Start()
    }

containerd/supervisor/work.go —> Start()函数主要功能:循环等待监控 w.s.startTasks CHANNEL ,创建相应的容器,并将创建结构以 Event方式通知 gRPC server。

其他

CONTAINERD 的runtime部分,包括container —> 运行时,containerd中代码的容器信息实体 ; Process —>运行时容器中的进程信息

CONTAINERD-SHIM 分析

CONTAINERD-SHIM的代码和业务逻辑都很简单;其主要实现目的:
1. 通过runC命令可以启动、执行容器、进程;
2. 监控容器进程状态,当容器执行完成后,通过exit fifo文件报告容器进程结束状态;
3. 当此容器SHIM的第一个实例进程被杀死后,reaper掉所有其子进程;

一个容器可以由多个container-shim进程;container-shim进程由containerd进程拉起,并持续存在到容器实例进程退出为止;

代码流程分析

CONTAINERD-SHIM的代码在containerd/container-shim/目录下;主要包含main.go和process.go;
主要启动业务逻辑:

main()
------>start()
------------>(p *process) create() //主要功能启动runC进程
------>start函数中,监控runC进程状态

runC 简要分析

runC 是一套符合OCI标准的容器引擎;其是一个非常独立,真正创建容器的组件,runC可以独立于dockerd创建、操作容器,其功能和LXC等容器化工具类似;使用runC主要功能:创建、并启动标准化容器。
容器使用的主要技术(Linux):namespace 资源隔离,cgroup 资源限制
关于容器的资源和好文:
1. OCI标准化 runtime-spec
2. namespace技术说明 —> Namespace资源隔离
3. 容器标准化和 docker
4. cgroup 实现原理与使用 —>Linux Cgroups 详解

runC源码分析:网上有较多的runC源码分析,所以不做过多介绍 —> docker RunC Create 源码简单分析

dockerd 启动一个容器流程分析

dockerd 端函数调用链:

containerStart() —> (clnt *client) Create() —> (ctr *container) start —> ctr.client.remote.apiClient.CreateContainer —> 向containerd发送gRPC信号

containerd端的函数执行流程:

gRPC接收到来自于dockerd的请求 —> (s *apiServer) CreateContainer —>s.sv.SendTask(e) —> 向supervisor.Supervisor发送函数创建容器事件

supervisor.Supervisor 处理协程收到容器创建事件 —> handleTask() —> s.start(t) —> s.startTasks <- task: 将创建容器事件从新包装后发送给work的处理事件协程

supervisor.work处理事件协程收到创建容器事件(work.go/Start(): 在此函数中操作创建、运行容器,此函数主要工作:
1. 创建容器:t.Container.Start:(c *container) Start —> (c *container) createCmd:使用shim create 进程方式创建容器(异步方式) —> 启动shim进程,使用runC create 方式创建容器(创建但不运行容器进程)(异步方式)—> 容器创建成功,此时容器状态为created,并卡在/proc/self/exe init进程中 —> shim启动runC完后,循环监控容器状态,直至此容器进程实例结束
2. 调用w.s.monitor.MonitorOOM(t.Container)函数,使用epoll方式监控,容器的OOM流程
3. 调用w.s.monitorProcess(process)函数,使用epoll方式监控,容器进程实例退出事件
4. 调用process.Start启动容器进程实例:(p *process) Start() —> 使用runC start 方式启动容器进程实例(此为第一步骤同个container-id)
5. 调用w.s.notifySubscribers 将容器创建完成事件,通知给api的事件监控模块

containerd/api/grpc/server.go/Events函数 —> for 循环监听到容器创建完成事件 —> 封装gRPC的Event事件 —>通过types.API_EventsServer send()方法发送Event

dockerd的监控消息协程将接收并处理容器创建成功的事件,更新dockerd端信息。—>前面已经分析

多个组件间通信分析

dockerd 与 containerd间通信

dockerd和containerd之间通过 gRPC 通信;
方法定义:./vendor/src/github.com/docker/containerd/api/grpc/types/api.proto

containerd 获取容器实例进程退出、OOM状态

在 supervisor.Supervisor 启动时,会启动两个协程监控监控退出和OOM状态,见上文分析;
在supervisor.work启动容器时,将容器状态添加到监控中:

//(w *worker) Start()
w.s.monitor.MonitorOOM(t.Container)
w.s.monitorProcess(process)
//monitorProcess ---> Monitor()
func (m *Monitor) Monitor(p runtime.Process) error {
    m.m.Lock()
    defer m.m.Unlock()
    fd := p.ExitFD()
    event := syscall.EpollEvent{
        Fd:     int32(fd),
        Events: syscall.EPOLLHUP,
    }
    if err := archutils.EpollCtl(m.epollFd, syscall.EPOLL_CTL_ADD, fd, &event); err != nil {
        return err
    }
    EpollFdCounter.Inc(1)
    m.receivers[fd] = p
    return nil
}

使用epoll 系统调用,监控exit文件的EPOLLHUP事件:当open exit文件后,在close时刻会触发EPOLLHUP事件

exit文件在什么地方close? —> 在shim进程退出时,close 掉exit文件。

// containerd-shim/main.go /start()
    f, err := os.OpenFile("exit", syscall.O_WRONLY, 0)
    if err != nil {
        return err
    }
    defer f.Close()

shim 进程什么时候退出?
shim for 循环中代码:

//start函数
        case s := <-signals:
            switch s {
            case syscall.SIGCHLD://子进程退出信号
                exits, _ := osutils.Reap(false) //杀掉所欲子进程
                for _, e := range exits {
                    // check to see if runtime is one of the processes that has exited
                    if e.Pid == p.pid() {
                        exitShim = true
                        writeInt("exitStatus", e.Status)
                    }
                }
            }
            // runtime has exited so the shim can also exit
            if exitShim {
                // kill all processes in the container incase it was not running in
                // its own PID namespace
                p.killAll()
                // wait for all the processes and IO to finish
                p.Wait()
                // delete the container from the runtime
                p.delete()
                // the close of the exit fifo will happen when the shim exits
                return nil
            }

shim 在其所有子进程(SHIM创建的进程根,其及其子进程创建的进程都为其子进程)都退出后,SHIM进程退出。
容器进程退出流程:(假设为init进程退出)
容器的实例进程完全退出后,shim进程退出 —> 引发exit 文件的EPOLLHUP事件 —> supervisor中检测到process退出 —>*Supervisor) exitHandler()协程获取到退出事件 —>SendTask:ExitTask —>(s *Supervisor) Start()协程处理退出事件 —> handleTask —> s.exit(t) —> s.delete(ne):ne为DeleteTask —> s.deleteContainer(i.container)删除容器:在containerd内存结构数据 —> s.notifySubscribers 通知api Event协程,向dockerd发送容器退出状态

退出容器退出过程中,会获取容器退出状态,并将退出码发送给dockerd;
(s *Supervisor) exit —> proc.ExitStatus:获取退出码 —> handleSigkilledShim 根据Shim的退出状态定义退出码

containerd 和 shim 交互

containerd 获取 shim退出状态:上已分析
containerd通过control文件控制shim
containerd对代码:

func (p *process) Resize(w, h int) error {
    _, err := fmt.Fprintf(p.controlPipe, "%d %d %d\n", 1, w, h)
    return err
}

shim端代码:

//container-shim/main.go start()函数
    go func() {
        for {
            var m controlMessage
            if _, err := fmt.Fscanf(control, "%d %d %d\n", &m.Type, &m.Width, &m.Height); err != nil {
                continue
            }
            msgC <- m
        }
    }()

containerd 和 runC 交互

containerd 通过runC命令,获取命令返回输出,获取runC状态:如(c *container) Status()函数

展开阅读全文

没有更多推荐了,返回首页