feat(nodeadm): add nodeadm config dump command (#2107)

* feat(nodeadm): add config dump command

* refactor(nodeadm): move resolveConfig to cli package

Author: vflaux

nodeadm/cmd/nodeadm/config/dump.go

@@ -0,0 +1,66 @@
+package config
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/awslabs/amazon-eks-ami/nodeadm/api/v1alpha1"
+	"github.com/awslabs/amazon-eks-ami/nodeadm/internal/api/bridge"
+	"github.com/awslabs/amazon-eks-ami/nodeadm/internal/cli"
+	"github.com/awslabs/amazon-eks-ami/nodeadm/internal/util"
+	"github.com/integrii/flaggy"
+	"go.uber.org/zap"
+)
+
+type dumpCmd struct {
+	cmd *flaggy.Subcommand
+
+	configSources []string
+	configCache   string
+	configOutput  string
+}
+
+func NewDumpCommand() cli.Command {
+	c := dumpCmd{}
+	c.cmd = flaggy.NewSubcommand("dump")
+	c.cmd.Description = "Dump configuration"
+	cli.RegisterFlagConfigSources(c.cmd, &c.configSources)
+	cli.RegisterFlagConfigCache(c.cmd, &c.configCache)
+	cli.RegisterFlagConfigOutput(c.cmd, &c.configOutput)
+	return &c
+}
+
+func (c *dumpCmd) Flaggy() *flaggy.Subcommand {
+	return c.cmd
+}
+
+func (c *dumpCmd) Run(log *zap.Logger, opts *cli.GlobalOptions) error {
+	c.configSources = cli.ResolveConfigSources(c.configSources)
+
+	if c.configOutput != "" {
+		log.Info("Dumping configuration", zap.Strings("source", c.configSources), zap.String("output", c.configOutput))
+	}
+
+	nodeConfig, _, _, err := cli.ResolveConfig(log, c.configSources, c.configCache)
+	if err != nil {
+		return err
+	}
+
+	data, err := bridge.EncodeNodeConfig(nodeConfig, v1alpha1.GroupVersion)
+	if err != nil {
+		return fmt.Errorf("failed to encode config: %w", err)
+	}
+
+	if c.configOutput != "" {
+		if err := util.WriteFileWithDir(c.configOutput, data, 0644); err != nil {
+			return fmt.Errorf("failed to write config to file: %w", err)
+		}
+		log.Info("Configuration dumped")
+		return nil
+	}
+
+	if _, err := os.Stdout.Write(data); err != nil {
+		return fmt.Errorf("failed to write config to stdout: %w", err)
+	}
+	return nil
+}

nodeadm/cmd/nodeadm/config/root.go

@@ -7,5 +7,6 @@ import (
 func NewConfigCommand() cli.Command {
 	container := cli.NewCommandContainer("config", "Manage configuration")
 	container.AddCommand(NewCheckCommand())
+	container.AddCommand(NewDumpCommand())
 	return container.AsCommand()
 }

nodeadm/cmd/nodeadm/init/init.go

@@ -2,9 +2,6 @@ package init
 
 import (
 	"context"
-	"errors"
-	"os"
-	"reflect"
 	"time"
 
 	"github.com/aws/aws-sdk-go-v2/aws"
@@ -15,15 +12,12 @@ import (
 	"k8s.io/utils/strings/slices"
 
 	"github.com/awslabs/amazon-eks-ami/nodeadm/internal/api"
-	"github.com/awslabs/amazon-eks-ami/nodeadm/internal/api/bridge"
 	"github.com/awslabs/amazon-eks-ami/nodeadm/internal/aws/imds"
 	"github.com/awslabs/amazon-eks-ami/nodeadm/internal/cli"
-	"github.com/awslabs/amazon-eks-ami/nodeadm/internal/configprovider"
 	"github.com/awslabs/amazon-eks-ami/nodeadm/internal/containerd"
 	"github.com/awslabs/amazon-eks-ami/nodeadm/internal/daemon"
 	"github.com/awslabs/amazon-eks-ami/nodeadm/internal/kubelet"
 	"github.com/awslabs/amazon-eks-ami/nodeadm/internal/system"
-	"github.com/awslabs/amazon-eks-ami/nodeadm/internal/util"
 )
 
 const (
@@ -38,7 +32,7 @@ func NewInitCommand() cli.Command {
 	c.cmd.Description = "Initialize this instance as a node in an EKS cluster"
 	c.cmd.StringSlice(&c.daemons, "d", "daemon", "specify one or more of `containerd` and `kubelet`. This is intended for testing and should not be used in a production environment.")
 	c.cmd.StringSlice(&c.skipPhases, "s", "skip", "phases of the bootstrap you want to skip")
-	c.cmd.String(&c.configCache, "", "config-cache", "File path at which to cache the resolved/enriched config. This can make repeated init calls more efficient. JSON encoding will be used.")
+	cli.RegisterFlagConfigCache(c.cmd, &c.configCache)
 	cli.RegisterFlagConfigSources(c.cmd, &c.configSources)
 	return &c
 }
@@ -70,7 +64,7 @@ func (c *initCmd) Run(log *zap.Logger, opts *cli.GlobalOptions) error {
 
 	log.Info("Loading configuration..", zap.Strings("configSource", c.configSources), zap.String("configCache", c.configCache))
 
-	nodeConfig, isChanged, shouldEnrichConfig, err := c.resolveConfig(log)
+	nodeConfig, isChanged, shouldEnrichConfig, err := cli.ResolveConfig(log, c.configSources, c.configCache)
 	if err != nil {
 		return err
 	}
@@ -137,7 +131,7 @@ func (c *initCmd) Run(log *zap.Logger, opts *cli.GlobalOptions) error {
 		}
 
 		// this is not fatal, so do not use a blocking error.
-		if err := saveCachedConfig(nodeConfig, c.configCache); err != nil {
+		if err := cli.SaveCachedConfig(nodeConfig, c.configCache); err != nil {
 			log.Error("Failed to cache config", zap.String("configCache", c.configCache), zap.Error(err))
 		}
 	}
@@ -162,52 +156,6 @@ func (c *initCmd) Run(log *zap.Logger, opts *cli.GlobalOptions) error {
 	return nil
 }
 
-// resolveConfig returns either the cached config or the provided config chain.
-func (c *initCmd) resolveConfig(log *zap.Logger) (cfg *api.NodeConfig, isChanged bool, shouldEnrichConfig bool, err error) {
-	var cachedConfig *api.NodeConfig
-	shouldEnrichConfig = false
-	if len(c.configCache) > 0 {
-		config, err := loadCachedConfig(c.configCache)
-		if err != nil {
-			log.Warn("failed to load cached config", zap.Error(err))
-		} else {
-			cachedConfig = config
-		}
-	}
-
-	provider, err := configprovider.BuildConfigProviderChain(c.configSources)
-	if err != nil {
-		return nil, false, shouldEnrichConfig, err
-	}
-	nodeConfig, err := provider.Provide()
-	// if the error is just that no config is provided, then attempt to use the
-	// cached config as a fallback. otherwise, treat this as a fatal error.
-	if errors.Is(err, configprovider.ErrNoConfigInChain) && cachedConfig != nil {
-		log.Warn("Falling back to cached config...")
-		return cachedConfig, false, shouldEnrichConfig, nil
-	} else if err != nil {
-		return nil, false, shouldEnrichConfig, err
-	}
-
-	// if the cached and the provider config specs are the same, we'll just
-	// use the cached spec because it also has the internal NodeConfig
-	// .status information cached.
-	//
-	// if perf of reflect.DeepEqual becomes an issue, look into something like: https://github.com/Wind-River/deepequal-gen
-	if cachedConfig != nil && reflect.DeepEqual(nodeConfig.Spec, cachedConfig.Spec) {
-		return cachedConfig, false, shouldEnrichConfig, nil
-	}
-
-	// If the code reaches here it means that either no-config is cached (isChanged = false)
-	// Or the cache exists and the cached spec does not match the node spec (isChanged = true)
-	// In both cases, the config should be enriched
-	shouldEnrichConfig = true
-
-	// we return the presence of a cache as the `isChanged` value, because if we
-	// had a cache hit and didnt use it, it's because we have a modified config.
-	return nodeConfig, cachedConfig != nil, shouldEnrichConfig, nil
-}
-
 // enrichConfig populates the internal .status portion of the NodeConfig, used
 // only for internal implementation details.
 func (*initCmd) enrichConfig(log *zap.Logger, cfg *api.NodeConfig, opts *cli.GlobalOptions) error {
@@ -257,24 +205,6 @@ func (*initCmd) enrichConfig(log *zap.Logger, cfg *api.NodeConfig, opts *cli.Glo
 	return nil
 }
 
-func loadCachedConfig(path string) (*api.NodeConfig, error) {
-	// #nosec G304 // intended mechanism to read user-provided config file
-	nodeConfigData, err := os.ReadFile(path)
-	if err != nil {
-		return nil, err
-	}
-	gvk := bridge.InternalGroupVersion.WithKind(api.KindNodeConfig)
-	return bridge.DecodeNodeConfig(nodeConfigData, &gvk)
-}
-
-func saveCachedConfig(cfg *api.NodeConfig, path string) error {
-	data, err := bridge.EncodeNodeConfig(cfg)
-	if err != nil {
-		return err
-	}
-	return util.WriteFileWithDir(path, data, 0644)
-}
-
 func (c *initCmd) configureDaemons(log *zap.Logger, cfg *api.NodeConfig, daemons []daemon.Daemon) error {
 	for _, daemon := range daemons {
 		if len(c.daemons) > 0 && !slices.Contains(c.daemons, daemon.Name()) {

nodeadm/internal/api/bridge/encode.go

@@ -10,7 +10,7 @@ import (
 
 // EncodeNodeConfig marshals the given internal NodeConfig object to JSON.
 // JSON is used because it's simply easier than YAML to work with in scripting contexts.
-func EncodeNodeConfig(nodeConfig *internalapi.NodeConfig) ([]byte, error) {
+func EncodeNodeConfig(nodeConfig *internalapi.NodeConfig, groupVersioner runtime.GroupVersioner) ([]byte, error) {
 	scheme := runtime.NewScheme()
 	err := localSchemeBuilder.AddToScheme(scheme)
 	if err != nil {
@@ -21,7 +21,12 @@ func EncodeNodeConfig(nodeConfig *internalapi.NodeConfig) ([]byte, error) {
 	if !matched {
 		return nil, fmt.Errorf("JSON did not match any supported media type")
 	}
-	// always encode to the internal version so we don't lose any internal state
-	codec := codecs.EncoderForVersion(info.Serializer, InternalGroupVersion)
+	codec := codecs.EncoderForVersion(info.Serializer, groupVersioner)
 	return runtime.Encode(codec, nodeConfig)
 }
+
+// EncodeInternalNodeConfig marshals the given internal NodeConfig object to JSON using the internal group version.
+// JSON is used because it's simply easier than YAML to work with in scripting contexts.
+func EncodeInternalNodeConfig(nodeConfig *internalapi.NodeConfig) ([]byte, error) {
+	return EncodeNodeConfig(nodeConfig, InternalGroupVersion)
+}

nodeadm/internal/cli/config.go

@@ -0,0 +1,80 @@
+package cli
+
+import (
+	"errors"
+	"os"
+	"reflect"
+
+	"github.com/awslabs/amazon-eks-ami/nodeadm/internal/api"
+	"github.com/awslabs/amazon-eks-ami/nodeadm/internal/api/bridge"
+	"github.com/awslabs/amazon-eks-ami/nodeadm/internal/util"
+
+	"github.com/awslabs/amazon-eks-ami/nodeadm/internal/configprovider"
+
+	"go.uber.org/zap"
+)
+
+// ResolveConfig returns either the cached config or the provided config chain.
+func ResolveConfig(log *zap.Logger, rawConfigSourceURLs []string, configCachePath string) (cfg *api.NodeConfig, isChanged bool, shouldEnrichConfig bool, err error) {
+	var cachedConfig *api.NodeConfig
+	shouldEnrichConfig = false
+
+	if len(configCachePath) > 0 {
+		config, err := LoadCachedConfig(configCachePath)
+		if err != nil {
+			log.Warn("failed to load cached config", zap.Error(err))
+		} else {
+			cachedConfig = config
+		}
+	}
+
+	provider, err := configprovider.BuildConfigProviderChain(rawConfigSourceURLs)
+	if err != nil {
+		return nil, false, shouldEnrichConfig, err
+	}
+	nodeConfig, err := provider.Provide()
+	// if the error is just that no config is provided, then attempt to use the
+	// cached config as a fallback. otherwise, treat this as a fatal error.
+	if errors.Is(err, configprovider.ErrNoConfigInChain) && cachedConfig != nil {
+		log.Warn("Falling back to cached config...")
+		return cachedConfig, false, shouldEnrichConfig, nil
+	} else if err != nil {
+		return nil, false, shouldEnrichConfig, err
+	}
+
+	// if the cached and the provider config specs are the same, we'll just
+	// use the cached spec because it also has the internal NodeConfig
+	// .status information cached.
+	//
+	// if perf of reflect.DeepEqual becomes an issue, look into something like: https://github.com/Wind-River/deepequal-gen
+	if cachedConfig != nil && reflect.DeepEqual(nodeConfig.Spec, cachedConfig.Spec) {
+		return cachedConfig, false, shouldEnrichConfig, nil
+	}
+
+	// If the code reaches here it means that either no-config is cached (isChanged = false)
+	// Or the cache exists and the cached spec does not match the node spec (isChanged = true)
+	// In both cases, the config should be enriched
+	shouldEnrichConfig = true
+
+	// we return the presence of a cache as the `isChanged` value, because if we
+	// had a cache hit and didnt use it, it's because we have a modified config.
+	return nodeConfig, cachedConfig != nil, shouldEnrichConfig, nil
+}
+
+func LoadCachedConfig(path string) (*api.NodeConfig, error) {
+	// #nosec G304 // intended mechanism to read user-provided config file
+	nodeConfigData, err := os.ReadFile(path)
+	if err != nil {
+		return nil, err
+	}
+	gvk := bridge.InternalGroupVersion.WithKind(api.KindNodeConfig)
+	return bridge.DecodeNodeConfig(nodeConfigData, &gvk)
+}
+
+func SaveCachedConfig(cfg *api.NodeConfig, path string) error {
+	data, err := bridge.EncodeInternalNodeConfig(cfg)
+	if err != nil {
+		return err
+	}
+	return util.WriteFileWithDir(path, data, 0644)
+}

nodeadm/internal/cli/options.go

@@ -26,7 +26,7 @@ func NewGlobalOptions() *GlobalOptions {
 }
 
 func RegisterFlagConfigOutput(c *flaggy.Subcommand, configOutput *string) {
-	c.String(configOutput, "", "config-output", "File path to write the final resolved and enriched config to. JSON encoding is used.")
+	c.String(configOutput, "o", "config-output", "File path to write the final resolved config to. JSON encoding is used.")
 }
 
 // RegisterFlagConfigSources maps a command-line flag for config sources to the specified string slice for the specified command.
@@ -45,3 +45,7 @@ func ResolveConfigSources(configSources []string) []string {
 	zap.L().Info("Using default config sources...")
 	return DefaultConfigSources
 }
+
+func RegisterFlagConfigCache(c *flaggy.Subcommand, configCache *string) {
+	c.String(configCache, "", "config-cache", "File path at which to cache the resolved/enriched config. This can make repeated init calls more efficient. JSON encoding will be used.")
+}