萬字長文：徹底搞懂容器鏡像構建

1➜  ~ docker version |grep API
2 API version:       1.41
3  API version:      1.41 (minimum version 1.12)

1(MoeLove) ➜  git clone https://github.com/docker/docker.git docker
2(MoeLove) ➜  cd docker
3(MoeLove) ➜  docker git:(master) git checkout -b v20.10.5 v20.10.5
4(MoeLove) ➜  docker git:(v20.10.5) make swagger-docs
5API docs preview will be running at http://localhost:9000

1/ # curl -X POST --unix-socket /var/run/docker.sock  localhost/v1.41/build 
2{"message":"Cannot locate specified Dockerfile: Dockerfile"}

1(MoeLove) ➜  git clone https://github.com/docker/cli.git
2(MoeLove) ➜  cd cli
3(MoeLove) ➜  cli git:(master) git checkout -b v20.10.5 v20.10.5

1if v, ok := aliasMap["builder"]; ok {
2    aliases = append(aliases,
3        [2][]string{{"build"}, {v, "build"}},
4        [2][]string{{"image", "build"}, {v, "build"}},
5    )
6}

 1func runBuild(dockerCli command.Cli, options buildOptions) error {
 2	buildkitEnabled, err := command.BuildKitEnabled(dockerCli.ServerInfo())
 3	if err != nil {
 4		return err
 5	}
 6	if buildkitEnabled {
 7		return runBuildBuildKit(dockerCli, options)
 8	}
 9    
10}

 1func BuildKitEnabled(si ServerInfo) (bool, error) {
 2	buildkitEnabled := si.BuildkitVersion == types.BuilderBuildKit
 3	if buildkitEnv := os.Getenv("DOCKER_BUILDKIT"); buildkitEnv != "" {
 4		var err error
 5		buildkitEnabled, err = strconv.ParseBool(buildkitEnv)
 6		if err != nil {
 7			return false, errors.Wrap(err, "DOCKER_BUILDKIT environment variable expects boolean value")
 8		}
 9	}
10	return buildkitEnabled, nil
11}

1{
2  "features": {
3    "buildkit": true
4  }
5}

 1(MoeLove) ➜  x ls
 2bar  Dockerfile  foo
 3(MoeLove) ➜  x cat Dockerfile | DOCKER_BUILDKIT=0 docker build -f - .
 4Sending build context to Docker daemon  15.41kB
 5Step 1/3 : FROM scratch
 6 ---> 
 7Step 2/3 : COPY foo foo
 8 ---> a2af45d66bb5
 9Step 3/3 : COPY bar bar
10 ---> cc803c675dd2
11Successfully built cc803c675dd2

 1(MoeLove) ➜  x tar -cvf x.tar foo bar Dockerfile 
 2foo                                                     
 3bar                         
 4Dockerfile
 5(MoeLove) ➜  x cat x.tar| DOCKER_BUILDKIT=0 docker build -f Dockerfile -
 6Sending build context to Docker daemon  10.24kB
 7Step 1/3 : FROM scratch
 8 ---> 
 9Step 2/3 : COPY foo foo
10 ---> 09319712e220
11Step 3/3 : COPY bar bar
12 ---> ce88644a7395
13Successfully built ce88644a7395

1(MoeLove) ➜  x DOCKER_BUILDKIT=0 docker build -f - -             
2invalid argument: can't use stdin for both build context and dockerfile

 1switch {
 2case options.contextFromStdin():
 3    
 4case isLocalDir(specifiedContext):
 5    
 6case urlutil.IsGitURL(specifiedContext):
 7    
 8case urlutil.IsURL(specifiedContext):
 9    
10default:
11    return errors.Errorf("unable to prepare context: path %q not found", specifiedContext)
12}

 1func ReadDockerignore(contextDir string) ([]string, error) {
 2	var excludes []string
 3
 4	f, err := os.Open(filepath.Join(contextDir, ".dockerignore"))
 5	switch {
 6	case os.IsNotExist(err):
 7		return excludes, nil
 8	case err != nil:
 9		return nil, err
10	}
11	defer f.Close()
12
13	return dockerignore.ReadAll(f)
14}

1response, err := dockerCli.Client().ImageBuild(ctx, body, buildOptions)
2if err != nil {
3    if options.quiet {
4        fmt.Fprintf(dockerCli.Err(), "%s", progBuff)
5    }
6    cancel()
7    return err
8}
9defer response.Body.Close()

 1func runBuild(dockerCli command.Cli, options buildOptions) error {
 2	buildkitEnabled, err := command.BuildKitEnabled(dockerCli.ServerInfo())
 3	if err != nil {
 4		return err
 5	}
 6	if buildkitEnabled {
 7		return runBuildBuildKit(dockerCli, options)
 8	}
 9    
10}

1s, err := trySession(dockerCli, options.context, false)
2if err != nil {
3    return err
4}
5if s == nil {
6    return errors.Errorf("buildkit not supported by daemon")
7}

 1func trySession(dockerCli command.Cli, contextDir string, forStream bool) (*session.Session, error) {
 2	if !isSessionSupported(dockerCli, forStream) {
 3		return nil, nil
 4	}
 5	sharedKey := getBuildSharedKey(contextDir)
 6	s, err := session.NewSession(context.Background(), filepath.Base(contextDir), sharedKey)
 7	if err != nil {
 8		return nil, errors.Wrap(err, "failed to create session")
 9	}
10	return s, nil
11}

1func isSessionSupported(dockerCli command.Cli, forStream bool) bool {
2	if !forStream && versions.GreaterThanOrEqualTo(dockerCli.Client().ClientVersion(), "1.39") {
3		return true
4	}
5	return dockerCli.ServerInfo().HasExperimental && versions.GreaterThanOrEqualTo(dockerCli.Client().ClientVersion(), "1.31")
6}

 1func NewSession(ctx context.Context, name, sharedKey string) (*Session, error) {
 2	id := identity.NewID()
 3
 4	var unary []grpc.UnaryServerInterceptor
 5	var stream []grpc.StreamServerInterceptor
 6
 7	serverOpts := []grpc.ServerOption{}
 8	if span := opentracing.SpanFromContext(ctx); span != nil {
 9		tracer := span.Tracer()
10		unary = append(unary, otgrpc.OpenTracingServerInterceptor(tracer, traceFilter()))
11		stream = append(stream, otgrpc.OpenTracingStreamServerInterceptor(span.Tracer(), traceFilter()))
12	}
13
14	unary = append(unary, grpcerrors.UnaryServerInterceptor)
15	stream = append(stream, grpcerrors.StreamServerInterceptor)
16
17	if len(unary) == 1 {
18		serverOpts = append(serverOpts, grpc.UnaryInterceptor(unary[0]))
19	} else if len(unary) > 1 {
20		serverOpts = append(serverOpts, grpc.UnaryInterceptor(grpc_middleware.ChainUnaryServer(unary...)))
21	}
22
23	if len(stream) == 1 {
24		serverOpts = append(serverOpts, grpc.StreamInterceptor(stream[0]))
25	} else if len(stream) > 1 {
26		serverOpts = append(serverOpts, grpc.StreamInterceptor(grpc_middleware.ChainStreamServer(stream...)))
27	}
28
29	s := &Session{
30		id:         id,
31		name:       name,
32		sharedKey:  sharedKey,
33		grpcServer: grpc.NewServer(serverOpts...),
34	}
35
36	grpc_health_v1.RegisterHealthServer(s.grpcServer, health.NewServer())
37
38	return s, nil
39}

 1switch {
 2case options.contextFromStdin():
 3    
 4case isLocalDir(options.context):
 5    
 6case urlutil.IsGitURL(options.context):
 7    
 8case urlutil.IsURL(options.context):
 9    
10default:
11    return errors.Errorf("unable to prepare context: path %q not found", options.context)
12}

 1outputs, err := parseOutputs(options.outputs)
 2if err != nil {
 3    return errors.Wrapf(err, "failed to parse outputs")
 4}
 5
 6for _, out := range outputs {
 7    switch out.Type {
 8    case "local":
 9        
10    case "tar":
11        
12    }
13}

1dockerAuthProvider := authprovider.NewDockerAuthProvider(os.Stderr)
2s.Allow(dockerAuthProvider)

1func (s *Session) Allow(a Attachable) {
2	a.Register(s.grpcServer)
3}

 1func parseSecretSpecs(sl []string) (session.Attachable, error) {
 2	fs := make([]secretsprovider.Source, 0, len(sl))
 3	for _, v := range sl {
 4		s, err := parseSecret(v)
 5		if err != nil {
 6			return nil, err
 7		}
 8		fs = append(fs, *s)
 9	}
10	store, err := secretsprovider.NewStore(fs)
11	if err != nil {
12		return nil, err
13	}
14	return secretsprovider.NewSecretProvider(store), nil
15}

1func parseSSHSpecs(sl []string) (session.Attachable, error) {
2	configs := make([]sshprovider.AgentConfig, 0, len(sl))
3	for _, v := range sl {
4		c := parseSSH(v)
5		configs = append(configs, *c)
6	}
7	return sshprovider.NewSSHAgentProvider(configs)
8}

 1buildID := stringid.GenerateRandomID()
 2if body != nil {
 3    eg.Go(func() error {
 4        buildOptions := types.ImageBuildOptions{
 5            Version: types.BuilderBuildKit,
 6            BuildID: uploadRequestRemote + ":" + buildID,
 7        }
 8
 9        response, err := dockerCli.Client().ImageBuild(context.Background(), body, buildOptions)
10        if err != nil {
11            return err
12        }
13        defer response.Body.Close()
14        return nil
15    })
16}

 1eg.Go(func() error {
 2    defer func() {
 3        s.Close()
 4    }()
 5
 6    buildOptions := imageBuildOptions(dockerCli, options)
 7    buildOptions.Version = types.BuilderBuildKit
 8    buildOptions.Dockerfile = dockerfileName
 9    buildOptions.RemoteContext = remote
10    buildOptions.SessionID = s.ID()
11    buildOptions.BuildID = buildID
12    buildOptions.Outputs = outputs
13    return doBuild(ctx, eg, dockerCli, stdoutUsed, options, buildOptions)
14})

1func doBuild(ctx context.Context, eg *errgroup.Group, dockerCli command.Cli, stdoutUsed bool, options buildOptions, buildOptions types.ImageBuildOptions, at session.Attachable) (finalErr error) {
2	response, err := dockerCli.Client().ImageBuild(context.Background(), nil, buildOptions)
3	if err != nil {
4		return err
5	}
6	defer response.Body.Close()
7    
8}

 1func (cli *Client) ImageBuild(ctx context.Context, buildContext io.Reader, options types.ImageBuildOptions) (types.ImageBuildResponse, error) {
 2	query, err := cli.imageBuildOptionsToQuery(options)
 3	if err != nil {
 4		return types.ImageBuildResponse{}, err
 5	}
 6
 7	headers := http.Header(make(map[string][]string))
 8	buf, err := json.Marshal(options.AuthConfigs)
 9	if err != nil {
10		return types.ImageBuildResponse{}, err
11	}
12	headers.Add("X-Registry-Config", base64.URLEncoding.EncodeToString(buf))
13
14	headers.Set("Content-Type", "application/x-tar")
15
16	serverResp, err := cli.postRaw(ctx, "/build", query, buildContext, headers)
17	if err != nil {
18		return types.ImageBuildResponse{}, err
19	}
20
21	osType := getDockerOS(serverResp.header.Get("Server"))
22
23	return types.ImageBuildResponse{
24		Body:   serverResp.body,
25		OSType: osType,
26	}, nil
27}

1func (r *buildRouter) initRoutes() {
2	r.routes = []router.Route{
3		router.NewPostRoute("/build", r.postBuild),
4		router.NewPostRoute("/build/prune", r.postPrune),
5		router.NewPostRoute("/build/cancel", r.postCancel),
6	}
7}

1buildOptions, err := newImageBuildOptions(ctx, r)
2if err != nil {
3    return errf(err)
4}

1buildOptions.AuthConfigs = getAuthConfigs(r.Header)

1imgID, err := br.backend.Build(ctx, backend.BuildConfig{
2    Source:         body,
3    Options:        buildOptions,
4    ProgressWriter: buildProgressWriter(out, wantAux, createProgressReader),
5})
6if err != nil {
7    return errf(err)
8}

 1func (b *Backend) Build(ctx context.Context, config backend.BuildConfig) (string, error) {
 2	options := config.Options
 3	useBuildKit := options.Version == types.BuilderBuildKit
 4
 5	tagger, err := NewTagger(b.imageComponent, config.ProgressWriter.StdoutFormatter, options.Tags)
 6	if err != nil {
 7		return "", err
 8	}
 9
10	var build *builder.Result
11	if useBuildKit {
12		build, err = b.buildkit.Build(ctx, config)
13		if err != nil {
14			return "", err
15		}
16	} else {
17		build, err = b.builder.Build(ctx, config)
18		if err != nil {
19			return "", err
20		}
21	}
22
23	if build == nil {
24		return "", nil
25	}
26
27	var imageID = build.ImageID
28	if options.Squash {
29		if imageID, err = squashBuild(build, b.imageComponent); err != nil {
30			return "", err
31		}
32		if config.ProgressWriter.AuxFormatter != nil {
33			if err = config.ProgressWriter.AuxFormatter.Emit("moby.image.id", types.BuildResult{ID: imageID}); err != nil {
34				return "", err
35			}
36		}
37	}
38
39	if !useBuildKit {
40		stdout := config.ProgressWriter.StdoutFormatter
41		fmt.Fprintf(stdout, "Successfully built %s\n", stringid.TruncateID(imageID))
42	}
43	if imageID != "" {
44		err = tagger.TagImages(image.ID(imageID))
45	}
46	return imageID, err
47}

 1useBuildKit := options.Version == types.BuilderBuildKit
 2
 3var build *builder.Result
 4if useBuildKit {
 5    build, err = b.buildkit.Build(ctx, config)
 6    if err != nil {
 7        return "", err
 8    }
 9} else {
10    build, err = b.builder.Build(ctx, config)
11    if err != nil {
12        return "", err
13    }
14}