add AWSMachineTemplate NodeInfo

Author: LiangquanLi930

api/v1beta1/awsmachine_conversion.go

@@ -129,6 +129,9 @@ func (r *AWSMachineTemplate) ConvertTo(dstRaw conversion.Hub) error {
 		}
 	}
 
+	// Restore Status fields that don't exist in v1beta1.
+	dst.Status.NodeInfo = restored.Status.NodeInfo
+
 	return nil
 }
 

api/v1beta1/conversion.go

@@ -103,3 +103,10 @@ func Convert_v1beta2_S3Bucket_To_v1beta1_S3Bucket(in *v1beta2.S3Bucket, out *S3B
 func Convert_v1beta2_Ignition_To_v1beta1_Ignition(in *v1beta2.Ignition, out *Ignition, s conversion.Scope) error {
 	return autoConvert_v1beta2_Ignition_To_v1beta1_Ignition(in, out, s)
 }
+
+// Convert_v1beta2_AWSMachineTemplateStatus_To_v1beta1_AWSMachineTemplateStatus converts v1beta2 AWSMachineTemplateStatus to v1beta1.
+// The NodeInfo field is dropped during conversion as it doesn't exist in v1beta1.
+func Convert_v1beta2_AWSMachineTemplateStatus_To_v1beta1_AWSMachineTemplateStatus(in *v1beta2.AWSMachineTemplateStatus, out *AWSMachineTemplateStatus, s conversion.Scope) error {
+	// NodeInfo field is ignored (dropped) as it doesn't exist in v1beta1
+	return autoConvert_v1beta2_AWSMachineTemplateStatus_To_v1beta1_AWSMachineTemplateStatus(in, out, s)
+}

api/v1beta1/zz_generated.conversion.go

@@ -23,13 +23,43 @@ import (
 	clusterv1 "sigs.k8s.io/cluster-api/api/v1beta1"
 )
 
+// Architecture represents the CPU architecture of the node.
+// Its underlying type is a string and its value can be any of amd64, arm64.
+// +kubebuilder:validation:Enum=amd64;arm64
+// +enum
+type Architecture string
+
+// Architecture constants.
+const (
+	ArchitectureAmd64 Architecture = "amd64"
+	ArchitectureArm64 Architecture = "arm64"
+)
+
+// NodeInfo contains information about the node's architecture and operating system.
+type NodeInfo struct {
+	// Architecture is the CPU architecture of the node.
+	// Its underlying type is a string and its value can be any of amd64, arm64.
+	// +optional
+	Architecture Architecture `json:"architecture,omitempty"`
+	// OperatingSystem is a string representing the operating system of the node.
+	// This may be a string like 'linux' or 'windows'.
+	// +optional
+	OperatingSystem string `json:"operatingSystem,omitempty"`
+}
+
 // AWSMachineTemplateStatus defines a status for an AWSMachineTemplate.
 type AWSMachineTemplateStatus struct {
 	// Capacity defines the resource capacity for this machine.
 	// This value is used for autoscaling from zero operations as defined in:
 	// https://github.com/kubernetes-sigs/cluster-api/blob/main/docs/proposals/20210310-opt-in-autoscaling-from-zero.md
 	// +optional
 	Capacity corev1.ResourceList `json:"capacity,omitempty"`
+
+	// NodeInfo contains information about the node's architecture and operating system.
+	// This value is used for autoscaling from zero operations as defined in:
+	// https://github.com/kubernetes-sigs/cluster-api/blob/main/docs/proposals/20210310-opt-in-autoscaling-from-zero.md
+	// +optional
+	NodeInfo *NodeInfo `json:"nodeInfo,omitempty"`
 }
 
 // AWSMachineTemplateSpec defines the desired state of AWSMachineTemplate.

api/v1beta2/awsmachinetemplate_types.go

@@ -1134,6 +1134,26 @@ spec:
                   This value is used for autoscaling from zero operations as defined in:
                   https://github.com/kubernetes-sigs/cluster-api/blob/main/docs/proposals/20210310-opt-in-autoscaling-from-zero.md
                 type: object
+              nodeInfo:
+                description: |-
+                  NodeInfo contains information about the node's architecture and operating system.
+                  This value is used for autoscaling from zero operations as defined in:
+                  https://github.com/kubernetes-sigs/cluster-api/blob/main/docs/proposals/20210310-opt-in-autoscaling-from-zero.md
+                properties:
+                  architecture:
+                    description: |-
+                      Architecture is the CPU architecture of the node.
+                      Its underlying type is a string and its value can be any of amd64, arm64.
+                    enum:
+                    - amd64
+                    - arm64
+                    type: string
+                  operatingSystem:
+                    description: |-
+                      OperatingSystem is a string representing the operating system of the node.
+                      This may be a string like 'linux' or 'windows'.
+                    type: string
+                type: object
             type: object
         type: object
     served: true

api/v1beta2/zz_generated.deepcopy.go

@@ -18,6 +18,7 @@ package controllers
 
 import (
 	"context"
+	"strings"
 
 	"github.com/aws/aws-sdk-go-v2/service/ec2"
 	ec2types "github.com/aws/aws-sdk-go-v2/service/ec2/types"
@@ -67,8 +68,8 @@ func (r *AWSMachineTemplateReconciler) Reconcile(ctx context.Context, req ctrl.R
 		return ctrl.Result{}, err
 	}
 
-	// Skip if capacity is already set
-	if len(awsMachineTemplate.Status.Capacity) > 0 {
+	// Skip if capacity and nodeInfo are already set
+	if len(awsMachineTemplate.Status.Capacity) > 0 && awsMachineTemplate.Status.NodeInfo != nil {
 		return ctrl.Result{}, nil
 	}
 
@@ -98,21 +99,22 @@ func (r *AWSMachineTemplateReconciler) Reconcile(ctx context.Context, req ctrl.R
 		return ctrl.Result{}, nil
 	}
 
-	// Query instance type capacity
-	capacity, err := r.getInstanceTypeCapacity(ctx, globalScope, instanceType)
+	// Query instance type capacity and node info
+	capacity, nodeInfo, err := r.getInstanceTypeInfo(ctx, globalScope, awsMachineTemplate, instanceType)
 	if err != nil {
 		record.Warnf(awsMachineTemplate, "CapacityQueryFailed", "Failed to query capacity for instance type %q: %v", instanceType, err)
 		return ctrl.Result{}, nil
 	}
 
-	// Update status with capacity
+	// Update status with capacity and nodeInfo
 	awsMachineTemplate.Status.Capacity = capacity
+	awsMachineTemplate.Status.NodeInfo = nodeInfo
 
 	if err := r.Status().Update(ctx, awsMachineTemplate); err != nil {
 		return ctrl.Result{}, errors.Wrap(err, "failed to update AWSMachineTemplate status")
 	}
 
-	log.Info("Successfully populated capacity information", "instanceType", instanceType, "region", region, "capacity", capacity)
+	log.Info("Successfully populated capacity and nodeInfo", "instanceType", instanceType, "region", region, "capacity", capacity, "nodeInfo", nodeInfo)
 	return ctrl.Result{}, nil
 }
 
@@ -145,8 +147,8 @@ func (r *AWSMachineTemplateReconciler) getRegion(ctx context.Context, template *
 	return "", nil
 }
 
-// getInstanceTypeCapacity queries AWS EC2 API for instance type capacity.
-func (r *AWSMachineTemplateReconciler) getInstanceTypeCapacity(ctx context.Context, globalScope *scope.GlobalScope, instanceType string) (corev1.ResourceList, error) {
+// getInstanceTypeInfo queries AWS EC2 API for instance type capacity and node info.
+func (r *AWSMachineTemplateReconciler) getInstanceTypeInfo(ctx context.Context, globalScope *scope.GlobalScope, template *infrav1.AWSMachineTemplate, instanceType string) (corev1.ResourceList, *infrav1.NodeInfo, error) {
 	// Create EC2 client from global scope
 	ec2Client := ec2.NewFromConfig(globalScope.Session())
 
@@ -157,11 +159,11 @@ func (r *AWSMachineTemplateReconciler) getInstanceTypeCapacity(ctx context.Conte
 
 	result, err := ec2Client.DescribeInstanceTypes(ctx, input)
 	if err != nil {
-		return nil, errors.Wrapf(err, "failed to describe instance type %q", instanceType)
+		return nil, nil, errors.Wrapf(err, "failed to describe instance type %q", instanceType)
 	}
 
 	if len(result.InstanceTypes) == 0 {
-		return nil, errors.Errorf("no information found for instance type %q", instanceType)
+		return nil, nil, errors.Errorf("no information found for instance type %q", instanceType)
 	}
 
 	// Extract capacity information
@@ -178,7 +180,71 @@ func (r *AWSMachineTemplateReconciler) getInstanceTypeCapacity(ctx context.Conte
 		memoryBytes := *info.MemoryInfo.SizeInMiB * 1024 * 1024
 		resourceList[corev1.ResourceMemory] = *resource.NewQuantity(memoryBytes, resource.BinarySI)
 	}
-	return resourceList, nil
+
+	// Extract node info from AMI if available
+	nodeInfo := &infrav1.NodeInfo{}
+	amiID := template.Spec.Template.Spec.AMI.ID
+	if amiID != nil && *amiID != "" {
+		arch, os, err := r.getNodeInfoFromAMI(ctx, ec2Client, *amiID)
+		if err == nil {
+			if arch != "" {
+				nodeInfo.Architecture = arch
+			}
+			if os != "" {
+				nodeInfo.OperatingSystem = os
+			}
+		}
+	}
+
+	return resourceList, nodeInfo, nil
+}
+
+// getNodeInfoFromAMI queries the AMI to determine architecture and operating system.
+func (r *AWSMachineTemplateReconciler) getNodeInfoFromAMI(ctx context.Context, ec2Client *ec2.Client, amiID string) (infrav1.Architecture, string, error) {
+	input := &ec2.DescribeImagesInput{
+		ImageIds: []string{amiID},
+	}
+
+	result, err := ec2Client.DescribeImages(ctx, input)
+	if err != nil {
+		return "", "", errors.Wrapf(err, "failed to describe AMI %q", amiID)
+	}
+
+	if len(result.Images) == 0 {
+		return "", "", errors.Errorf("no information found for AMI %q", amiID)
+	}
+
+	image := result.Images[0]
+
+	// Get architecture from AMI
+	var arch infrav1.Architecture
+	switch image.Architecture {
+	case ec2types.ArchitectureValuesX8664:
+		arch = infrav1.ArchitectureAmd64
+	case ec2types.ArchitectureValuesArm64:
+		arch = infrav1.ArchitectureArm64
+	}
+
+	// Determine OS - check Platform field first (specifically for Windows identification)
+	var os string
+
+	// 1. Check Platform field (most reliable for Windows detection)
+	if image.Platform == ec2types.PlatformValuesWindows {
+		os = "windows"
+	}
+
+	// 2. Check PlatformDetails field (provides more detailed information)
+	if os == "" && image.PlatformDetails != nil {
+		platformDetails := strings.ToLower(*image.PlatformDetails)
+		switch {
+		case strings.Contains(platformDetails, "windows"):
+			os = "windows"
+		case strings.Contains(platformDetails, "linux"), strings.Contains(platformDetails, "unix"):
+			os = "linux"
+		}
+	}
+
+	return arch, os, nil
 }
 
 // SetupWithManager sets up the controller with the Manager.

config/crd/bases/infrastructure.cluster.x-k8s.io_awsmachinetemplates.yaml

@@ -187,17 +187,20 @@ func TestAWSMachineTemplateReconciler(t *testing.T) {
 		})
 	})
 
-	// Note: getInstanceTypeCapacity tests are skipped as they require EC2 client injection
+	// Note: getInstanceTypeInfo tests are skipped as they require EC2 client injection
 	// which would need significant refactoring. The function is tested indirectly through
 	// integration tests.
 
 	t.Run("Reconcile", func(t *testing.T) {
-		t.Run("should skip when capacity already set", func(t *testing.T) {
+		t.Run("should skip when capacity and nodeInfo already set", func(t *testing.T) {
 			g := NewWithT(t)
 			template := newAWSMachineTemplate("test-template")
 			template.Status.Capacity = corev1.ResourceList{
 				corev1.ResourceCPU: *resource.NewQuantity(2, resource.DecimalSI),
 			}
+			template.Status.NodeInfo = &infrav1.NodeInfo{
+				Architecture: infrav1.ArchitectureAmd64,
+			}
 
 			reconciler := &AWSMachineTemplateReconciler{
 				Client: newFakeClient(template),
@@ -211,6 +214,55 @@ func TestAWSMachineTemplateReconciler(t *testing.T) {
 			g.Expect(result.Requeue).To(BeFalse())
 		})
 
+		t.Run("should reconcile when capacity set but nodeInfo is not", func(t *testing.T) {
+			g := NewWithT(t)
+			template := newAWSMachineTemplate("test-template")
+			template.Status.Capacity = corev1.ResourceList{
+				corev1.ResourceCPU: *resource.NewQuantity(2, resource.DecimalSI),
+			}
+			template.OwnerReferences = []metav1.OwnerReference{
+				{
+					APIVersion: clusterv1.GroupVersion.String(),
+					Kind:       "Cluster",
+					Name:       "test-cluster",
+				},
+			}
+			cluster := &clusterv1.Cluster{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "test-cluster",
+					Namespace: "default",
+				},
+				Spec: clusterv1.ClusterSpec{
+					InfrastructureRef: &corev1.ObjectReference{
+						Kind:      "AWSCluster",
+						Name:      "test-aws-cluster",
+						Namespace: "default",
+					},
+				},
+			}
+			awsCluster := &infrav1.AWSCluster{
+				ObjectMeta: metav1.ObjectMeta{
+					Name:      "test-aws-cluster",
+					Namespace: "default",
+				},
+				Spec: infrav1.AWSClusterSpec{
+					Region: "us-west-2",
+				},
+			}
+
+			reconciler := &AWSMachineTemplateReconciler{
+				Client: newFakeClient(template, cluster, awsCluster),
+			}
+
+			// This will fail at AWS API call, but demonstrates that reconcile proceeds
+			result, err := reconciler.Reconcile(context.Background(), ctrl.Request{
+				NamespacedName: client.ObjectKeyFromObject(template),
+			})
+
+			g.Expect(err).To(BeNil())
+			g.Expect(result.Requeue).To(BeFalse())
+		})
+
 		t.Run("should skip when instance type is empty", func(t *testing.T) {
 			g := NewWithT(t)
 			template := newAWSMachineTemplate("test-template")

controllers/awsmachinetemplate_controller.go

@@ -360,15 +360,26 @@ var _ = ginkgo.Context("[unmanaged] [functional]", func() {
 			Expect(len(awsMachineTemplateList.Items)).To(BeNumerically(">", 0), "Expected at least one AWSMachineTemplate")
 
 			foundTemplateWithCapacity := false
+			foundTemplateWithNodeInfo := false
 			for _, template := range awsMachineTemplateList.Items {
 				if len(template.Status.Capacity) > 0 {
 					foundTemplateWithCapacity = true
 					ginkgo.By(fmt.Sprintf("AWSMachineTemplate %s has capacity populated: %v", template.Name, template.Status.Capacity))
 					Expect(template.Status.Capacity).To(HaveKey(corev1.ResourceCPU), "Expected CPU to be set in capacity")
 					Expect(template.Status.Capacity).To(HaveKey(corev1.ResourceMemory), "Expected Memory to be set in capacity")
 				}
+				if template.Status.NodeInfo != nil {
+					foundTemplateWithNodeInfo = true
+					ginkgo.By(fmt.Sprintf("AWSMachineTemplate %s has nodeInfo populated: %v", template.Name, template.Status.NodeInfo))
+					// Verify architecture is set (should be either amd64 or arm64 for AWS)
+					Expect(template.Status.NodeInfo.Architecture).ToNot(BeEmpty(), "Expected architecture to be set in nodeInfo")
+					Expect(string(template.Status.NodeInfo.Architecture)).To(MatchRegexp("^(amd64|arm64)$"), "Expected architecture to be amd64 or arm64")
+					// Verify operating system is set
+					Expect(template.Status.NodeInfo.OperatingSystem).ToNot(BeEmpty(), "Expected operatingSystem to be set in nodeInfo")
+				}
 			}
 			Expect(foundTemplateWithCapacity).To(BeTrue(), "Expected at least one AWSMachineTemplate to have capacity populated")
+			Expect(foundTemplateWithNodeInfo).To(BeTrue(), "Expected at least one AWSMachineTemplate to have nodeInfo populated")
 		})
 	})