Persistent volume caching for base images

cmd/executor/cmd/root.go

@@ -99,6 +99,7 @@ func addKanikoOptionsFlags(cmd *cobra.Command) {
 	RootCmd.PersistentFlags().StringVarP(&opts.Target, "target", "", "", "Set the target build stage to build")
 	RootCmd.PersistentFlags().BoolVarP(&opts.NoPush, "no-push", "", false, "Do not push the image to the registry")
 	RootCmd.PersistentFlags().StringVarP(&opts.CacheRepo, "cache-repo", "", "", "Specify a repository to use as a cache, otherwise one will be inferred from the destination provided")
+	RootCmd.PersistentFlags().StringVarP(&opts.CacheDir, "cache-dir", "", "/cache", "Specify a local directory to use as a cache.")
 	RootCmd.PersistentFlags().BoolVarP(&opts.Cache, "cache", "", false, "Use cache when building image")
 	RootCmd.PersistentFlags().BoolVarP(&opts.Cleanup, "cleanup", "", false, "Clean the filesystem at the end")
 }

kaniko-test.yaml

@@ -8,7 +8,9 @@ spec:
     image: gcr.io/kaniko-project/executor:latest
     args: ["--dockerfile=<dockerfile>",
             "--context=<context>",
-            "--destination=<destination>"]
+            "--destination=<destination>",
+            "--cache",
+            "--cache-dir=/cache"]
     volumeMounts:
       - name: kaniko-secret
         mountPath: /secret

kaniko-warmer.yaml

@@ -5,10 +5,9 @@ metadata:
 spec:
   containers:
   - name: kaniko-warmer
-    image: gcr.io/sharif-test/warmer@sha256:9bf8affcf6630a9b17298e54b79247a22516aebff0c88733f04e6e2974ca58c4
-    args: ["-c /cache",
-           "-i gcr.io/google-appengine/debian9",
-           "-vdebug"]
+    image: gcr.io/kaniko-project/warmer:latest
+    args: ["--cache-dir=/cache",
+           "--image=gcr.io/google-appengine/debian9"]
     volumeMounts:
       - name: kaniko-secret
         mountPath: /secret
@@ -21,7 +20,7 @@ spec:
   volumes:
     - name: kaniko-secret
       secret:
-        secretName: default-token-wtlnt
+        secretName: kaniko-secret
     - name: kaniko-cache
       persistentVolumeClaim:
               claimName: kaniko-cache-claim

pkg/cache/cache.go

@@ -33,10 +33,6 @@ import (
 
 // RetrieveLayer checks the specified cache for a layer with the tag :cacheKey
 func RetrieveLayer(opts *config.KanikoOptions, cacheKey string) (v1.Image, error) {
-	if local, _ := LocalDestination(opts, cacheKey); local != nil {
-		return local, nil
-	}
-
 	cache, err := Destination(opts, cacheKey)
 	if err != nil {
 		return nil, errors.Wrap(err, "getting cache destination")
@@ -75,21 +71,17 @@ func Destination(opts *config.KanikoOptions, cacheKey string) (string, error) {
 	return fmt.Sprintf("%s:%s", cache, cacheKey), nil
 }
 
-func LocalDestination(opts *config.KanikoOptions, cacheKey string) (v1.Image, error) {
+func LocalSource(opts *config.KanikoOptions, cacheKey string, source string) (v1.Image, error) {
 	cache := opts.CacheDir
 	if cache == "" {
 		return nil, nil
 	}
 
 	path := path.Join(cache, cacheKey)
-	destination := opts.Destinations[0]
-	destRef, err := name.NewTag(destination, name.WeakValidation)
-	if err != nil {
-		return nil, errors.Wrap(err, "volume cache: getting tag for destination")
-	}
-	tag, err := name.NewTag(fmt.Sprintf("%s/cache:%s", destRef.Context(), cacheKey), name.WeakValidation)
+
+	tag, err := name.NewTag(source, name.WeakValidation)
 	if err != nil {
-		return nil, errors.Wrap(err, "volume cache: create new cache tag")
+		return nil, errors.Wrap(err, "volume cache: creating new cache tag")
 	}
 	imgTar, err := tarball.ImageFromPath(path, &tag)
 	if err != nil {

pkg/cache/warm.go

@@ -38,30 +38,24 @@ func WarmCache(opts *config.WarmerOptions) error {
 	for _, image := range images {
 		cacheRef, err := name.NewTag(image, name.WeakValidation)
 		if err != nil {
-			logrus.Debugf("Failed to verify image name %v", err)
 			errors.Wrap(err, fmt.Sprintf("Failed to verify image name: %s", image))
 		}
 		k8sc, err := k8schain.NewNoClient()
 		if err != nil {
-			logrus.Debugf("Failed to create auth keychain: %v", err)
 			errors.Wrap(err, fmt.Sprintf("Failed to create auth keychain: %s", image))
 		}
 		img, err := remote.Image(cacheRef, remote.WithAuthFromKeychain(k8sc))
 		if err != nil {
-			logrus.Debugf("Failed to retrieve image: %v", err)
 			errors.Wrap(err, fmt.Sprintf("Failed to retrieve image: %s", image))
 		}
 
 		digest, err := img.Digest()
 		if err != nil {
-			logrus.Debugf("Failed to retrieve digest: %v", err)
 			errors.Wrap(err, fmt.Sprintf("Failed to retrieve digest: %s", image))
 		}
 		cachePath := path.Join(cacheDir, digest.String())
-		logrus.Debugf("CACHE PATH = %s\n", cachePath)
 		err = tarball.WriteToFile(cachePath, cacheRef, img)
 		if err != nil {
-			logrus.Debugf("Failed to write to cache %v", err)
 			errors.Wrap(err, fmt.Sprintf("Failed to write %s to cache", image))
 		} else {
 			logrus.Debugf("Wrote %s to cache", image)

pkg/util/image_util.go

@@ -17,7 +17,6 @@ limitations under the License.
 package util
 
 import (
-	"fmt"
 	"path/filepath"
 	"strconv"
 
@@ -106,7 +105,22 @@ func cachedImage(opts *config.KanikoOptions, image string) (v1.Image, error) {
 	if err != nil {
 		return nil, err
 	}
-	cacheKey := ref.Name()
-	fmt.Printf("CACHEKEY=%s", cacheKey)
-	return cache.LocalDestination(opts, cacheKey)
+
+	k8sc, err := k8schain.NewNoClient()
+	if err != nil {
+		return nil, err
+	}
+	kc := authn.NewMultiKeychain(authn.DefaultKeychain, k8sc)
+
+	img, err := remote.Image(ref, remote.WithAuthFromKeychain(kc))
+	if err != nil {
+		return nil, err
+	}
+
+	cacheKey, err := img.Digest()
+	if err != nil {
+		return nil, err
+	}
+
+	return cache.LocalSource(opts, cacheKey.String(), image)
 }

pkg/util/image_util_test.go

@@ -57,7 +57,7 @@ func Test_StandardImage(t *testing.T) {
 	retrieveRemoteImage = mock
 	actual, err := RetrieveSourceImage(config.KanikoStage{
 		Stage: stages[0],
-	}, nil)
+	}, nil, nil)
 	testutil.CheckErrorAndDeepEqual(t, false, err, nil, actual)
 }
 func Test_ScratchImage(t *testing.T) {
@@ -67,7 +67,7 @@ func Test_ScratchImage(t *testing.T) {
 	}
 	actual, err := RetrieveSourceImage(config.KanikoStage{
 		Stage: stages[1],
-	}, nil)
+	}, nil, nil)
 	expected := empty.Image
 	testutil.CheckErrorAndDeepEqual(t, false, err, expected, actual)
 }
@@ -89,7 +89,7 @@ func Test_TarImage(t *testing.T) {
 		BaseImageStoredLocally: true,
 		BaseImageIndex:         0,
 		Stage:                  stages[2],
-	}, nil)
+	}, nil, nil)
 	testutil.CheckErrorAndDeepEqual(t, false, err, nil, actual)
 }