refactor: extract vminstanceutils.go from vminstance.go and cloudprovider.go

Move VM utility functions into a dedicated vminstanceutils.go file:
- Priority maps (KarpCapacityTypeToVMPriority, VMPriorityToKarpCapacityType, VMPriorityToScaleSetPriority)
- Extension-related constants and helpers (aksIdentifyingExtensionName, GetManagedExtensionNames, isAKSIdentifyingExtensionEnabled)
- ErrorCodeForMetrics, ConvertToVirtualMachineIdentity, GetCapacityTypeFromVM, GetScaleSetPriorityLabelFromVM

Move vmInstanceToNodeClaim from CloudProvider to BuildNodeClaimFromVM in instance package,
paralleling BuildNodeClaimFromAKSMachine. Move GetNodeClaimNameFromVMName to instance package.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: comtalyst

pkg/cloudprovider/cloudprovider.go

@@ -21,15 +21,12 @@ import (
 	stderrors "errors"
 	"fmt"
 	"net/http"
-	"strings"
 	"sync"
 	"time"
 
 	"github.com/awslabs/operatorpkg/status"
 	corev1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/api/errors"
-	"k8s.io/apimachinery/pkg/api/resource"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"sigs.k8s.io/karpenter/pkg/controllers/nodeoverlay"
 
@@ -195,7 +192,7 @@ func (c *CloudProvider) createVMInstance(ctx context.Context, nodeClass *v1beta1
 	instanceType, _ := lo.Find(instanceTypes, func(i *cloudprovider.InstanceType) bool {
 		return i.Name == string(lo.FromPtr(vm.Properties.HardwareProfile.VMSize))
 	})
-	newNodeClaim, err := c.vmInstanceToNodeClaim(ctx, vm, instanceType)
+	newNodeClaim, err := instance.BuildNodeClaimFromVM(ctx, vm, instanceType)
 	if err != nil {
 		return nil, err
 	}
@@ -394,12 +391,12 @@ func (c *CloudProvider) List(ctx context.Context) ([]*karpv1.NodeClaim, error) {
 		return nil, fmt.Errorf("listing VM instances, %w", err)
 	}
 
-	for _, instance := range vmInstances {
-		instanceType, err := c.resolveInstanceTypeFromVMInstance(ctx, instance)
+	for _, vmInst := range vmInstances {
+		instanceType, err := c.resolveInstanceTypeFromVMInstance(ctx, vmInst)
 		if err != nil {
 			return nil, fmt.Errorf("resolving instance type for VM instance, %w", err)
 		}
-		nodeClaim, err := c.vmInstanceToNodeClaim(ctx, instance, instanceType)
+		nodeClaim, err := instance.BuildNodeClaimFromVM(ctx, vmInst, instanceType)
 		if err != nil {
 			return nil, fmt.Errorf("converting VM instance to node claim, %w", err)
 		}
@@ -434,7 +431,7 @@ func (c *CloudProvider) Get(ctx context.Context, providerID string) (*karpv1.Nod
 		if err != nil {
 			return nil, fmt.Errorf("resolving instance type, %w", err)
 		}
-		return c.vmInstanceToNodeClaim(ctx, vm, instanceType)
+		return instance.BuildNodeClaimFromVM(ctx, vm, instanceType)
 	}
 }
 
@@ -617,60 +614,6 @@ func (c *CloudProvider) resolveNodePoolFromVMInstance(ctx context.Context, vm *a
 	return nil, errors.NewNotFound(schema.GroupResource{Group: coreapis.Group, Resource: "nodepools"}, "")
 }
 
-func (c *CloudProvider) vmInstanceToNodeClaim(ctx context.Context, vm *armcompute.VirtualMachine, instanceType *cloudprovider.InstanceType) (*karpv1.NodeClaim, error) {
-	nodeClaim := &karpv1.NodeClaim{}
-	labels := map[string]string{}
-	annotations := map[string]string{}
-
-	if instanceType != nil {
-		labels = labelspkg.GetAllSingleValuedRequirementLabels(instanceType.Requirements)
-		nodeClaim.Status.Capacity = lo.PickBy(instanceType.Capacity, func(_ corev1.ResourceName, v resource.Quantity) bool { return !resources.IsZero(v) })
-		nodeClaim.Status.Allocatable = lo.PickBy(instanceType.Allocatable(), func(_ corev1.ResourceName, v resource.Quantity) bool { return !resources.IsZero(v) })
-	}
-
-	if zone, err := utils.MakeAKSLabelZoneFromVM(vm); err != nil {
-		log.FromContext(ctx).Info("failed to get zone for VM, zone label will be empty", "vmName", *vm.Name, "error", err)
-	} else {
-		labels[corev1.LabelTopologyZone] = zone
-	}
-
-	labels[karpv1.CapacityTypeLabelKey] = instance.GetCapacityTypeFromVM(vm)
-	labels[v1beta1.AKSLabelScaleSetPriority] = instance.GetScaleSetPriorityLabelFromVM(vm)
-
-	if tag, ok := vm.Tags[launchtemplate.NodePoolTagKey]; ok {
-		labels[karpv1.NodePoolLabelKey] = *tag
-	}
-
-	nodeClaim.Name = GetNodeClaimNameFromVMName(*vm.Name)
-	nodeClaim.Labels = labels
-	nodeClaim.Annotations = annotations
-	if vm.Properties != nil && vm.Properties.TimeCreated != nil {
-		nodeClaim.CreationTimestamp = metav1.Time{Time: *vm.Properties.TimeCreated}
-	} else {
-		// Fallback to current time to ensure garbage collection grace period is enforced
-		// when TimeCreated is unavailable. Without this, CreationTimestamp would be epoch (zero value)
-		// and the instance could be immediately garbage collected, bypassing the 5-minute grace period.
-		// TODO: Investigate a more fail-safe approach. If vm.Properties.TimeCreated is NEVER populated,
-		// this fallback means the VM will never be garbage collected since we call this helper every time
-		// we create an in-memory NodeClaim. We currently assume this shouldn't happen because VMs that fail
-		// to come up should eventually stop appearing in Azure API responses.
-		nodeClaim.CreationTimestamp = metav1.Time{Time: time.Now()}
-	}
-	// Set the deletionTimestamp to be the current time if the instance is currently terminating
-	if utils.IsVMDeleting(*vm) {
-		nodeClaim.DeletionTimestamp = &metav1.Time{Time: time.Now()}
-	}
-	nodeClaim.Status.ProviderID = utils.VMResourceIDToProviderID(ctx, *vm.ID)
-	if vm.Properties != nil && vm.Properties.StorageProfile != nil && vm.Properties.StorageProfile.ImageReference != nil {
-		nodeClaim.Status.ImageID = utils.ImageReferenceToString(vm.Properties.StorageProfile.ImageReference)
-	}
-	return nodeClaim, nil
-}
-
-func GetNodeClaimNameFromVMName(vmName string) string {
-	return strings.TrimPrefix(vmName, "aks-")
-}
-
 const truncateAt = 1200
 
 func isNodeClaimStandalone(nodeClaim *karpv1.NodeClaim) bool {

pkg/cloudprovider/cloudprovider_test.go

@@ -25,6 +25,8 @@ import (
 	. "github.com/onsi/gomega"
 	"github.com/samber/lo"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+
+	"github.com/Azure/karpenter-provider-azure/pkg/providers/instance"
 )
 
 func TestGenerateNodeClaimName(t *testing.T) {
@@ -54,13 +56,13 @@ func TestGenerateNodeClaimName(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			g := NewWithT(t)
 
-			result := GetNodeClaimNameFromVMName(tt.vmName)
+			result := instance.GetNodeClaimNameFromVMName(tt.vmName)
 			g.Expect(result).To(Equal(tt.expected))
 		})
 	}
 }
 
-func TestVmInstanceToNodeClaim_NilProperties(t *testing.T) {
+func TestBuildNodeClaimFromVM_NilProperties(t *testing.T) {
 	tests := []struct {
 		name                string
 		vm                  *armcompute.VirtualMachine
@@ -102,9 +104,8 @@ func TestVmInstanceToNodeClaim_NilProperties(t *testing.T) {
 			g := NewWithT(t)
 			ctx := context.Background()
 
-			cp := &CloudProvider{}
 			before := time.Now()
-			nodeClaim, err := cp.vmInstanceToNodeClaim(ctx, tt.vm, nil)
+			nodeClaim, err := instance.BuildNodeClaimFromVM(ctx, tt.vm, nil)
 			after := time.Now()
 
 			g.Expect(err).ToNot(HaveOccurred())

pkg/cloudprovider/suite_drift_test.go

@@ -36,6 +36,7 @@ import (
 	"github.com/Azure/karpenter-provider-azure/pkg/apis/v1beta1"
 	"github.com/Azure/karpenter-provider-azure/pkg/fake"
 	"github.com/Azure/karpenter-provider-azure/pkg/operator/options"
+	"github.com/Azure/karpenter-provider-azure/pkg/providers/instance"
 	"github.com/Azure/karpenter-provider-azure/pkg/test"
 	. "github.com/Azure/karpenter-provider-azure/pkg/test/expectations"
 )
@@ -352,7 +353,7 @@ var _ = Describe("CloudProvider", func() {
 				Expect(azureEnv.VirtualMachinesAPI.VirtualMachineCreateOrUpdateBehavior.CalledWithInput.Len()).To(Equal(1))
 				input := azureEnv.VirtualMachinesAPI.VirtualMachineCreateOrUpdateBehavior.CalledWithInput.Pop()
 				// Corresponding NodeClaim - fetch from API server so it has all status fields (including ImageID)
-				nodeClaimName := GetNodeClaimNameFromVMName(input.VMName)
+				nodeClaimName := instance.GetNodeClaimNameFromVMName(input.VMName)
 				driftNodeClaim = &karpv1.NodeClaim{}
 				Expect(env.Client.Get(ctx, types.NamespacedName{Name: nodeClaimName}, driftNodeClaim)).To(Succeed())
 				// ExpectProvisioned doesn't set Status.NodeName

pkg/providers/instance/vminstance.go

@@ -31,7 +31,6 @@ import (
 	"github.com/samber/lo"
 	v1 "k8s.io/api/core/v1"
 	"k8s.io/apimachinery/pkg/util/sets"
-	azureclouds "sigs.k8s.io/cloud-provider-azure/pkg/azclient"
 	"sigs.k8s.io/controller-runtime/pkg/log"
 	karpv1 "sigs.k8s.io/karpenter/pkg/apis/v1"
 	corecloudprovider "sigs.k8s.io/karpenter/pkg/cloudprovider"
@@ -54,71 +53,6 @@ import (
 	"github.com/Azure/karpenter-provider-azure/pkg/utils"
 )
 
-var (
-	KarpCapacityTypeToVMPriority = map[string]armcompute.VirtualMachinePriorityTypes{
-		karpv1.CapacityTypeSpot:     armcompute.VirtualMachinePriorityTypesSpot,
-		karpv1.CapacityTypeOnDemand: armcompute.VirtualMachinePriorityTypesRegular,
-	}
-	VMPriorityToKarpCapacityType = map[armcompute.VirtualMachinePriorityTypes]string{
-		armcompute.VirtualMachinePriorityTypesSpot:    karpv1.CapacityTypeSpot,
-		armcompute.VirtualMachinePriorityTypesRegular: karpv1.CapacityTypeOnDemand,
-	}
-	// Note that there is no ScaleSetPriorityToKarpCapacityType because the karpenter.sh/capacity-type
-	// label is the "official" label that we actually key priority off of. Selection still works though
-	// because when we list instance types on-demand offerings always have v1beta1.ScaleSetPriorityRegular
-	// and spot instances always have v1beta1.ScaleSetPrioritySpot, so the correct karpenter.sh/capacity-type
-	// label is still selected even if the user is using kubernetes.azure.com/scalesetpriority only on the NodePool.
-	VMPriorityToScaleSetPriority = map[armcompute.VirtualMachinePriorityTypes]string{
-		armcompute.VirtualMachinePriorityTypesSpot:    v1beta1.ScaleSetPrioritySpot,
-		armcompute.VirtualMachinePriorityTypesRegular: v1beta1.ScaleSetPriorityRegular,
-	}
-
-	aksIdentifyingExtensionEnvs = sets.New(
-		azureclouds.PublicCloud.Name,
-		azureclouds.ChinaCloud.Name,
-		azureclouds.USGovernmentCloud.Name,
-	)
-)
-
-const (
-	aksIdentifyingExtensionName = "computeAksLinuxBilling"
-	// TODO: Why bother with a different CSE name for Windows?
-	cseNameWindows = "windows-cse-agent-karpenter"
-	cseNameLinux   = "cse-agent-karpenter"
-)
-
-// ErrorCodeForMetrics extracts a stable Azure error code for metric labeling when possible.
-func ErrorCodeForMetrics(err error) string {
-	if err == nil {
-		return "UnknownError"
-	}
-	if azErr := sdkerrors.IsResponseError(err); azErr != nil {
-		if azErr.ErrorCode != "" {
-			return azErr.ErrorCode
-		}
-		return "UnknownError"
-	}
-	return "UnknownError"
-}
-
-// GetManagedExtensionNames gets the names of the VM extensions managed by Karpenter.
-// This is a set of 1 or 2 extensions (depending on provisionMode): aksIdentifyingExtension and (sometimes) cse.
-func GetManagedExtensionNames(provisionMode string, env *auth.Environment) []string {
-	var result []string
-	// Only including AKS identifying extension in the clouds it is supported in
-	if isAKSIdentifyingExtensionEnabled(env) {
-		result = append(result, aksIdentifyingExtensionName)
-	}
-	if provisionMode == consts.ProvisionModeBootstrappingClient {
-		result = append(result, cseNameLinux) // TODO: Windows
-	}
-	return result
-}
-
-func isAKSIdentifyingExtensionEnabled(env *auth.Environment) bool {
-	return aksIdentifyingExtensionEnvs.Has(env.Environment.Name)
-}
-
 type Resource = map[string]interface{}
 
 type VirtualMachinePromise struct {
@@ -1053,36 +987,3 @@ func (p *DefaultVMProvider) getCSExtension(cse string, isWindows bool, tags map[
 		Tags: tags,
 	}
 }
-
-func ConvertToVirtualMachineIdentity(nodeIdentities []string) *armcompute.VirtualMachineIdentity {
-	var identity *armcompute.VirtualMachineIdentity
-	if len(nodeIdentities) > 0 {
-		identityMap := make(map[string]*armcompute.UserAssignedIdentitiesValue)
-		for _, identityID := range nodeIdentities {
-			identityMap[identityID] = &armcompute.UserAssignedIdentitiesValue{}
-		}
-
-		if len(identityMap) > 0 {
-			identity = &armcompute.VirtualMachineIdentity{
-				Type:                   lo.ToPtr(armcompute.ResourceIdentityTypeUserAssigned),
-				UserAssignedIdentities: identityMap,
-			}
-		}
-	}
-
-	return identity
-}
-
-func GetCapacityTypeFromVM(vm *armcompute.VirtualMachine) string {
-	if vm != nil && vm.Properties != nil && vm.Properties.Priority != nil {
-		return VMPriorityToKarpCapacityType[*vm.Properties.Priority]
-	}
-	return ""
-}
-
-func GetScaleSetPriorityLabelFromVM(vm *armcompute.VirtualMachine) string {
-	if vm != nil && vm.Properties != nil && vm.Properties.Priority != nil {
-		return VMPriorityToScaleSetPriority[*vm.Properties.Priority]
-	}
-	return ""
-}