Add launch template counter tool

hack/tools/launchtemplate_counter/main.go

@@ -0,0 +1,143 @@
+/*
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package main
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"os"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/aws/session"
+	"github.com/aws/aws-sdk-go/service/ec2"
+	"github.com/patrickmn/go-cache"
+	"github.com/samber/lo"
+	corev1 "k8s.io/api/core/v1"
+	karpv1 "sigs.k8s.io/karpenter/pkg/apis/v1"
+	"sigs.k8s.io/karpenter/pkg/cloudprovider"
+	coreoptions "sigs.k8s.io/karpenter/pkg/operator/options"
+	"sigs.k8s.io/karpenter/pkg/scheduling"
+	coretest "sigs.k8s.io/karpenter/pkg/test"
+
+	v1 "github.com/aws/karpenter-provider-aws/pkg/apis/v1"
+	awscache "github.com/aws/karpenter-provider-aws/pkg/cache"
+	"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/providers/instancetype"
+	"github.com/aws/karpenter-provider-aws/pkg/providers/pricing"
+	"github.com/aws/karpenter-provider-aws/pkg/providers/subnet"
+	"github.com/aws/karpenter-provider-aws/pkg/test"
+)
+
+func main() {
+	lo.Must0(os.Setenv("AWS_SDK_LOAD_CONFIG", "true"))
+
+	ctx := coreoptions.ToContext(context.Background(), coretest.Options())
+	ctx = options.ToContext(ctx, test.Options(test.OptionsFields{
+		ClusterName:     lo.ToPtr("docs-gen"),
+		ClusterEndpoint: lo.ToPtr("https://docs-gen.aws"),
+		IsolatedVPC:     lo.ToPtr(true), // disable pricing lookup
+	}))
+
+	region := "us-west-2"
+	sess := session.Must(session.NewSession(&aws.Config{Region: lo.ToPtr(region)}))
+	ec2api := ec2.New(sess)
+	subnetProvider := subnet.NewDefaultProvider(ec2api, cache.New(awscache.DefaultTTL, awscache.DefaultCleanupInterval), cache.New(awscache.AvailableIPAddressTTL, awscache.DefaultCleanupInterval), cache.New(awscache.AssociatePublicIPAddressTTL, awscache.DefaultCleanupInterval))
+	instanceTypeProvider := instancetype.NewDefaultProvider(
+		region,
+		cache.New(awscache.InstanceTypesAndZonesTTL, awscache.DefaultCleanupInterval),
+		ec2api,
+		subnetProvider,
+		awscache.NewUnavailableOfferings(),
+		pricing.NewDefaultProvider(
+			ctx,
+			pricing.NewAPI(sess, *sess.Config.Region),
+			ec2api,
+			*sess.Config.Region,
+		),
+	)
+	if err := instanceTypeProvider.UpdateInstanceTypes(ctx); err != nil {
+		log.Fatalf("updating instance types, %s", err)
+	}
+	if err := instanceTypeProvider.UpdateInstanceTypeOfferings(ctx); err != nil {
+		log.Fatalf("updating instance types offerings, %s", err)
+	}
+	// Fake a NodeClass, so we can use it to get InstanceTypes
+	nodeClass := &v1.EC2NodeClass{
+		Spec: v1.EC2NodeClassSpec{
+			AMISelectorTerms: []v1.AMISelectorTerm{{
+				Alias: "al2023@latest",
+			}},
+			SubnetSelectorTerms: []v1.SubnetSelectorTerm{
+				{
+					Tags: map[string]string{
+						"*": "*",
+					},
+				},
+			},
+		},
+	}
+	subnets, err := subnetProvider.List(ctx, nodeClass)
+	if err != nil {
+		log.Fatalf("listing subnets, %s", err)
+	}
+	nodeClass.Status.Subnets = lo.Map(subnets, func(ec2subnet *ec2.Subnet, _ int) v1.Subnet {
+		return v1.Subnet{
+			ID:   *ec2subnet.SubnetId,
+			Zone: *ec2subnet.AvailabilityZone,
+		}
+	})
+	nodeClass.Status.AMIs = []v1.AMI{
+		{
+			ID:   coretest.RandomName(),
+			Name: coretest.RandomName(),
+			Requirements: []corev1.NodeSelectorRequirement{
+				{
+					Key:      corev1.LabelArchStable,
+					Operator: corev1.NodeSelectorOpIn,
+					Values:   []string{karpv1.ArchitectureAmd64},
+				},
+			},
+		},
+		{
+			ID:   coretest.RandomName(),
+			Name: coretest.RandomName(),
+			Requirements: []corev1.NodeSelectorRequirement{
+				{
+					Key:      corev1.LabelArchStable,
+					Operator: corev1.NodeSelectorOpIn,
+					Values:   []string{karpv1.ArchitectureArm64},
+				},
+			},
+		},
+	}
+	instanceTypes, err := instanceTypeProvider.List(ctx, &v1.KubeletConfiguration{}, nodeClass)
+
+	// See how many launch templates we get by constraining our instance types to just be "c", "m", and "r"
+	reqs := scheduling.NewRequirements(scheduling.NewRequirement(v1.LabelInstanceCategory, corev1.NodeSelectorOpIn, "c", "m", "r"))
+	instanceTypes = lo.Filter(instanceTypes, func(it *cloudprovider.InstanceType, _ int) bool {
+		return it.Requirements.Compatible(reqs) == nil
+	})
+	fmt.Printf("Got %d instance types after filtering\n", len(instanceTypes))
+
+	resolver := amifamily.NewResolver()
+	launchTemplates, err := resolver.Resolve(nodeClass, &karpv1.NodeClaim{}, lo.Slice(instanceTypes, 0, 60), karpv1.CapacityTypeOnDemand, &amifamily.Options{InstanceStorePolicy: lo.ToPtr(v1.InstanceStorePolicyRAID0)})
+
+	if err != nil {
+		log.Fatalf("resolving launchTemplates, %s", err)
+	}
+	fmt.Printf("Got %d launch templates back from the resolver\n", len(launchTemplates))
+}

pkg/operator/operator.go

@@ -143,7 +143,7 @@ func NewOperator(ctx context.Context, operator *operator.Operator) (context.Cont
 	versionProvider := version.NewDefaultProvider(operator.KubernetesInterface, cache.New(awscache.DefaultTTL, awscache.DefaultCleanupInterval))
 	ssmProvider := ssmp.NewDefaultProvider(ssm.New(sess), cache.New(awscache.SSMGetParametersByPathTTL, awscache.DefaultCleanupInterval))
 	amiProvider := amifamily.NewDefaultProvider(versionProvider, ssmProvider, ec2api, cache.New(awscache.DefaultTTL, awscache.DefaultCleanupInterval))
-	amiResolver := amifamily.NewResolver(amiProvider)
+	amiResolver := amifamily.NewResolver()
 	launchTemplateProvider := launchtemplate.NewDefaultProvider(
 		ctx,
 		cache.New(awscache.DefaultTTL, awscache.DefaultCleanupInterval),

pkg/providers/amifamily/resolver.go

@@ -42,9 +42,7 @@ var DefaultEBS = v1.BlockDevice{
 }
 
 // Resolver is able to fill-in dynamic launch template parameters
-type Resolver struct {
-	amiProvider Provider
-}
+type Resolver struct{}
 
 // Options define the static launch template parameters
 type Options struct {
@@ -112,10 +110,8 @@ func (d DefaultFamily) FeatureFlags() FeatureFlags {
 }
 
 // NewResolver constructs a new launch template Resolver
-func NewResolver(amiProvider Provider) *Resolver {
-	return &Resolver{
-		amiProvider: amiProvider,
-	}
+func NewResolver() *Resolver {
+	return &Resolver{}
 }
 
 // Resolve generates launch templates using the static options and dynamically generates launch template parameters.

pkg/test/environment.go

@@ -109,7 +109,7 @@ func NewEnvironment(ctx context.Context, env *coretest.Environment) *Environment
 	instanceProfileProvider := instanceprofile.NewDefaultProvider(fake.DefaultRegion, iamapi, instanceProfileCache)
 	ssmProvider := ssmp.NewDefaultProvider(ssmapi, ssmCache)
 	amiProvider := amifamily.NewDefaultProvider(versionProvider, ssmProvider, ec2api, ec2Cache)
-	amiResolver := amifamily.NewResolver(amiProvider)
+	amiResolver := amifamily.NewResolver()
 	instanceTypesProvider := instancetype.NewDefaultProvider(fake.DefaultRegion, instanceTypeCache, ec2api, subnetProvider, unavailableOfferingsCache, pricingProvider)
 	launchTemplateProvider :=
 		launchtemplate.NewDefaultProvider(