fix(amifamily) remove HTTPProtocolIPv6 by default for unsupported regions

Author: treyrichbourg

hack/tools/launchtemplate_counter/main.go

@@ -139,7 +139,7 @@ func main() {
 	})
 	fmt.Printf("Got %d instance types after filtering\n", len(instanceTypes))
 
-	resolver := amifamily.NewDefaultResolver()
+	resolver := amifamily.NewDefaultResolver(region)
 	launchTemplates, err := resolver.Resolve(nodeClass, &karpv1.NodeClaim{}, lo.Slice(instanceTypes, 0, 60), karpv1.CapacityTypeOnDemand, &amifamily.Options{InstanceStorePolicy: lo.ToPtr(v1.InstanceStorePolicyRAID0)})
 
 	if err != nil {

kwok/operator/operator.go

@@ -139,7 +139,7 @@ func NewOperator(ctx context.Context, operator *operator.Operator) (context.Cont
 	lo.Must0(versionProvider.UpdateVersion(ctx))
 	ssmProvider := ssmp.NewDefaultProvider(ssm.NewFromConfig(cfg), ssmCache)
 	amiProvider := amifamily.NewDefaultProvider(operator.Clock, versionProvider, ssmProvider, ec2api, cache.New(awscache.DefaultTTL, awscache.DefaultCleanupInterval))
-	amiResolver := amifamily.NewDefaultResolver()
+	amiResolver := amifamily.NewDefaultResolver(cfg.Region)
 	launchTemplateProvider := launchtemplate.NewDefaultProvider(
 		ctx,
 		cache.New(awscache.DefaultTTL, awscache.DefaultCleanupInterval),

pkg/operator/operator.go

@@ -145,7 +145,7 @@ func NewOperator(ctx context.Context, operator *operator.Operator) (context.Cont
 	lo.Must0(versionProvider.UpdateVersion(ctx))
 	ssmProvider := ssmp.NewDefaultProvider(ssm.NewFromConfig(cfg), ssmCache)
 	amiProvider := amifamily.NewDefaultProvider(operator.Clock, versionProvider, ssmProvider, ec2api, cache.New(awscache.DefaultTTL, awscache.DefaultCleanupInterval))
-	amiResolver := amifamily.NewDefaultResolver()
+	amiResolver := amifamily.NewDefaultResolver(cfg.Region)
 	launchTemplateProvider := launchtemplate.NewDefaultProvider(
 		ctx,
 		cache.New(awscache.DefaultTTL, awscache.DefaultCleanupInterval),

pkg/providers/amifamily/resolver.go

@@ -25,6 +25,7 @@ import (
 	"github.com/samber/lo"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/resource"
+	"k8s.io/apimachinery/pkg/util/sets"
 
 	karpv1 "sigs.k8s.io/karpenter/pkg/apis/v1"
 
@@ -47,7 +48,9 @@ type Resolver interface {
 }
 
 // DefaultResolver is able to fill-in dynamic launch template parameters
-type DefaultResolver struct{}
+type DefaultResolver struct {
+	region string
+}
 
 // Options define the static launch template parameters
 type Options struct {
@@ -117,8 +120,10 @@ func (d DefaultFamily) FeatureFlags() FeatureFlags {
 }
 
 // NewDefaultResolver constructs a new launch template DefaultResolver
-func NewDefaultResolver() *DefaultResolver {
-	return &DefaultResolver{}
+func NewDefaultResolver(region string) *DefaultResolver {
+	return &DefaultResolver{
+		region: region,
+	}
 }
 
 // Resolve generates launch templates using the static options and dynamically generates launch template parameters.
@@ -270,6 +275,15 @@ func (r DefaultResolver) resolveLaunchTemplates(
 	if len(capacityReservationIDs) == 0 {
 		capacityReservationIDs = append(capacityReservationIDs, "")
 	}
+	httpProtocolUnsupportedRegions := sets.New[string](
+		"eu-isoe-west-1",
+		"us-iso-east-1",
+		"us-iso-west-1",
+		"us-isob-east-1",
+		"us-isob-west-1",
+		"us-isof-south-1",
+		"us-isof-east-1",
+	)
 	return lo.Map(capacityReservationIDs, func(id string, _ int) *LaunchTemplate {
 		resolved := &LaunchTemplate{
 			Options: options,
@@ -298,6 +312,9 @@ func (r DefaultResolver) resolveLaunchTemplates(
 		if resolved.MetadataOptions == nil {
 			resolved.MetadataOptions = amiFamily.DefaultMetadataOptions()
 		}
+		if httpProtocolUnsupportedRegions.Has(r.region) {
+			resolved.MetadataOptions.HTTPProtocolIPv6 = nil
+		}
 		return resolved
 	})
 }

pkg/providers/amifamily/suite_test.go

@@ -35,13 +35,18 @@ import (
 	"github.com/samber/lo"
 	corev1 "k8s.io/api/core/v1"
 
+	"github.com/awslabs/operatorpkg/object"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	karpv1 "sigs.k8s.io/karpenter/pkg/apis/v1"
+	corecloudprovider "sigs.k8s.io/karpenter/pkg/cloudprovider"
+	corecloudfake "sigs.k8s.io/karpenter/pkg/cloudprovider/fake"
 	coreoptions "sigs.k8s.io/karpenter/pkg/operator/options"
 	"sigs.k8s.io/karpenter/pkg/scheduling"
 	coretest "sigs.k8s.io/karpenter/pkg/test"
 
 	"github.com/aws/karpenter-provider-aws/pkg/apis"
 	v1 "github.com/aws/karpenter-provider-aws/pkg/apis/v1"
+	"github.com/aws/karpenter-provider-aws/pkg/fake"
 	"github.com/aws/karpenter-provider-aws/pkg/operator/options"
 	"github.com/aws/karpenter-provider-aws/pkg/providers/amifamily"
 	"github.com/aws/karpenter-provider-aws/pkg/test"
@@ -51,6 +56,9 @@ var ctx context.Context
 var env *coretest.Environment
 var awsEnv *test.Environment
 var nodeClass *v1.EC2NodeClass
+var nodePool *karpv1.NodePool
+var nodeClaim *karpv1.NodeClaim
+var instanceTypes []*corecloudprovider.InstanceType
 
 func TestAWS(t *testing.T) {
 	ctx = TestContextWithLogger(t)
@@ -929,6 +937,60 @@ var _ = Describe("AMIProvider", func() {
 	})
 })
 
+var _ = Describe("AMIResolver", func() {
+	BeforeEach(func() {
+		nodeClass = test.EC2NodeClass()
+		nodePool = coretest.NodePool(karpv1.NodePool{
+			Spec: karpv1.NodePoolSpec{
+				Template: karpv1.NodeClaimTemplate{
+					Spec: karpv1.NodeClaimTemplateSpec{
+						NodeClassRef: &karpv1.NodeClassReference{
+							Group: object.GVK(nodeClass).Group,
+							Kind:  object.GVK(nodeClass).Kind,
+							Name:  nodeClass.Name,
+						},
+					},
+				},
+			},
+		})
+		nodeClaim = coretest.NodeClaim(karpv1.NodeClaim{
+			ObjectMeta: metav1.ObjectMeta{
+				Labels: map[string]string{
+					karpv1.NodePoolLabelKey: nodePool.Name,
+				},
+			},
+			Spec: karpv1.NodeClaimSpec{
+				NodeClassRef: &karpv1.NodeClassReference{
+					Group: object.GVK(nodeClass).Group,
+					Kind:  object.GVK(nodeClass).Kind,
+					Name:  nodeClass.Name,
+				},
+			},
+		})
+		instanceTypes = []*corecloudprovider.InstanceType{
+			corecloudfake.NewInstanceType(corecloudfake.InstanceTypeOptions{Name: "t3.medium"}),
+			corecloudfake.NewInstanceType(corecloudfake.InstanceTypeOptions{Name: "m5.large"}),
+		}
+	})
+	DescribeTable(
+		"should set launch template metadata options correctly per region",
+		func(region string, expect *string) {
+			amiResolver := amifamily.NewDefaultResolver(region)
+			launchTemplates, err := amiResolver.Resolve(nodeClass, nodeClaim, instanceTypes, karpv1.CapacityTypeOnDemand, &amifamily.Options{ClusterName: "test"})
+			Expect(err).ToNot(HaveOccurred())
+			Expect(launchTemplates).To(HaveLen(1))
+			lo.ForEach(launchTemplates, func(launchTemplate *amifamily.LaunchTemplate, _ int) {
+				Expect(launchTemplate.MetadataOptions.HTTPProtocolIPv6).To(Equal(expect))
+			})
+		},
+		Entry("should be disabled for supported regions", fake.DefaultRegion, lo.ToPtr("disabled")),
+		Entry("should be nil for isoe", "eu-isoe-west-1", nil),
+		Entry("should be nil for iso", "us-iso-east-1", nil),
+		Entry("should be nil for isob", "us-isob-east-1", nil),
+		Entry("should be nil for isof", "us-isof-south-1", nil),
+	)
+})
+
 func ExpectConsistsOfAMIQueries(expected, actual []amifamily.DescribeImageQuery) {
 	GinkgoHelper()
 	Expect(actual).To(HaveLen(len(expected)))

pkg/test/environment.go

@@ -145,7 +145,7 @@ func NewEnvironment(ctx context.Context, env *coretest.Environment) *Environment
 	instanceProfileProvider := instanceprofile.NewDefaultProvider(iamapi, instanceProfileCache, protectedProfilesCache, fake.DefaultRegion)
 	ssmProvider := ssmp.NewDefaultProvider(ssmapi, ssmCache)
 	amiProvider := amifamily.NewDefaultProvider(clock, versionProvider, ssmProvider, ec2api, ec2Cache)
-	amiResolver := amifamily.NewDefaultResolver()
+	amiResolver := amifamily.NewDefaultResolver(fake.DefaultRegion)
 	instanceTypesResolver := instancetype.NewDefaultResolver(fake.DefaultRegion)
 	capacityReservationProvider := capacityreservation.NewProvider(ec2api, clock, capacityReservationCache, capacityReservationAvailabilityCache)
 	instanceTypesProvider := instancetype.NewDefaultProvider(instanceTypeCache, offeringCache, discoveredCapacityCache, ec2api, subnetProvider, pricingProvider, capacityReservationProvider, unavailableOfferingsCache, instanceTypesResolver)