docker架构速看(1)-启动

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()函数，函数简单概括如下：

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

func (cli *DaemonCli) start(opts *daemonOptions) (err error) 
{//根据参数设置cli.Configcli.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.apirouterOptions.cluster = cinitRouter(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 completeerrAPI := <-serveAPIWait
}

loadListener

1. 根据传入的参数，为每个需要处理的host进行相关设置，例如TLS。
2. 调用daemon/listeners包中的listeners.Init()函数，该函数会根据不同的协议（TCP Socket、Unix Socket等）来初始化对应的listener，并将listener绑定到对应的host。
3. 使用初始化好的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初始化HTTPServerfor _, 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,管理volumesd.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 maskedcheckpointrouter.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 {imageBackendimportExportBackendregistryBackend
}// initRoutes initializes the routes in the image router
func (r *imageRouter) initRoutes() {r.routes = []router.Route{// GETrouter.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),// POSTrouter.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),// DELETErouter.NewDeleteRoute("/images/{name:.*}", r.deleteImages),}
}

总结

​ 最后，Docker服务端成功启动，处理请求架构如下：

​ 下一节介绍Docker中的镜像存储。