root: add --registry-mirror flag

README.md

@@ -59,6 +59,7 @@ _If you are interested in contributing to kaniko, see [DEVELOPMENT.md](DEVELOPME
     - [--insecure](#--insecure)
     - [--insecure-pull](#--insecure-pull)
     - [--no-push](#--no-push)
+    - [--registry-mirror](#--registry-mirror)
     - [--reproducible](#--reproducible)
     - [--single-snapshot](#--single-snapshot)
     - [--skip-tls-verify](#--skip-tls-verify)
@@ -478,6 +479,10 @@ Set this flag if you want to pull images from a plain HTTP registry. It is suppo
 
 Set this flag if you only want to build the image, without pushing to a registry.
 
+#### --registry-mirror
+
+Set this flag if you want to use a registry mirror instead of default `index.docker.io`.
+
 #### --reproducible
 
 Set this flag to strip timestamps out of the built image and make it reproducible.

cmd/executor/cmd/root.go

@@ -146,6 +146,7 @@ func addKanikoOptionsFlags() {
 	RootCmd.PersistentFlags().DurationVarP(&opts.CacheTTL, "cache-ttl", "", time.Hour*336, "Cache timeout in hours. Defaults to two weeks.")
 	RootCmd.PersistentFlags().VarP(&opts.InsecureRegistries, "insecure-registry", "", "Insecure registry using plain HTTP to push and pull. Set it repeatedly for multiple registries.")
 	RootCmd.PersistentFlags().VarP(&opts.SkipTLSVerifyRegistries, "skip-tls-verify-registry", "", "Insecure registry ignoring TLS verify to push and pull. Set it repeatedly for multiple registries.")
+	RootCmd.PersistentFlags().StringVarP(&opts.RegistryMirror, "registry-mirror", "", "", "Registry mirror to use has pull-through cache instead of docker.io.")
 	RootCmd.PersistentFlags().BoolVarP(&opts.WhitelistVarRun, "whitelist-var-run", "", true, "Ignore /var/run directory when taking image snapshot. Set it to false to preserve /var/run/ in destination image. (Default true).")
 }
 

integration/dockerfiles/Dockerfile_registry_mirror

@@ -0,0 +1,20 @@
+# Copyright 2018 Google, Inc. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Test to make sure the executor builds an image correctly
+# when no files are changed
+
+FROM google-appengine/debian9@sha256:1d6a9a6d106bd795098f60f4abb7083626354fa6735e81743c7f8cfca11259f0
+RUN echo "hey" 
+MAINTAINER kaniko

integration/integration_test.go

@@ -260,6 +260,50 @@ func TestGitBuildcontext(t *testing.T) {
 	checkContainerDiffOutput(t, diff, expected)
 }
 
+func TestBuildViaRegistryMirror(t *testing.T) {
+	repo := getGitRepo()
+	dockerfile := "integration/dockerfiles/Dockerfile_registry_mirror"
+
+	// Build with docker
+	dockerImage := GetDockerImage(config.imageRepo, "Dockerfile_registry_mirror")
+	dockerCmd := exec.Command("docker",
+		append([]string{"build",
+			"-t", dockerImage,
+			"-f", dockerfile,
+			repo})...)
+	out, err := RunCommandWithoutTest(dockerCmd)
+	if err != nil {
+		t.Errorf("Failed to build image %s with docker command \"%s\": %s %s", dockerImage, dockerCmd.Args, err, string(out))
+	}
+
+	// Build with kaniko
+	kanikoImage := GetKanikoImage(config.imageRepo, "Dockerfile_registry_mirror")
+	dockerRunFlags := []string{"run", "--net=host"}
+	dockerRunFlags = addServiceAccountFlags(dockerRunFlags, config.serviceAccount)
+	dockerRunFlags = append(dockerRunFlags, ExecutorImage,
+		"-f", dockerfile,
+		"-d", kanikoImage,
+		"-c", fmt.Sprintf("git://%s", repo))
+
+	kanikoCmd := exec.Command("docker", dockerRunFlags...)
+
+	out, err = RunCommandWithoutTest(kanikoCmd)
+	if err != nil {
+		t.Errorf("Failed to build image %s with kaniko command \"%s\": %v %s", dockerImage, kanikoCmd.Args, err, string(out))
+	}
+
+	// container-diff
+	daemonDockerImage := daemonPrefix + dockerImage
+	containerdiffCmd := exec.Command("container-diff", "diff", "--no-cache",
+		daemonDockerImage, kanikoImage,
+		"-q", "--type=file", "--type=metadata", "--json")
+	diff := RunCommand(containerdiffCmd, t)
+	t.Logf("diff = %s", string(diff))
+
+	expected := fmt.Sprintf(emptyContainerDiff, dockerImage, kanikoImage, dockerImage, kanikoImage)
+	checkContainerDiffOutput(t, diff, expected)
+}
+
 func TestLayers(t *testing.T) {
 	offset := map[string]int{
 		"Dockerfile_test_add":     12,

pkg/config/options.go

@@ -39,10 +39,11 @@ type KanikoOptions struct {
 	DigestFile              string
 	ImageNameDigestFile     string
 	OCILayoutPath           string
-	Destinations            multiArg
-	BuildArgs               multiArg
+	RegistryMirror          string
 	InsecureRegistries      multiArg
 	SkipTLSVerifyRegistries multiArg
+	Destinations            multiArg
+	BuildArgs               multiArg
 	Insecure                bool
 	SkipTLSVerify           bool
 	InsecurePull            bool

pkg/util/image_util.go

@@ -107,11 +107,25 @@ func remoteImage(image string, opts *config.KanikoOptions) (v1.Image, error) {
 	}
 
 	registryName := ref.Context().RegistryStr()
+	var newReg name.Registry
+
+	if opts.RegistryMirror != "" && registryName == name.DefaultRegistry {
+		registryName = opts.RegistryMirror
+
+		newReg, err = name.NewRegistry(opts.RegistryMirror, name.StrictValidation)
+		if err != nil {
+			return nil, err
+		}
+	}
+
 	if opts.InsecurePull || opts.InsecureRegistries.Contains(registryName) {
-		newReg, err := name.NewRegistry(registryName, name.WeakValidation, name.Insecure)
+		newReg, err = name.NewRegistry(registryName, name.WeakValidation, name.Insecure)
 		if err != nil {
 			return nil, err
 		}
+	}
+
+	if newReg != ref.Context().Registry {
 		if tag, ok := ref.(name.Tag); ok {
 			tag.Repository.Registry = newReg
 			ref = tag

pkg/util/image_util_test.go

@@ -60,6 +60,7 @@ func Test_StandardImage(t *testing.T) {
 	}, &config.KanikoOptions{})
 	testutil.CheckErrorAndDeepEqual(t, false, err, nil, actual)
 }
+
 func Test_ScratchImage(t *testing.T) {
 	stages, err := parse(dockerfile)
 	if err != nil {
@@ -93,6 +94,20 @@ func Test_TarImage(t *testing.T) {
 	testutil.CheckErrorAndDeepEqual(t, false, err, nil, actual)
 }
 
+func Test_ScratchImageFromMirror(t *testing.T) {
+	stages, err := parse(dockerfile)
+	if err != nil {
+		t.Error(err)
+	}
+	actual, err := RetrieveSourceImage(config.KanikoStage{
+		Stage: stages[1],
+	}, &config.KanikoOptions{
+		RegistryMirror: "mirror.gcr.io",
+	})
+	expected := empty.Image
+	testutil.CheckErrorAndDeepEqual(t, false, err, expected, actual)
+}
+
 // parse parses the contents of a Dockerfile and returns a list of commands
 func parse(s string) ([]instructions.Stage, error) {
 	p, err := parser.Parse(bytes.NewReader([]byte(s)))