Implement Kaniko for Fargate builds.

It will work alongside Docker, which remains the default for EC2 builds, while Kaniko will be used for Fargate

Author: Twsouza

cmd/build/main.go

@@ -63,7 +63,7 @@ func execute() error {
 	fs.StringVar(&flagGeneration, "generation", "", "app generation")
 	fs.StringVar(&flagID, "id", "latest", "build id")
 	fs.StringVar(&flagManifest, "manifest", "", "path to app manifest")
-	fs.StringVar(&flagMethod, "method", "", "source method")
+	fs.StringVar(&flagMethod, "method", "tgz", "source method")
 	fs.StringVar(&flagPush, "push", "", "push to registry")
 	fs.StringVar(&flagRack, "rack", "convox", "rack name")
 	fs.StringVar(&flagUrl, "url", "", "source url")
@@ -100,6 +100,10 @@ func execute() error {
 		flagManifest = v
 	}
 
+	if v := os.Getenv("BUILD_ENGINE"); v != "" {
+		flagMethod = v
+	}
+
 	if v := os.Getenv("BUILD_PUSH"); v != "" {
 		flagPush = v
 	}
@@ -122,6 +126,7 @@ func execute() error {
 		Generation:  flagGeneration,
 		Id:          flagID,
 		Manifest:    flagManifest,
+		Method:      flagMethod,
 		Push:        flagPush,
 		Rack:        flagRack,
 		Source:      flagUrl,

pkg/build/build.go

@@ -1,6 +1,7 @@
 package build
 
 import (
+	"bufio"
 	"bytes"
 	"compress/gzip"
 	"encoding/json"
@@ -32,6 +33,7 @@ type Options struct {
 	Generation  string
 	Id          string
 	Manifest    string
+	Method      string
 	Output      io.Writer
 	Push        string
 	Rack        string
@@ -60,6 +62,11 @@ func New(opts Options) (*Build, error) {
 		}
 	}
 
+	// Default to tgz method if not specified
+	if b.Method == "" {
+		b.Method = "tgz"
+	}
+
 	r, err := sdk.NewFromEnv()
 	if err != nil {
 		return nil, err
@@ -164,6 +171,7 @@ func (bb *Build) execute() error {
 	return nil
 }
 
+// login handles authentication for both Docker and Kaniko builds
 func (bb *Build) login() error {
 	var auth map[string]struct {
 		Username string
@@ -174,19 +182,13 @@ func (bb *Build) login() error {
 		return err
 	}
 
-	for host, entry := range auth {
-		buf := &bytes.Buffer{}
-
-		err := bb.Exec.Stream(buf, strings.NewReader(entry.Password), "docker", "login", "-u", entry.Username, "--password-stdin", host)
-
-		bb.Printf("Authenticating %s: %s\n", host, strings.TrimSpace(buf.String()))
-
-		if err != nil {
-			return err
-		}
+	// For Kaniko, write Docker config.json instead of using docker login
+	if bb.Method == "kaniko" {
+		return loginForKaniko(auth)
 	}
 
-	return nil
+	// Standard Docker login for non-Kaniko builds
+	return loginForDocker(bb, auth)
 }
 
 func (bb *Build) buildGeneration1(dir string) error {
@@ -421,3 +423,57 @@ func (bb *Build) fail(buildError error) error {
 
 	return buildError
 }
+
+// build calls the appropriate builder based on the method
+func (bb *Build) build(path, dockerfile string, tag string, env map[string]string) error {
+	if path == "" {
+		return fmt.Errorf("must have path to build")
+	}
+
+	df := filepath.Join(path, dockerfile)
+
+	// Choose build implementation based on method
+	switch bb.Method {
+	case "kaniko":
+		return bb.buildWithKaniko(path, df, tag, env)
+	default:
+		return bb.buildWithDocker(path, df, tag, env)
+	}
+}
+
+// Common function for extracting build args from Dockerfile
+func (bb *Build) buildArgs(dockerfile string, env map[string]string) ([]string, error) {
+	fd, err := os.Open(dockerfile)
+	if err != nil {
+		return nil, err
+	}
+	defer fd.Close()
+
+	s := bufio.NewScanner(fd)
+
+	args := []string{}
+
+	for s.Scan() {
+		fields := strings.Fields(strings.TrimSpace(s.Text()))
+
+		if len(fields) < 2 {
+			continue
+		}
+
+		parts := strings.Split(fields[1], "=")
+
+		switch fields[0] {
+		case "FROM":
+			if bb.Development && strings.Contains(strings.ToLower(s.Text()), "as development") {
+				args = append(args, "--target", "development")
+			}
+		case "ARG":
+			k := strings.TrimSpace(parts[0])
+			if v, ok := env[k]; ok {
+				args = append(args, "--build-arg", fmt.Sprintf("%s=%s", k, v))
+			}
+		}
+	}
+
+	return args, nil
+}

pkg/build/docker.go

@@ -1,7 +1,6 @@
 package build
 
 import (
-	"bufio"
 	"encoding/json"
 	"errors"
 	"fmt"
@@ -14,24 +13,39 @@ import (
 	shellquote "github.com/kballard/go-shellquote"
 )
 
-func (bb *Build) build(path, dockerfile string, tag string, env map[string]string) error {
-	if path == "" {
-		return fmt.Errorf("must have path to build")
+// loginForDocker performs Docker registry login using docker CLI
+func loginForDocker(bb *Build, auth map[string]struct {
+	Username string
+	Password string
+}) error {
+	for host, entry := range auth {
+		buf := &strings.Builder{}
+
+		err := bb.Exec.Stream(buf, strings.NewReader(entry.Password), "docker", "login", "-u", entry.Username, "--password-stdin", host)
+
+		bb.Printf("Authenticating %s: %s\n", host, strings.TrimSpace(buf.String()))
+
+		if err != nil {
+			return err
+		}
 	}
 
-	df := filepath.Join(path, dockerfile)
+	return nil
+}
 
+// buildWithDocker builds a Docker image using the Docker CLI
+func (bb *Build) buildWithDocker(path, dockerfile string, tag string, env map[string]string) error {
 	args := []string{"build"}
 
 	if !bb.Cache {
 		args = append(args, "--no-cache")
 	}
 
 	args = append(args, "-t", tag)
-	args = append(args, "-f", df)
+	args = append(args, "-f", dockerfile)
 	args = append(args, "--network", "host")
 
-	ba, err := bb.buildArgs(df, env)
+	ba, err := bb.buildArgs(dockerfile, env)
 	if err != nil {
 		return err
 	}
@@ -68,43 +82,60 @@ func (bb *Build) build(path, dockerfile string, tag string, env map[string]strin
 	return nil
 }
 
-func (bb *Build) buildArgs(dockerfile string, env map[string]string) ([]string, error) {
-	fd, err := os.Open(dockerfile)
+// pull retrieves an image from a Docker registry
+func (bb *Build) pull(image string) error {
+	if bb.Method == "kaniko" {
+		return bb.pullWithKaniko(image)
+	}
+
+	fmt.Fprintf(bb.writer, "Running: docker pull %s\n", image)
+
+	data, err := bb.Exec.Execute("docker", "pull", image)
 	if err != nil {
-		return nil, err
+		return errors.New(strings.TrimSpace(string(data)))
+	}
+
+	return nil
+}
+
+// push sends an image to a Docker registry
+func (bb *Build) push(tag string) error {
+	if bb.Method == "kaniko" {
+		return bb.pushWithKaniko(tag)
 	}
-	defer fd.Close()
 
-	s := bufio.NewScanner(fd)
+	fmt.Fprintf(bb.writer, "Running: docker push %s\n", tag)
 
-	args := []string{}
+	data, err := bb.Exec.Execute("docker", "push", tag)
+	if err != nil {
+		return errors.New(strings.TrimSpace(string(data)))
+	}
 
-	for s.Scan() {
-		fields := strings.Fields(strings.TrimSpace(s.Text()))
+	return nil
+}
 
-		if len(fields) < 2 {
-			continue
-		}
+// tag adds a tag to an existing Docker image
+func (bb *Build) tag(from, to string) error {
+	if bb.Method == "kaniko" {
+		return bb.tagWithKaniko(from, to)
+	}
 
-		parts := strings.Split(fields[1], "=")
-
-		switch fields[0] {
-		case "FROM":
-			if bb.Development && strings.Contains(strings.ToLower(s.Text()), "as development") {
-				args = append(args, "--target", "development")
-			}
-		case "ARG":
-			k := strings.TrimSpace(parts[0])
-			if v, ok := env[k]; ok {
-				args = append(args, "--build-arg", fmt.Sprintf("%s=%s", k, v))
-			}
-		}
+	fmt.Fprintf(bb.writer, "Running: docker tag %s %s\n", from, to)
+
+	data, err := bb.Exec.Execute("docker", "tag", from, to)
+	if err != nil {
+		return errors.New(strings.TrimSpace(string(data)))
 	}
 
-	return args, nil
+	return nil
 }
 
+// injectConvoxEnv adds the convox-env executable to a Docker image
 func (bb *Build) injectConvoxEnv(tag string) error {
+	if bb.Method == "kaniko" {
+		return bb.injectConvoxEnvWithKaniko(tag)
+	}
+
 	fmt.Fprintf(bb.writer, "Injecting: convox-env\n")
 
 	var cmd []string
@@ -157,43 +188,10 @@ func (bb *Build) injectConvoxEnv(tag string) error {
 		return err
 	}
 
-	data, err = bb.Exec.Execute("docker", "build", "-t", tag, tmp)
+	_, err = bb.Exec.Execute("docker", "build", "-t", tag, tmp)
 	if err != nil {
 		return err
 	}
 
 	return nil
 }
-
-func (bb *Build) pull(tag string) error {
-	fmt.Fprintf(bb.writer, "Running: docker pull %s\n", tag)
-
-	data, err := bb.Exec.Execute("docker", "pull", tag)
-	if err != nil {
-		return errors.New(strings.TrimSpace(string(data)))
-	}
-
-	return nil
-}
-
-func (bb *Build) push(tag string) error {
-	fmt.Fprintf(bb.writer, "Running: docker push %s\n", tag)
-
-	data, err := bb.Exec.Execute("docker", "push", tag)
-	if err != nil {
-		return errors.New(strings.TrimSpace(string(data)))
-	}
-
-	return nil
-}
-
-func (bb *Build) tag(from, to string) error {
-	fmt.Fprintf(bb.writer, "Running: docker tag %s %s\n", from, to)
-
-	data, err := bb.Exec.Execute("docker", "tag", from, to)
-	if err != nil {
-		return errors.New(strings.TrimSpace(string(data)))
-	}
-
-	return nil
-}