feat: shrink flatcar customdata size (#7755)

Author: Jeremi Piotrowski

parts/linux/cloud-init/flatcar.yml

@@ -18,3 +18,23 @@ systemd:
 
         [Install]
         WantedBy=sysinit.target
+
+    - name: ignition-file-extract.service
+      enabled: true
+      contents: |
+        [Unit]
+        Description=Extract Ignition file payload
+        DefaultDependencies=no
+        After=local-fs.target
+        Before=sysinit.target ignition-bootcmds.service
+        ConditionPathExists=/var/lib/ignition/ignition-files.tar
+
+        [Service]
+        Type=oneshot
+        ExecStart=tar -xvf /var/lib/ignition/ignition-files.tar -C /
+        ExecStart=rm -f /var/lib/ignition/ignition-files.tar
+        ExecStart=systemctl daemon-reload
+        RemainAfterExit=yes
+
+        [Install]
+        WantedBy=sysinit.target

pkg/agent/baker.go

@@ -4,6 +4,7 @@
 package agent
 
 import (
+	"archive/tar"
 	"archive/zip"
 	"bytes"
 	"encoding/base64"
@@ -79,36 +80,101 @@ func (t *TemplateGenerator) getLinuxNodeCustomDataJSONObject(config *datamodel.N
 	return fmt.Sprintf("{\"customData\": \"%s\"}", str)
 }
 
-func toButaneFile(file cloudInitWriteFile) (*base0_5.File, error) {
-	newfile := base0_5.File{}
-	newfile.Path = file.Path
-	newfile.User.Name = &file.Owner
-	newfile.Overwrite = to.BoolPtr(true)
-	mode, e := strconv.ParseInt(file.Permissions, 8, 32)
-	if e != nil {
-		return nil, fmt.Errorf("failed to parse file mode: %w", e)
+const (
+	ignitionFilesTarPath      = "/var/lib/ignition/ignition-files.tar"
+	ignitionBootcmdScriptPath = "/etc/ignition-bootcmds.sh"
+	ignitionTarUnitName       = "ignition-file-extract.service"
+)
+
+type ignitionTarEntry struct {
+	path     string
+	mode     int64
+	owner    string
+	contents []byte
+}
+
+// buildIgnitionTarEntries converts cloud-init write_files and bootcmds into tar entries.
+func buildIgnitionTarEntries(customData cloudInit) ([]ignitionTarEntry, error) {
+	entries := make([]ignitionTarEntry, 0, len(customData.WriteFiles)+1)
+
+	for _, file := range customData.WriteFiles {
+		mode, err := strconv.ParseInt(file.Permissions, 8, 32)
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse file mode: %w", err)
+		}
+
+		var contents []byte
+		switch {
+		case file.Content == "" || file.Encoding == "":
+			contents = []byte(file.Content)
+		case file.Encoding == "gzip":
+			decoded, err := getGzipDecodedValue([]byte(file.Content))
+			if err != nil {
+				return nil, fmt.Errorf("failed to decode gzip content for %s: %w", file.Path, err)
+			}
+			contents = decoded
+		case file.Encoding == "base64":
+			decoded, err := base64.StdEncoding.DecodeString(file.Content)
+			if err != nil {
+				return nil, fmt.Errorf("failed to decode base64 content: %w", err)
+			}
+			contents = decoded
+		default:
+			return nil, fmt.Errorf("unsupported encoding %s for %s", file.Encoding, file.Path)
+		}
+
+		entry := ignitionTarEntry{
+			path:     file.Path,
+			mode:     mode,
+			owner:    file.Owner,
+			contents: contents,
+		}
+		entries = append(entries, entry)
+	}
+
+	if len(customData.BootCommands) > 0 {
+		contents := strings.Join(append([]string{"#!/bin/sh"}, customData.BootCommands...), "\n")
+		entries = append(entries, ignitionTarEntry{
+			path:     ignitionBootcmdScriptPath,
+			mode:     0o755,
+			owner:    "root",
+			contents: []byte(contents),
+		})
 	}
-	newfile.Mode = to.IntPtr(int(mode))
-	switch file.Encoding {
-	case "gzip":
-		newfile.Contents.Inline = &file.Content
-		// This is hit for AKSCustomCloud file
-		if file.Content != "" {
-			newfile.Contents.Compression = &file.Encoding
+
+	return entries, nil
+}
+
+// buildIgnitionTarball builds a tar archive with relative paths for extraction at root.
+func buildIgnitionTarball(entries []ignitionTarEntry) ([]byte, error) {
+	buf := new(bytes.Buffer)
+	tarWriter := tar.NewWriter(buf)
+
+	for _, entry := range entries {
+		path := strings.TrimLeft(entry.path, "/")
+		header := &tar.Header{
+			Name: path,
+			Mode: entry.mode,
+			Size: int64(len(entry.contents)),
+			Uid:  0,
+			Gid:  0,
+		}
+		if entry.owner != "" && entry.owner != "root" {
+			header.Uname = entry.owner
 		}
-	case "base64":
-		inline, e := base64.StdEncoding.DecodeString(file.Content)
-		if e != nil {
-			return nil, fmt.Errorf("failed to decode base64 content: %w", e)
+		if err := tarWriter.WriteHeader(header); err != nil {
+			return nil, fmt.Errorf("failed to write tar header for %s: %w", entry.path, err)
 		}
-		newfile.Contents.Inline = to.StringPtr(string(inline))
-		newfile.Contents.Compression = nil
-	case "":
-		newfile.Contents.Inline = to.StringPtr(file.Content)
-	default:
-		return nil, fmt.Errorf("unsupported encoding: %s", file.Encoding)
+		if _, err := tarWriter.Write(entry.contents); err != nil {
+			return nil, fmt.Errorf("failed to write tar contents for %s: %w", entry.path, err)
+		}
+	}
+
+	if err := tarWriter.Close(); err != nil {
+		return nil, fmt.Errorf("failed to close tar writer: %w", err)
 	}
-	return &newfile, nil
+
+	return buf.Bytes(), nil
 }
 
 func cloudInitToButane(customData cloudInit) flatcar1_1.Config {
@@ -121,28 +187,31 @@ func cloudInitToButane(customData cloudInit) flatcar1_1.Config {
 		panic(fmt.Errorf("failed to unmarshal butane config: %w", e))
 	}
 
-	newfiles := make([]base0_5.File, 0)
-	var newfile *base0_5.File
-	for _, file := range customData.WriteFiles {
-		newfile, e = toButaneFile(file)
-		if e != nil {
-			panic(fmt.Errorf("failed to convert cloudInit file to butane file: %w", e))
-		}
-		newfiles = append(newfiles, *newfile)
+	entries, err := buildIgnitionTarEntries(customData)
+	if err != nil {
+		panic(fmt.Errorf("failed to convert cloudInit data to tar entries: %w", err))
 	}
-	if len(customData.BootCommands) > 0 {
-		var contents = strings.Join(append([]string{"#!/bin/sh"}, customData.BootCommands...), "\n")
-		newfiles = append(newfiles, base0_5.File{
-			Path:      "/etc/ignition-bootcmds.sh",
-			User:      base0_5.NodeUser{Name: to.StringPtr("root")},
-			Group:     base0_5.NodeGroup{Name: to.StringPtr("root")},
-			Mode:      to.IntPtr(0o755),
-			Overwrite: to.BoolPtr(true),
-			Contents:  base0_5.Resource{Inline: to.StringPtr(contents)},
-		})
+	if len(entries) == 0 {
+		return butaneconfig
+	}
+
+	tarball, err := buildIgnitionTarball(entries)
+	if err != nil {
+		panic(fmt.Errorf("failed to build ignition tarball: %w", err))
 	}
+	compressedTarball := getGzippedBufferFromBytes(tarball)
+	dataURL := "data:;base64," + base64.StdEncoding.EncodeToString(compressedTarball)
 
-	butaneconfig.Storage.Files = append(newfiles, butaneconfig.Storage.Files...)
+	tarFile := base0_5.File{
+		Path:      ignitionFilesTarPath,
+		Mode:      to.IntPtr(0o600),
+		Overwrite: to.BoolPtr(true),
+		Contents: base0_5.Resource{
+			Source:      to.StringPtr(dataURL),
+			Compression: to.StringPtr("gzip"),
+		},
+	}
+	butaneconfig.Storage.Files = append(butaneconfig.Storage.Files, tarFile)
 	return butaneconfig
 }
 
@@ -178,35 +247,7 @@ func (t *TemplateGenerator) getFlatcarLinuxNodeCustomDataJSONObject(config *data
 		panic(fmt.Errorf("failed to marshal Ignition config: %w", e))
 	}
 
-	envelope := flatcar1_1.Config{
-		Config: base0_5.Config{
-			Variant: "flatcar",
-			Version: "1.1.0",
-			Ignition: base0_5.Ignition{
-				Config: base0_5.IgnitionConfig{
-					Replace: base0_5.Resource{
-						Inline: to.StringPtr(string(ignjson)),
-						// TODO: butane 0.24.0 broke support for explicit compression
-						// so we depend on automatic resource compression.
-						// Compression: to.StringPtr("gzip"),
-					},
-				},
-			},
-		},
-	}
-	wrapped, report, e := envelope.ToIgn3_4(butanecommon.TranslateOptions{})
-	if e != nil {
-		panic(fmt.Errorf("butane -> ignition: error: %w:\n%s", e, report.String()))
-	}
-	if len(report.Entries) > 0 {
-		panic(fmt.Errorf("butane -> ignition: warning:\n%s", report.String()))
-	}
-	// Marshal the Ignition config to JSON
-	enc, err := json.Marshal(wrapped)
-	if err != nil {
-		panic(fmt.Errorf("failed to marshal Ignition config: %w", err))
-	}
-	escstr := escapeSingleLine(string(enc))
+	escstr := escapeSingleLine(string(ignjson))
 
 	return fmt.Sprintf("{\"customData\": \"%s\"}", escstr)
 }