feat: invalidate SSM cache upon AMI invalidation

charts/karpenter-crd/templates/karpenter.k8s.aws_ec2nodeclasses.yaml

@@ -3,7 +3,7 @@ apiVersion: apiextensions.k8s.io/v1
 kind: CustomResourceDefinition
 metadata:
   annotations:
-    controller-gen.kubebuilder.io/version: v0.16.3
+    controller-gen.kubebuilder.io/version: v0.16.4
   name: ec2nodeclasses.karpenter.k8s.aws
 spec:
   group: karpenter.k8s.aws

cmd/controller/main.go

@@ -62,6 +62,8 @@ func main() {
 			op.AMIProvider,
 			op.LaunchTemplateProvider,
 			op.InstanceTypesProvider,
+			op.SSMProvider,
+			op.VersionProvider,
 		)...).
 		Start(ctx)
 }

pkg/apis/crds/karpenter.k8s.aws_ec2nodeclasses.yaml

@@ -3,7 +3,7 @@ apiVersion: apiextensions.k8s.io/v1
 kind: CustomResourceDefinition
 metadata:
   annotations:
-    controller-gen.kubebuilder.io/version: v0.16.3
+    controller-gen.kubebuilder.io/version: v0.16.4
   name: ec2nodeclasses.karpenter.k8s.aws
 spec:
   group: karpenter.k8s.aws

pkg/apis/v1/ec2nodeclass.go

@@ -484,16 +484,35 @@ func (in *EC2NodeClass) AMIFamily() string {
 	if in.Spec.AMIFamily != nil {
 		return *in.Spec.AMIFamily
 	}
-	if term, ok := lo.Find(in.Spec.AMISelectorTerms, func(t AMISelectorTerm) bool {
-		return t.Alias != ""
-	}); ok {
-		return AMIFamilyFromAlias(term.Alias)
+	if alias := in.Alias(); alias != nil {
+		return alias.Family
 	}
 	// Unreachable: validation enforces that one of the above conditions must be met
 	return AMIFamilyCustom
 }
 
-func AMIFamilyFromAlias(alias string) string {
+type Alias struct {
+	Family  string
+	Version string
+}
+
+const (
+	AliasVersionLatest = "latest"
+)
+
+func (in *EC2NodeClass) Alias() *Alias {
+	if term, ok := lo.Find(in.Spec.AMISelectorTerms, func(term AMISelectorTerm) bool {
+		return term.Alias != ""
+	}); ok {
+		return &Alias{
+			Family:  amiFamilyFromAlias(term.Alias),
+			Version: amiVersionFromAlias(term.Alias),
+		}
+	}
+	return nil
+}
+
+func amiFamilyFromAlias(alias string) string {
 	components := strings.Split(alias, "@")
 	if len(components) != 2 {
 		log.Fatalf("failed to parse AMI alias %q, invalid format", alias)
@@ -513,7 +532,7 @@ func AMIFamilyFromAlias(alias string) string {
 	return family
 }
 
-func AMIVersionFromAlias(alias string) string {
+func amiVersionFromAlias(alias string) string {
 	components := strings.Split(alias, "@")
 	if len(components) != 2 {
 		log.Fatalf("failed to parse AMI alias %q, invalid format", alias)

pkg/cloudprovider/suite_test.go

@@ -1128,7 +1128,7 @@ var _ = Describe("CloudProvider", func() {
 				{SubnetId: aws.String("test-subnet-2"), AvailabilityZone: aws.String("test-zone-1a"), AvailabilityZoneId: aws.String("tstz1-1a"), AvailableIpAddressCount: aws.Int64(100),
 					Tags: []*ec2.Tag{{Key: aws.String("Name"), Value: aws.String("test-subnet-2")}}},
 			}})
-			controller := status.NewController(env.Client, awsEnv.SubnetProvider, awsEnv.SecurityGroupProvider, awsEnv.AMIProvider, awsEnv.InstanceProfileProvider, awsEnv.LaunchTemplateProvider)
+			controller := status.NewController(env.Client, awsEnv.SubnetProvider, awsEnv.SecurityGroupProvider, awsEnv.AMIProvider, awsEnv.SSMProvider, awsEnv.VersionProvider, awsEnv.InstanceProfileProvider, awsEnv.LaunchTemplateProvider)
 			ExpectApplied(ctx, env.Client, nodePool, nodeClass)
 			ExpectObjectReconciled(ctx, env.Client, controller, nodeClass)
 			pod := coretest.UnschedulablePod(coretest.PodOptions{NodeSelector: map[string]string{corev1.LabelTopologyZone: "test-zone-1a"}})
@@ -1145,7 +1145,7 @@ var _ = Describe("CloudProvider", func() {
 				{SubnetId: aws.String("test-subnet-2"), AvailabilityZone: aws.String("test-zone-1a"), AvailabilityZoneId: aws.String("tstz1-1a"), AvailableIpAddressCount: aws.Int64(11),
 					Tags: []*ec2.Tag{{Key: aws.String("Name"), Value: aws.String("test-subnet-2")}}},
 			}})
-			controller := status.NewController(env.Client, awsEnv.SubnetProvider, awsEnv.SecurityGroupProvider, awsEnv.AMIProvider, awsEnv.InstanceProfileProvider, awsEnv.LaunchTemplateProvider)
+			controller := status.NewController(env.Client, awsEnv.SubnetProvider, awsEnv.SecurityGroupProvider, awsEnv.AMIProvider, awsEnv.SSMProvider, awsEnv.VersionProvider, awsEnv.InstanceProfileProvider, awsEnv.LaunchTemplateProvider)
 			nodeClass.Spec.Kubelet = &v1.KubeletConfiguration{
 				MaxPods: aws.Int32(1),
 			}
@@ -1186,7 +1186,7 @@ var _ = Describe("CloudProvider", func() {
 			}})
 			nodeClass.Spec.SubnetSelectorTerms = []v1.SubnetSelectorTerm{{Tags: map[string]string{"Name": "test-subnet-1"}}}
 			ExpectApplied(ctx, env.Client, nodePool, nodeClass)
-			controller := status.NewController(env.Client, awsEnv.SubnetProvider, awsEnv.SecurityGroupProvider, awsEnv.AMIProvider, awsEnv.InstanceProfileProvider, awsEnv.LaunchTemplateProvider)
+			controller := status.NewController(env.Client, awsEnv.SubnetProvider, awsEnv.SecurityGroupProvider, awsEnv.AMIProvider, awsEnv.SSMProvider, awsEnv.VersionProvider, awsEnv.InstanceProfileProvider, awsEnv.LaunchTemplateProvider)
 			ExpectObjectReconciled(ctx, env.Client, controller, nodeClass)
 			podSubnet1 := coretest.UnschedulablePod()
 			ExpectProvisioned(ctx, env.Client, cluster, cloudProvider, prov, podSubnet1)

pkg/controllers/controllers.go

@@ -30,6 +30,8 @@ import (
 	controllersinstancetypecapacity "github.com/aws/karpenter-provider-aws/pkg/controllers/providers/instancetype/capacity"
 	controllerspricing "github.com/aws/karpenter-provider-aws/pkg/controllers/providers/pricing"
 	"github.com/aws/karpenter-provider-aws/pkg/providers/launchtemplate"
+	"github.com/aws/karpenter-provider-aws/pkg/providers/ssm"
+	"github.com/aws/karpenter-provider-aws/pkg/providers/version"
 
 	servicesqs "github.com/aws/aws-sdk-go-v2/service/sqs"
 	"github.com/aws/aws-sdk-go/aws/session"
@@ -59,11 +61,12 @@ import (
 func NewControllers(ctx context.Context, mgr manager.Manager, sess *session.Session, clk clock.Clock, kubeClient client.Client, recorder events.Recorder,
 	unavailableOfferings *cache.UnavailableOfferings, cloudProvider cloudprovider.CloudProvider, subnetProvider subnet.Provider,
 	securityGroupProvider securitygroup.Provider, instanceProfileProvider instanceprofile.Provider, instanceProvider instance.Provider,
-	pricingProvider pricing.Provider, amiProvider amifamily.Provider, launchTemplateProvider launchtemplate.Provider, instanceTypeProvider *instancetype.DefaultProvider) []controller.Controller {
+	pricingProvider pricing.Provider, amiProvider amifamily.Provider, launchTemplateProvider launchtemplate.Provider, instanceTypeProvider *instancetype.DefaultProvider,
+	ssmProvider ssm.Provider, versionProvider version.Provider) []controller.Controller {
 
 	controllers := []controller.Controller{
 		nodeclasshash.NewController(kubeClient),
-		nodeclassstatus.NewController(kubeClient, subnetProvider, securityGroupProvider, amiProvider, instanceProfileProvider, launchTemplateProvider),
+		nodeclassstatus.NewController(kubeClient, subnetProvider, securityGroupProvider, amiProvider, ssmProvider, versionProvider, instanceProfileProvider, launchTemplateProvider),
 		nodeclasstermination.NewController(kubeClient, recorder, instanceProfileProvider, launchTemplateProvider),
 		nodeclaimgarbagecollection.NewController(kubeClient, cloudProvider),
 		nodeclaimtagging.NewController(kubeClient, instanceProvider),

pkg/controllers/nodeclass/status/ami.go

@@ -28,10 +28,14 @@ import (
 
 	v1 "github.com/aws/karpenter-provider-aws/pkg/apis/v1"
 	"github.com/aws/karpenter-provider-aws/pkg/providers/amifamily"
+	"github.com/aws/karpenter-provider-aws/pkg/providers/ssm"
+	"github.com/aws/karpenter-provider-aws/pkg/providers/version"
 )
 
 type AMI struct {
-	amiProvider amifamily.Provider
+	amiProvider     amifamily.Provider
+	ssmProvider     ssm.Provider
+	versionProvider version.Provider
 }
 
 func (a *AMI) Reconcile(ctx context.Context, nodeClass *v1.EC2NodeClass) (reconcile.Result, error) {
@@ -44,6 +48,16 @@ func (a *AMI) Reconcile(ctx context.Context, nodeClass *v1.EC2NodeClass) (reconc
 		nodeClass.StatusConditions().SetFalse(v1.ConditionTypeAMIsReady, "AMINotFound", "AMISelector did not match any AMIs")
 		return reconcile.Result{}, nil
 	}
+	// If an alias is configured for automatic upgrades, and we receive a deprecated AMI, we should invalidate the SSM
+	// cache ahead of the 24 hour expiration period. This ensures Karpenter can react quickly to AMI deprecations due
+	// to regressions in EKS-optimized AMIs.
+	if alias := nodeClass.Alias(); alias != nil && alias.Version == v1.AliasVersionLatest && lo.ContainsBy(amis, func(a amifamily.AMI) bool { return a.Deprecated }) {
+		k8sVersion, err := a.versionProvider.Get(ctx)
+		if err != nil {
+			return reconcile.Result{}, err
+		}
+		a.ssmProvider.Invalidate(ctx, amifamily.GetAMIFamily(alias.Family, nil).SSMParameters(k8sVersion, alias.Version)...)
+	}
 	nodeClass.Status.AMIs = lo.Map(amis, func(ami amifamily.AMI, _ int) v1.AMI {
 		reqs := lo.Map(ami.Requirements.NodeSelectorRequirements(), func(item karpv1.NodeSelectorRequirementWithMinValues, _ int) corev1.NodeSelectorRequirement {
 			return item.NodeSelectorRequirement

pkg/controllers/nodeclass/status/controller.go

@@ -37,7 +37,9 @@ import (
 	"github.com/aws/karpenter-provider-aws/pkg/providers/instanceprofile"
 	"github.com/aws/karpenter-provider-aws/pkg/providers/launchtemplate"
 	"github.com/aws/karpenter-provider-aws/pkg/providers/securitygroup"
+	"github.com/aws/karpenter-provider-aws/pkg/providers/ssm"
 	"github.com/aws/karpenter-provider-aws/pkg/providers/subnet"
+	"github.com/aws/karpenter-provider-aws/pkg/providers/version"
 )
 
 type nodeClassStatusReconciler interface {
@@ -55,11 +57,12 @@ type Controller struct {
 }
 
 func NewController(kubeClient client.Client, subnetProvider subnet.Provider, securityGroupProvider securitygroup.Provider,
-	amiProvider amifamily.Provider, instanceProfileProvider instanceprofile.Provider, launchTemplateProvider launchtemplate.Provider) *Controller {
+	amiProvider amifamily.Provider, ssmProvider ssm.Provider, versionProvider version.Provider, instanceProfileProvider instanceprofile.Provider,
+	launchTemplateProvider launchtemplate.Provider) *Controller {
 	return &Controller{
 		kubeClient: kubeClient,
 
-		ami:             &AMI{amiProvider: amiProvider},
+		ami:             &AMI{amiProvider: amiProvider, ssmProvider: ssmProvider, versionProvider: versionProvider},
 		subnet:          &Subnet{subnetProvider: subnetProvider},
 		securitygroup:   &SecurityGroup{securityGroupProvider: securityGroupProvider},
 		instanceprofile: &InstanceProfile{instanceProfileProvider: instanceProfileProvider},

pkg/controllers/nodeclass/status/suite_test.go

@@ -58,6 +58,8 @@ var _ = BeforeSuite(func() {
 		awsEnv.SubnetProvider,
 		awsEnv.SecurityGroupProvider,
 		awsEnv.AMIProvider,
+		awsEnv.SSMProvider,
+		awsEnv.VersionProvider,
 		awsEnv.InstanceProfileProvider,
 		awsEnv.LaunchTemplateProvider,
 	)

pkg/operator/operator.go

@@ -153,7 +153,7 @@ func NewOperator(ctx context.Context, operator *operator.Operator) (context.Cont
 		*sess.Config.Region,
 	)
 	versionProvider := version.NewDefaultProvider(operator.KubernetesInterface, cache.New(awscache.DefaultTTL, awscache.DefaultCleanupInterval))
-	ssmProvider := ssmp.NewDefaultProvider(ssm.NewFromConfig(cfg), cache.New(awscache.SSMGetParametersByPathTTL, awscache.DefaultCleanupInterval))
+	ssmProvider := ssmp.NewDefaultProvider(ssm.NewFromConfig(cfg), cache.New(awscache.SSMGetParametersByPathTTL, awscache.DefaultCleanupInterval), operator.Clock, clusterEndpoint)
 	amiProvider := amifamily.NewDefaultProvider(operator.Clock, versionProvider, ssmProvider, ec2api, cache.New(awscache.DefaultTTL, awscache.DefaultCleanupInterval))
 	amiResolver := amifamily.NewDefaultResolver()
 	launchTemplateProvider := launchtemplate.NewDefaultProvider(

pkg/providers/amifamily/al2.go

@@ -41,23 +41,7 @@ type AL2 struct {
 
 func (a AL2) DescribeImageQuery(ctx context.Context, ssmProvider ssm.Provider, k8sVersion string, amiVersion string) (DescribeImageQuery, error) {
 	ids := map[string][]Variant{}
-	for path, variants := range map[string][]Variant{
-		fmt.Sprintf("/aws/service/eks/optimized-ami/%s/amazon-linux-2/%s/image_id", k8sVersion, lo.Ternary(
-			amiVersion == AMIVersionLatest,
-			"recommended",
-			fmt.Sprintf("amazon-eks-node-%s-%s", k8sVersion, amiVersion),
-		)): {VariantStandard},
-		fmt.Sprintf("/aws/service/eks/optimized-ami/%s/amazon-linux-2-arm64/%s/image_id", k8sVersion, lo.Ternary(
-			amiVersion == AMIVersionLatest,
-			"recommended",
-			fmt.Sprintf("amazon-eks-arm64-node-%s-%s", k8sVersion, amiVersion),
-		)): {VariantStandard},
-		fmt.Sprintf("/aws/service/eks/optimized-ami/%s/amazon-linux-2-gpu/%s/image_id", k8sVersion, lo.Ternary(
-			amiVersion == AMIVersionLatest,
-			"recommended",
-			fmt.Sprintf("amazon-eks-gpu-node-%s-%s", k8sVersion, amiVersion),
-		)): {VariantNeuron, VariantNvidia},
-	} {
+	for path, variants := range a.parametersToVariants(k8sVersion, amiVersion) {
 		imageID, err := ssmProvider.Get(ctx, path)
 		if err != nil {
 			continue
@@ -80,6 +64,30 @@ func (a AL2) DescribeImageQuery(ctx context.Context, ssmProvider ssm.Provider, k
 	}, nil
 }
 
+func (a AL2) SSMParameters(k8sVersion string, amiVersion string) []string {
+	return lo.Keys(a.parametersToVariants(k8sVersion, amiVersion))
+}
+
+func (a AL2) parametersToVariants(k8sVersion, amiVersion string) map[string][]Variant {
+	return map[string][]Variant{
+		fmt.Sprintf("/aws/service/eks/optimized-ami/%s/amazon-linux-2/%s/image_id", k8sVersion, lo.Ternary(
+			amiVersion == AMIVersionLatest,
+			"recommended",
+			fmt.Sprintf("amazon-eks-node-%s-%s", k8sVersion, amiVersion),
+		)): {VariantStandard},
+		fmt.Sprintf("/aws/service/eks/optimized-ami/%s/amazon-linux-2-arm64/%s/image_id", k8sVersion, lo.Ternary(
+			amiVersion == AMIVersionLatest,
+			"recommended",
+			fmt.Sprintf("amazon-eks-arm64-node-%s-%s", k8sVersion, amiVersion),
+		)): {VariantStandard},
+		fmt.Sprintf("/aws/service/eks/optimized-ami/%s/amazon-linux-2-gpu/%s/image_id", k8sVersion, lo.Ternary(
+			amiVersion == AMIVersionLatest,
+			"recommended",
+			fmt.Sprintf("amazon-eks-gpu-node-%s-%s", k8sVersion, amiVersion),
+		)): {VariantNeuron, VariantNvidia},
+	}
+}
+
 // UserData returns the exact same string for equivalent input,
 // even if elements of those inputs are in differing orders,
 // guaranteeing it won't cause spurious hash differences.

pkg/providers/amifamily/al2023.go

@@ -37,19 +37,18 @@ type AL2023 struct {
 
 func (a AL2023) DescribeImageQuery(ctx context.Context, ssmProvider ssm.Provider, k8sVersion string, amiVersion string) (DescribeImageQuery, error) {
 	ids := map[string]Variant{}
-	for arch, variants := range map[string][]Variant{
-		"x86_64": []Variant{VariantStandard, VariantNvidia, VariantNeuron},
-		"arm64":  []Variant{VariantStandard},
-	} {
-		for _, variant := range variants {
-			path := a.resolvePath(arch, string(variant), k8sVersion, amiVersion)
-			imageID, err := ssmProvider.Get(ctx, path)
-			if err != nil {
-				continue
+	for parameter, archToVariantMap := range a.parametersToVariantAndArchitecture(k8sVersion, amiVersion) {
+		for _, variants := range archToVariantMap {
+			for _, variant := range variants {
+				imageID, err := ssmProvider.Get(ctx, parameter)
+				if err != nil {
+					continue
+				}
+				ids[imageID] = variant
 			}
-			ids[imageID] = variant
 		}
 	}
+
 	// Failed to discover any AMIs, we should short circuit AMI discovery
 	if len(ids) == 0 {
 		return DescribeImageQuery{}, fmt.Errorf(`failed to discover AMIs for alias "al2023@%s"`, amiVersion)
@@ -66,6 +65,25 @@ func (a AL2023) DescribeImageQuery(ctx context.Context, ssmProvider ssm.Provider
 	}, nil
 }
 
+func (a AL2023) SSMParameters(k8sVersion string, amiVersion string) []string {
+	return lo.Keys(a.parametersToVariantAndArchitecture(k8sVersion, amiVersion))
+}
+
+func (a AL2023) parametersToVariantAndArchitecture(k8sVersion, amiVersion string) map[string]map[string][]Variant {
+	parameters := map[string]map[string][]Variant{}
+	for arch, variants := range map[string][]Variant{
+		"x86_64": []Variant{VariantStandard, VariantNvidia, VariantNeuron},
+		"arm64":  []Variant{VariantStandard},
+	} {
+		for _, v := range variants {
+			parameters[a.resolvePath(arch, string(v), k8sVersion, amiVersion)] = map[string][]Variant{
+				arch: []Variant{v},
+			}
+		}
+	}
+	return parameters
+}
+
 func (a AL2023) resolvePath(architecture, variant, k8sVersion, amiVersion string) string {
 	name := lo.Ternary(
 		amiVersion == AMIVersionLatest,

pkg/providers/amifamily/ami.go

@@ -88,15 +88,13 @@ func (p *DefaultProvider) List(ctx context.Context, nodeClass *v1.EC2NodeClass)
 func (p *DefaultProvider) DescribeImageQueries(ctx context.Context, nodeClass *v1.EC2NodeClass) ([]DescribeImageQuery, error) {
 	// Aliases are mutually exclusive, both on the term level and field level within a term.
 	// This is enforced by a CEL validation, we will treat this as an invariant.
-	if term, ok := lo.Find(nodeClass.Spec.AMISelectorTerms, func(term v1.AMISelectorTerm) bool {
-		return term.Alias != ""
-	}); ok {
+	if alias := nodeClass.Alias(); alias != nil {
 		kubernetesVersion, err := p.versionProvider.Get(ctx)
 		if err != nil {
 			return nil, fmt.Errorf("getting kubernetes version, %w", err)
 		}
-		amiFamily := GetAMIFamily(v1.AMIFamilyFromAlias(term.Alias), nil)
-		query, err := amiFamily.DescribeImageQuery(ctx, p.ssmProvider, kubernetesVersion, v1.AMIVersionFromAlias(term.Alias))
+
+		query, err := GetAMIFamily(alias.Family, nil).DescribeImageQuery(ctx, p.ssmProvider, kubernetesVersion, alias.Version)
 		if err != nil {
 			return []DescribeImageQuery{}, err
 		}

pkg/providers/amifamily/bottlerocket.go

@@ -41,14 +41,8 @@ type Bottlerocket struct {
 
 func (b Bottlerocket) DescribeImageQuery(ctx context.Context, ssmProvider ssm.Provider, k8sVersion string, amiVersion string) (DescribeImageQuery, error) {
 	// Bottlerocket AMIs versions are prefixed with a v on GitHub, but not in the SSM path. We should accept both.
-	trimmedAMIVersion := strings.TrimLeft(amiVersion, "v")
 	ids := map[string][]Variant{}
-	for path, variants := range map[string][]Variant{
-		fmt.Sprintf("/aws/service/bottlerocket/aws-k8s-%s/x86_64/%s/image_id", k8sVersion, trimmedAMIVersion):        {VariantStandard},
-		fmt.Sprintf("/aws/service/bottlerocket/aws-k8s-%s/arm64/%s/image_id", k8sVersion, trimmedAMIVersion):         {VariantStandard},
-		fmt.Sprintf("/aws/service/bottlerocket/aws-k8s-%s-nvidia/x86_64/%s/image_id", k8sVersion, trimmedAMIVersion): {VariantNeuron, VariantNvidia},
-		fmt.Sprintf("/aws/service/bottlerocket/aws-k8s-%s-nvidia/arm64/%s/image_id", k8sVersion, trimmedAMIVersion):  {VariantNeuron, VariantNvidia},
-	} {
+	for path, variants := range b.parametersToVariants(k8sVersion, amiVersion) {
 		imageID, err := ssmProvider.Get(ctx, path)
 		if err != nil {
 			continue
@@ -71,6 +65,20 @@ func (b Bottlerocket) DescribeImageQuery(ctx context.Context, ssmProvider ssm.Pr
 	}, nil
 }
 
+func (b Bottlerocket) SSMParameters(k8sVersion string, amiVersion string) []string {
+	return lo.Keys(b.parametersToVariants(k8sVersion, amiVersion))
+}
+
+func (b Bottlerocket) parametersToVariants(k8sVersion, amiVersion string) map[string][]Variant {
+	trimmedAMIVersion := strings.TrimLeft(amiVersion, "v")
+	return map[string][]Variant{
+		fmt.Sprintf("/aws/service/bottlerocket/aws-k8s-%s/x86_64/%s/image_id", k8sVersion, trimmedAMIVersion):        {VariantStandard},
+		fmt.Sprintf("/aws/service/bottlerocket/aws-k8s-%s/arm64/%s/image_id", k8sVersion, trimmedAMIVersion):         {VariantStandard},
+		fmt.Sprintf("/aws/service/bottlerocket/aws-k8s-%s-nvidia/x86_64/%s/image_id", k8sVersion, trimmedAMIVersion): {VariantNeuron, VariantNvidia},
+		fmt.Sprintf("/aws/service/bottlerocket/aws-k8s-%s-nvidia/arm64/%s/image_id", k8sVersion, trimmedAMIVersion):  {VariantNeuron, VariantNvidia},
+	}
+}
+
 // UserData returns the default userdata script for the AMI Family
 func (b Bottlerocket) UserData(kubeletConfig *v1.KubeletConfiguration, taints []corev1.Taint, labels map[string]string, caBundle *string, _ []*cloudprovider.InstanceType, customUserData *string, instanceStorePolicy *v1.InstanceStorePolicy) bootstrap.Bootstrapper {
 	return bootstrap.Bottlerocket{