Allow users to use multistage Docker builds based on Docker version

cmd/operator-sdk/build/cmd.go

@@ -21,6 +21,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"regexp"
 	"strings"
 
 	"github.com/operator-framework/operator-sdk/internal/pkg/scaffold"
@@ -39,6 +40,7 @@ var (
 	testLocationBuild  string
 	enableTests        bool
 	dockerBuildArgs    string
+	genMultistage      bool
 )
 
 func NewCmd() *cobra.Command {
@@ -60,6 +62,7 @@ For example:
 		RunE: buildFunc,
 	}
 	buildCmd.Flags().BoolVar(&enableTests, "enable-tests", false, "Enable in-cluster testing by adding test binary to the image")
+	buildCmd.Flags().BoolVar(&genMultistage, "gen-multistage", false, "Generate multistage build and test Dockerfiles")
 	buildCmd.Flags().StringVar(&testLocationBuild, "test-location", "./test/e2e", "Location of tests")
 	buildCmd.Flags().StringVar(&namespacedManBuild, "namespaced-manifest", "deploy/operator.yaml", "Path of namespaced resources manifest for tests")
 	buildCmd.Flags().StringVar(&dockerBuildArgs, "docker-build-args", "", "Extra docker build arguments as one string such as \"--build-arg https_proxy=$https_proxy\"")
@@ -145,78 +148,70 @@ func buildFunc(cmd *cobra.Command, args []string) error {
 	if len(args) != 1 {
 		return fmt.Errorf("command %s requires exactly one argument", cmd.CommandPath())
 	}
-
 	projutil.MustInProjectRoot()
-	goBuildEnv := append(os.Environ(), "GOOS=linux", "GOARCH=amd64", "CGO_ENABLED=0")
-	goTrimFlags := []string{"-gcflags", "all=-trimpath=${GOPATH}", "-asmflags", "all=-trimpath=${GOPATH}"}
-	absProjectPath := projutil.MustGetwd()
-	projectName := filepath.Base(absProjectPath)
-
-	// Don't need to build Go code if a non-Go Operator.
-	if projutil.GetOperatorType() == projutil.OperatorTypeGo {
-		managerDir := filepath.Join(projutil.CheckAndGetProjectGoPkg(), scaffold.ManagerDir)
-		outputBinName := filepath.Join(absProjectPath, scaffold.BuildBinDir, projectName)
-		goBuildArgs := append(append([]string{"build"}, goTrimFlags...), "-o", outputBinName, managerDir)
-		buildCmd := exec.Command("go", goBuildArgs...)
-		buildCmd.Env = goBuildEnv
-		if err := projutil.ExecCmd(buildCmd); err != nil {
-			return fmt.Errorf("failed to build operator binary: (%v)", err)
-		}
-	}
 
 	image := args[0]
 	baseImageName := image
 	if enableTests {
 		baseImageName += "-intermediate"
 	}
+	var dbArgs []string
+	if dockerBuildArgs != "" {
+		splitArgs := regexp.MustCompile("--build-arg(=)?").ReplaceAllString(dockerBuildArgs, "")
+		dbArgs = strings.Fields(splitArgs)
+	}
+	absProjectPath := projutil.MustGetwd()
+	projectName := filepath.Base(absProjectPath)
 
 	log.Infof("Building Docker image %s", baseImageName)
 
-	dbArgs := []string{"build", ".", "-f", "build/Dockerfile", "-t", baseImageName}
-
-	if dockerBuildArgs != "" {
-		splitArgs := strings.Fields(dockerBuildArgs)
-		dbArgs = append(dbArgs, splitArgs...)
+	// The runtime environment may have docker v17.05+, in which case the SDK
+	// can build the binary within a container in a multistage pipeline.
+	// Otherwise the binary will be built on the host and COPY'd into the
+	// resulting image.
+	buildDockerfile, err := makeDockerfileIfMultistage(filepath.Join(scaffold.BuildDir, scaffold.DockerfileFile))
+	if err != nil {
+		return err
 	}
-
-	dbcmd := exec.Command("docker", dbArgs...)
-	if err := projutil.ExecCmd(dbcmd); err != nil {
+	if projutil.IsOperatorGo() && !projutil.IsDockerfileMultistage(buildDockerfile) {
+		if err := buildOperatorBinary(); err != nil {
+			return fmt.Errorf("failed to build operator binary: (%v)", err)
+		}
+	}
+	err = projutil.DockerBuild(buildDockerfile, baseImageName, dbArgs...)
+	if err != nil {
 		if enableTests {
 			return fmt.Errorf("failed to output intermediate image %s: (%v)", image, err)
 		}
 		return fmt.Errorf("failed to output build image %s: (%v)", image, err)
 	}
 
 	if enableTests {
-		if projutil.GetOperatorType() == projutil.OperatorTypeGo {
-			testBinary := filepath.Join(absProjectPath, scaffold.BuildBinDir, projectName+"-test")
-			goTestBuildArgs := append(append([]string{"test"}, goTrimFlags...), "-c", "-o", testBinary, testLocationBuild+"/...")
-			buildTestCmd := exec.Command("go", goTestBuildArgs...)
-			buildTestCmd.Env = goBuildEnv
-			if err := projutil.ExecCmd(buildTestCmd); err != nil {
-				return fmt.Errorf("failed to build test binary: (%v)", err)
-			}
+		if !projutil.IsDockerMultistage() {
+			return fmt.Errorf("in-cluster tests are only available on hosts with Docker v17.05+")
 		}
 
-		// if a user is using an older sdk repo as their library, make sure they have required build files
+		// If a user is using an older sdk repo as their library, make sure they
+		// have the required build files.
 		testDockerfile := filepath.Join(scaffold.BuildTestDir, scaffold.DockerfileFile)
-		_, err := os.Stat(testDockerfile)
-		if err != nil && os.IsNotExist(err) {
+		_, err = os.Stat(testDockerfile)
+		if (err != nil && os.IsNotExist(err)) || !projutil.IsDockerfileMultistage(testDockerfile) {
 
 			log.Info("Generating build manifests for test-framework.")
 
 			cfg := &input.Config{
-				Repo:           projutil.CheckAndGetProjectGoPkg(),
 				AbsProjectPath: absProjectPath,
 				ProjectName:    projectName,
 			}
 
 			s := &scaffold.Scaffold{}
-			t := projutil.GetOperatorType()
-			switch t {
+			switch t := projutil.GetOperatorType(); t {
 			case projutil.OperatorTypeGo:
+				cfg.Repo = projutil.CheckAndGetProjectGoPkg()
 				err = s.Execute(cfg,
-					&scaffold.TestFrameworkDockerfile{},
+					&scaffold.TestFrameworkDockerfile{
+						Input: input.Input{IfExistsAction: input.Overwrite},
+					},
 					&scaffold.GoTestScript{},
 					&scaffold.TestPod{Image: image, TestNamespaceEnv: test.TestNamespaceEnv},
 				)
@@ -235,15 +230,14 @@ func buildFunc(cmd *cobra.Command, args []string) error {
 
 		log.Infof("Building test Docker image %s", image)
 
-		testDbArgs := []string{"build", ".", "-f", testDockerfile, "-t", image, "--build-arg", "NAMESPACEDMAN=" + namespacedManBuild, "--build-arg", "BASEIMAGE=" + baseImageName}
-
-		if dockerBuildArgs != "" {
-			splitArgs := strings.Fields(dockerBuildArgs)
-			testDbArgs = append(testDbArgs, splitArgs...)
-		}
-
-		testDbcmd := exec.Command("docker", testDbArgs...)
-		if err := projutil.ExecCmd(testDbcmd); err != nil {
+		// Tests require docker v17.05+ anyway so we don't need to conditionally
+		// scaffold a multistage Dockerfile.
+		err = projutil.DockerBuild(testDockerfile, image,
+			append(dbArgs,
+				"TESTDIR="+testLocationBuild,
+				"BASEIMAGE="+baseImageName,
+				"NAMESPACEDMAN="+namespacedManBuild)...)
+		if err != nil {
 			return fmt.Errorf("failed to output test image %s: (%v)", image, err)
 		}
 		// Check image name of deployments in namespaced manifest
@@ -255,3 +249,68 @@ func buildFunc(cmd *cobra.Command, args []string) error {
 	log.Info("Operator build complete.")
 	return nil
 }
+
+// makeDockerfileIfMultistage is effectively a function for migrating
+// single-stage to multistage Dockerfiles. makeDockerfileIfMultistage scaffolds
+// a multistage Dockerfile for Go operators on hosts with docker v17.05+ if a
+// multistage Dockerfile is not already present at path dockerfile. The newly
+// scaffolded file is named 'multistage.Dockerfile', which users are expected
+// to rename to 'Dockerfile'. Users will see a warning if docker v17.05+ is
+// present but they haven't set the --gen-multistage flag in
+// `operator-sdk build...`
+func makeDockerfileIfMultistage(dockerfile string) (string, error) {
+	if !projutil.IsOperatorGo() || !projutil.IsDockerMultistage() {
+		return dockerfile, nil
+	}
+
+	if !projutil.IsDockerfileMultistage(dockerfile) {
+		msDockerfile := "multistage." + scaffold.DockerfileFile
+		if !genMultistage {
+			log.Warnf(`Project uses a non-multistage Dockerfile but the present docker version
+supports multistage builds. Run operator-sdk build with --gen-multistage to write
+a multistage Dockerfile to '%s' and build it. Rename this
+file to '%s' to avoid this warning.`,
+				filepath.Join(scaffold.BuildDir, msDockerfile),
+				dockerfile)
+
+		} else {
+			absProjectPath := projutil.MustGetwd()
+			cfg := &input.Config{
+				AbsProjectPath: absProjectPath,
+				ProjectName:    filepath.Base(absProjectPath),
+				Repo:           projutil.CheckAndGetProjectGoPkg(),
+			}
+
+			dockerfile = filepath.Join(scaffold.BuildDir, msDockerfile)
+			d := &scaffold.Dockerfile{
+				Multistage: true,
+				Input: input.Input{
+					Path:           dockerfile,
+					IfExistsAction: input.Overwrite,
+				},
+			}
+			err := (&scaffold.Scaffold{}).Execute(cfg, d)
+			if err != nil {
+				return "", fmt.Errorf("failed to write %s: (%v)", msDockerfile, err)
+			}
+		}
+	}
+
+	return dockerfile, nil
+}
+
+// buildOperatorBinary builds the operator binary locally.
+func buildOperatorBinary() error {
+	absProjectPath := projutil.MustGetwd()
+	binName := filepath.Base(absProjectPath)
+	goFlags := []string{"build",
+		"-gcflags", "all=-trimpath=${GOPATH}",
+		"-asmflags", "all=-trimpath=${GOPATH}",
+		"-o", filepath.Join(absProjectPath, scaffold.BuildBinDir, binName),
+		filepath.Join(projutil.CheckAndGetProjectGoPkg(), scaffold.ManagerDir),
+	}
+
+	cmd := exec.Command("go", goFlags...)
+	cmd.Env = append(os.Environ(), "GOOS=linux", "GOARCH=amd64", "CGO_ENABLED=0")
+	return projutil.ExecCmd(cmd)
+}

cmd/operator-sdk/new/cmd.go

@@ -155,7 +155,7 @@ func doScaffold() error {
 	s := &scaffold.Scaffold{}
 	err := s.Execute(cfg,
 		&scaffold.Cmd{},
-		&scaffold.Dockerfile{},
+		&scaffold.Dockerfile{Multistage: projutil.IsDockerMultistage()},
 		&scaffold.Entrypoint{},
 		&scaffold.UserSetup{},
 		&scaffold.ServiceAccount{},