Docker架构速看(1)-启动

Docker是常用的容器管理工具，这篇文章对Docker架构结合源码做简要分析，由于也只使用过很少的命令，所以只分析image和container的相关部分。

源码准备

Docker源码可以在github上找到，当前已更名为Moby,这里采用22.06稳定版分支的代码。Moby项目使用vendor目录管理依赖，在vendor.mod开头指明了Moby项目的模块github.com/docker/docker，所以需要把moby更名为docker，并放置在GOPATH的对应目录下。

GOPATH
|	src
	|	github.com
		|	doccker
			|	docker(moby)
|	bin
|	pkg

关于Docker项目代码结构可以参看这篇2017年的文章，Docker源码分析第一篇 JIMMY SONG

启动过程

Docker采用了C/S架构，客户端发送请求到服务端，由服务端docker daemon根据请求完成镜像查询，镜像拉取，容器启动等工作。在这里我们主要分析Docker服务端的启动过程。

在这里插入图片描述

cmd/dockerd/包下是命令行启动Docker的相关代码，docker.go是启动入口文件。其中newDaemonCommand()函数处理命令行参数，并将参数传递到daemon.go中DaemonCli的start()函数，函数简单概括如下：

根据传入的参数设置守护进程的配置信息。
加载listener,监听hosts
创建一个新的守护进程(daemon)对象，并启动它。
初始化路由，将不同的请求路由到不同的后端服务进行处理。
启动API服务，开始监听客户端的请求，并将请求路由到正确的后端服务进行处理。
等待API服务结束，返回可能发生的错误。

func (cli *DaemonCli) start(opts *daemonOptions) (err error) 
{
 	//根据参数设置cli.Config
	cli.Config, err = loadDaemonCliConfig(opts)。
	
	/*
	加载listener,监听端口
	*/
	hosts, err := loadListeners(cli, serverConfig) 
    
    //初始化中间件
    pluginStore := plugin.NewStore()
    cli.initMiddlewares(cli.api, serverConfig, pluginStore)
    
    //启动新守护进程
    d, err := daemon.NewDaemon(ctx, cli.Config, pluginStore)
    
    //初始化路由信息，将不同请求(image,cocntainer...)路由到不同后端服务处理
	routerOptions, err := newRouterOptions(cli.Config, d)
	routerOptions.api = cli.api
	routerOptions.cluster = c
	initRouter(routerOptions)
    
    //开始接受请求了
  	serveAPIWait := make(chan error)
    //其中根据路由信息为servers添加handler，之后循环处理请求，一个简单的服务器
	go cli.api.Wait(serveAPIWait)
	notifyReady()
	// Daemon is fully initialized and handling API traffic
	// Wait for serve API to complete
	errAPI := <-serveAPIWait
}

loadListener

根据传入的参数，为每个需要处理的host进行相关设置，例如TLS。
调用daemon/listeners包中的listeners.Init()函数，该函数会根据不同的协议（TCP Socket、Unix Socket等）来初始化对应的listener，并将listener绑定到对应的host。
使用初始化好的listener初始化HTTPServer，并加入到servers中。

由此可见Docker客户端和服务器端可以通过TCP socket,Unix socket建立连接，上层使用HTTP协议通信。

//loadListener
func loadListeners(cli *DaemonCli, serverConfig *apiserver.Config)
{
    //处理设置中所有host,格式： 协议:://地址
	for i := 0; i < len(serverConfig.Hosts); i++ {
        //处理host协议，地址
        protoAddr := serverConfig.Hosts[i]
        protoAddrParts := strings.SplitN(serverConfig.Hosts[i], "://", 2)
        proto, addr := protoAddrParts[0], protoAddrParts[1]
        
        //处理TLS config ...
        
        ls, err := listeners.Init(proto, addr, serverConfig.SocketGroup, serverConfig.TLSConfig)
        
		hosts = append(hosts, protoAddrParts[1])
        //
		cli.api.Accept(addr, ls...)
    }
    
    return hosts
}

// Init 初始化对应host的listener
func Init(proto, addr, socketGroup string, tlsConfig *tls.Config) ([]net.Listener, error) 
{
    // 根据协议不同，对listener做不同初始化
    switch proto {
    // 
	case "fd":
		fds, err := listenFD(addr, tlsConfig)
		ls = append(ls, fds...)
	case "tcp":
		l, err := sockets.NewTCPSocket(addr, tlsConfig)
		ls = append(ls, l)
	case "unix":
		gid, err := lookupGID(socketGroup)
		l, err := sockets.NewUnixSocket(addr, gid)
		ls = append(ls, l)
	default:
		return nil, errors.Errorf("invalid protocol format: %q", proto)
	}
}


func (s *Server) Accept(addr string, listeners ...net.Listener) 
{
    // 通过初始化好的listener初始化HTTPServer
	for _, listener := range listeners 
    {
		httpServer := &HTTPServer{
			srv: &http.Server{
				Addr:              addr,
				ReadHeaderTimeout: 5 * time.Minute, // "G112: Potential Slowloris Attack (gosec)"; not a real concern for our use, so setting a long timeout.
			},
			l: listener,
		}
		s.servers = append(s.servers, httpServer)
	}
}

NewDaemon

daemon.NewDaemon()新建Docker守护进程，NewDaemon设置了所有必要的内容，使得守护进程能够处理来自Web服务器的请求。让我们看看他做了什么，下面代码中忽略了很多设置验证内容，列出了主干部分。

func NewDaemon(ctx context.Context, config *config.Config, pluginStore *plugin.Store) (daemon *Daemon, err error) 
{
    // 初始化registrySservice,提供容器注册中心服务，从注册中心拉取，提交容器镜像等。
	registryService, err := registry.NewService(config.ServiceOptions)
    ...
    d.registryService = registryService
    
    // Plugin system initialization should happen before restore. Do not change order.
    d.pluginManager, err = plugin.NewManager(plugin.ManagerConfig{})
    
    //初始化 layer.Store,
    layerStore, err := layer.NewStoreFromOptions(layer.StoreOptions{})
    //初始化 image.BackendStore,底层文件系统存储
	ifs, err := image.NewFSStoreBackend(filepath.Join(imageRoot, "imagedb"))
    //layerStore+fsStore 初始化image.Store,镜像存储
	imageStore, err := image.NewImageStore(ifs, layerStore)
    
    //初始化 VolumesService,管理volumes
  	d.volumes, err = volumesservice.NewVolumeService(config.Root, d.PluginStore, rootIDs, d)
    
    //初始化imageService,提供镜像管理
    d.imageService = images.NewImageService(imgSvcConfig)
    
}

可以看到daemon进程初始化中会初始化，启动镜像服务，容器服务，数据卷服务等，请求都是由这些服务来处理。

InitRouter

在之前可以看到daemon.NewDaemon()完成后还有一步，初始化路由initRouter()，在该函数中会初始化各种请求的路由，实际就是为不同请求路径添加不同handler,转发不同HTTP请求，交由后端服务处理。

func initRouter(opts routerOptions)
{
	routers := []router.Router{
		// we need to add the checkpoint router before the container router or the DELETE gets masked
		checkpointrouter.NewRouter(opts.daemon, decoder),
        //容器相关请求路由
		container.NewRouter(opts.daemon, decoder, opts.daemon.RawSysInfo().CgroupUnified),
        //镜像相关请求路由
		image.NewRouter(
			opts.daemon.ImageService(),
			opts.daemon.ReferenceStore,
			opts.daemon.ImageService().DistributionServices().ImageStore,
			opts.daemon.ImageService().DistributionServices().LayerStore,
		),
		systemrouter.NewRouter(opts.daemon, opts.cluster, opts.buildkit, opts.features),
		volume.NewRouter(opts.daemon.VolumesService(), opts.cluster),
		build.NewRouter(opts.buildBackend, opts.daemon, opts.features),
		sessionrouter.NewRouter(opts.sessionManager),
		swarmrouter.NewRouter(opts.cluster),
		pluginrouter.NewRouter(opts.daemon.PluginManager()),
		distributionrouter.NewRouter(opts.daemon.ImageService()),
	}
}

这里拿image router举例，看看image.NewRouter()函数。其中backend实际提供后端服务，这里的backend实际上是一个接口，包含各种镜像操作。而在Docker中实现了该接口的就是之前初始化的ImageService。在看一下r.initRoutes()就可以看到不同路径的路由信息，不同路径的请求交由不同函数处理，这些函数会解析请求参数，最后调用backend提供的函数进行真实处理。

// NewRouter initializes a new image router
func NewRouter(backend Backend, referenceBackend reference.Store, imageStore image.Store, layerStore layer.Store) router.Router {
	r := &imageRouter{
		backend:          backend, //实际提供后端服务
		referenceBackend: referenceBackend,
		imageStore:       imageStore,
		layerStore:       layerStore,
	}
	r.initRoutes()
	return r
}

// /api/server/router/image/backend.go
//	api包下定义的接口
type Backend interface {
	imageBackend
	importExportBackend
	registryBackend
}

// initRoutes initializes the routes in the image router
func (r *imageRouter) initRoutes() {
	r.routes = []router.Route{
		// GET
		router.NewGetRoute("/images/json", r.getImagesJSON),
		router.NewGetRoute("/images/search", r.getImagesSearch),
		router.NewGetRoute("/images/get", r.getImagesGet),
		router.NewGetRoute("/images/{name:.*}/get", r.getImagesGet),
		router.NewGetRoute("/images/{name:.*}/history", r.getImagesHistory),
		router.NewGetRoute("/images/{name:.*}/json", r.getImagesByName),
		// POST
		router.NewPostRoute("/images/load", r.postImagesLoad),
		router.NewPostRoute("/images/create", r.postImagesCreate),
		router.NewPostRoute("/images/{name:.*}/push", r.postImagesPush),
		router.NewPostRoute("/images/{name:.*}/tag", r.postImagesTag),
		router.NewPostRoute("/images/prune", r.postImagesPrune),
		// DELETE
		router.NewDeleteRoute("/images/{name:.*}", r.deleteImages),
	}
}