feat: further parity with AKS from AKS machine API integration/provision mode

Author: comtalyst

Makefile-az.mk

@@ -11,7 +11,7 @@ else
 endif
 
 AZURE_ACR_SUFFIX ?= azurecr.io
-AZURE_SIG_SUBSCRIPTION_ID ?= $(AZURE_SUBSCRIPTION_ID)
+AZURE_SIG_SUBSCRIPTION_ID ?= 10945678-1234-1234-1234-123456789012
 AZURE_CLUSTER_NAME ?= $(COMMON_NAME)
 AZURE_RESOURCE_GROUP_MC = MC_$(AZURE_RESOURCE_GROUP)_$(AZURE_CLUSTER_NAME)_$(AZURE_LOCATION)
 
@@ -22,6 +22,8 @@ KARPENTER_FEDERATED_IDENTITY_CREDENTIAL_NAME ?= KARPENTER_FID
 CUSTOM_VNET_NAME ?= $(AZURE_CLUSTER_NAME)-vnet
 CUSTOM_SUBNET_NAME ?= nodesubnet
 
+AKS_MACHINES_POOL_NAME ?= testmpool
+
 .DEFAULT_GOAL := help	# make without arguments will show help
 
 az-all:              az-login az-create-workload-msi az-mkaks-cilium      az-create-federated-cred az-perm               az-perm-acr az-configure-values             az-build az-run          az-run-sample ## Provision the infra (ACR,AKS); build and deploy Karpenter; deploy sample Provisioner and workload
@@ -30,6 +32,8 @@ az-all-cniv1:        az-login az-create-workload-msi az-mkaks-cniv1       az-cre
 
 az-all-cni-overlay:  az-login az-create-workload-msi az-mkaks-overlay     az-create-federated-cred az-perm               az-perm-acr az-configure-values             az-build az-run          az-run-sample ## Provision the infra (ACR,AKS); build and deploy Karpenter; deploy sample Provisioner and workload
 
+az-all-aksmachine:   az-login az-create-workload-msi az-mkaks-cilium      az-create-federated-cred az-perm               az-perm-acr az-perm-aksmachine             az-add-aksmachinespool az-configure-values-aksmachine             az-build az-run          az-run-sample 
+
 az-all-perftest:     az-login az-create-workload-msi az-mkaks-perftest    az-create-federated-cred az-perm               az-perm-acr az-configure-values
 	$(MAKE) az-mon-deploy
 	$(MAKE) az-pprof-enable
@@ -135,12 +139,18 @@ az-mkaks-savm: az-mkrg ## Create experimental cluster with standalone VMs (+ ACR
 	az aks get-credentials --resource-group $(AZURE_RESOURCE_GROUP) --name $(AZURE_CLUSTER_NAME) --overwrite-existing
 	skaffold config set default-repo $(AZURE_ACR_NAME).$(AZURE_ACR_SUFFIX)/karpenter
 
+az-add-aksmachinespool:
+	hack/deploy/add-aks-machines-pool.sh $(AZURE_SUBSCRIPTION_ID) $(AZURE_RESOURCE_GROUP) $(AZURE_CLUSTER_NAME) $(AKS_MACHINES_POOL_NAME)
+
 az-rmrg: ## Destroy test ACR and AKS cluster by deleting the resource group (use with care!)
 	az group delete --name $(AZURE_RESOURCE_GROUP)
 
 az-configure-values:  ## Generate cluster-related values for Karpenter Helm chart
 	hack/deploy/configure-values.sh $(AZURE_CLUSTER_NAME) $(AZURE_RESOURCE_GROUP) $(KARPENTER_SERVICE_ACCOUNT_NAME) $(AZURE_KARPENTER_USER_ASSIGNED_IDENTITY_NAME)
 
+az-configure-values-aksmachine:  ## Generate cluster-related values for Karpenter Helm chart
+	hack/deploy/configure-values.sh $(AZURE_CLUSTER_NAME) $(AZURE_RESOURCE_GROUP) $(KARPENTER_SERVICE_ACCOUNT_NAME) $(AZURE_KARPENTER_USER_ASSIGNED_IDENTITY_NAME) aksmachineapi $(AKS_MACHINES_POOL_NAME)
+
 az-mkvmssflex: ## Create VMSS Flex (optional, only if creating VMs referencing this VMSS)
 	az vmss create --name $(AZURE_CLUSTER_NAME)-vmss --resource-group $(AZURE_RESOURCE_GROUP_MC) --location $(AZURE_LOCATION) \
 		--instance-count 0 --orchestration-mode Flexible --platform-fault-domain-count 1 --zones 1 2 3
@@ -156,6 +166,15 @@ az-perm: ## Create role assignments to let Karpenter manage VMs and Network
 	az role assignment create --assignee-object-id $(KARPENTER_USER_ASSIGNED_CLIENT_ID) --assignee-principal-type "ServicePrincipal" --scope /subscriptions/$(AZURE_SUBSCRIPTION_ID)/resourceGroups/$(AZURE_RESOURCE_GROUP_MC) --role "Managed Identity Operator"
 	@echo Consider "make az-configure-values"!
 
+az-perm-aksmachine: ## Create role assignments for AKS machine API operations
+	$(eval KARPENTER_USER_ASSIGNED_CLIENT_ID=$(shell az identity show --resource-group "${AZURE_RESOURCE_GROUP}" --name "${AZURE_KARPENTER_USER_ASSIGNED_IDENTITY_NAME}" --query 'principalId' -otsv))
+	az role assignment create --assignee-object-id $(KARPENTER_USER_ASSIGNED_CLIENT_ID) --assignee-principal-type "ServicePrincipal" --scope /subscriptions/$(AZURE_SUBSCRIPTION_ID)/resourceGroups/$(AZURE_RESOURCE_GROUP) --role "Azure Kubernetes Service Contributor Role"
+	az role assignment create --assignee-object-id $(KARPENTER_USER_ASSIGNED_CLIENT_ID) --assignee-principal-type "ServicePrincipal" --scope /subscriptions/$(AZURE_SUBSCRIPTION_ID)/resourceGroups/$(AZURE_RESOURCE_GROUP_MC) --role "Network Contributor"
+	$(eval CLUSTER_IDENTITY=$(shell az aks show --resource-group "${AZURE_RESOURCE_GROUP}" --name "${AZURE_CLUSTER_NAME}" --query 'identity.principalId' -otsv))
+	az role assignment create --assignee-object-id $(CLUSTER_IDENTITY) --assignee-principal-type "ServicePrincipal" --scope /subscriptions/$(AZURE_SUBSCRIPTION_ID)/resourceGroups/$(AZURE_RESOURCE_GROUP_MC) --role "Virtual Machine Contributor"
+	az role assignment create --assignee-object-id $(CLUSTER_IDENTITY) --assignee-principal-type "ServicePrincipal" --scope /subscriptions/$(AZURE_SUBSCRIPTION_ID)/resourceGroups/$(AZURE_RESOURCE_GROUP_MC) --role "Network Contributor"
+	az role assignment create --assignee-object-id $(CLUSTER_IDENTITY) --assignee-principal-type "ServicePrincipal" --scope /subscriptions/$(AZURE_SUBSCRIPTION_ID)/resourceGroups/$(AZURE_RESOURCE_GROUP_MC) --role "Managed Identity Operator"
+
 az-perm-sig: ## Create role assignments when testing with SIG images
 	$(eval KARPENTER_USER_ASSIGNED_CLIENT_ID=$(shell az identity show --resource-group "${AZURE_RESOURCE_GROUP}" --name "${AZURE_KARPENTER_USER_ASSIGNED_IDENTITY_NAME}" --query 'principalId' -otsv))
 	az role assignment create --assignee-object-id $(KARPENTER_USER_ASSIGNED_CLIENT_ID) --assignee-principal-type "ServicePrincipal" --role "Reader" --scope /subscriptions/$(AZURE_SIG_SUBSCRIPTION_ID)/resourceGroups/AKS-Ubuntu/providers/Microsoft.Compute/galleries/AKSUbuntu

hack/deploy/configure-values.sh

@@ -3,8 +3,8 @@ set -euo pipefail
 # This script interrogates the AKS cluster and Azure resources to generate
 # the karpenter-values.yaml file using the karpenter-values-template.yaml file as a template.
 
-if [ "$#" -ne 4 ]; then
-    echo "Usage: $0 <cluster-name> <resource-group> <karpenter-service-account-name> <karpenter-user-assigned-identity-name>"
+if [ "$#" -lt 4 ] || [ "$#" -gt 6 ]; then
+    echo "Usage: $0 <cluster-name> <resource-group> <karpenter-service-account-name> <karpenter-user-assigned-identity-name> [provision-mode] [aks-machines-pool-name]"
     exit 1
 fi
 
@@ -14,6 +14,8 @@ CLUSTER_NAME=$1
 AZURE_RESOURCE_GROUP=$2
 KARPENTER_SERVICE_ACCOUNT_NAME=$3
 AZURE_KARPENTER_USER_ASSIGNED_IDENTITY_NAME=$4
+PROVISION_MODE=${5:-}
+AKS_MACHINES_POOL_NAME=${6:-testmpool}
 
 # Optional values through env vars:
 LOG_LEVEL=${LOG_LEVEL:-"info"}
@@ -68,9 +70,15 @@ NODE_IDENTITIES=$(jq -r ".identityProfile.kubeletidentity.resourceId" <<< "$AKS_
 KARPENTER_USER_ASSIGNED_CLIENT_ID=$(az identity show --resource-group "${AZURE_RESOURCE_GROUP}" --name "${AZURE_KARPENTER_USER_ASSIGNED_IDENTITY_NAME}" --query 'clientId' -otsv)
 KUBELET_IDENTITY_CLIENT_ID=$(jq -r ".identityProfile.kubeletidentity.clientId // empty" <<< "$AKS_JSON")
 
-export CLUSTER_NAME AZURE_LOCATION AZURE_RESOURCE_GROUP_MC KARPENTER_SERVICE_ACCOUNT_NAME \
+# For Machine API mode
+if [[ "${PROVISION_MODE:-}" == "aksmachineapi" ]]; then
+    USE_SIG="true"
+    AZURE_SIG_SUBSCRIPTION_ID=109a5e88-712a-48ae-9078-9ca8b3c81345
+fi
+
+export CLUSTER_NAME AZURE_LOCATION AZURE_RESOURCE_GROUP AZURE_RESOURCE_GROUP_MC KARPENTER_SERVICE_ACCOUNT_NAME \
     CLUSTER_ENDPOINT BOOTSTRAP_TOKEN SSH_PUBLIC_KEY VNET_SUBNET_ID KARPENTER_USER_ASSIGNED_CLIENT_ID NODE_IDENTITIES AZURE_SUBSCRIPTION_ID NETWORK_PLUGIN NETWORK_PLUGIN_MODE NETWORK_POLICY \
-    LOG_LEVEL VNET_GUID KUBELET_IDENTITY_CLIENT_ID
+    LOG_LEVEL VNET_GUID KUBELET_IDENTITY_CLIENT_ID PROVISION_MODE USE_SIG AZURE_SIG_SUBSCRIPTION_ID AKS_MACHINES_POOL_NAME
 
 # get karpenter-values-template.yaml, if not already present (e.g. outside of repo context)
 if [ ! -f karpenter-values-template.yaml ]; then

karpenter-values-template.yaml

@@ -42,13 +42,19 @@ controller:
 
     # managed karpenter settings
     - name: USE_SIG
-      value: "false"
+      value: "${USE_SIG}"
     - name: SIG_ACCESS_TOKEN_SERVER_URL
       value: ""
     - name: SIG_ACCESS_TOKEN_SCOPE
       value: ""
     - name: SIG_SUBSCRIPTION_ID
-      value: ""
+      value: "${AZURE_SIG_SUBSCRIPTION_ID}"
+    - name: PROVISION_MODE
+      value: ${PROVISION_MODE}
+    - name: AKS_MACHINES_POOL_NAME
+      value: "${AKS_MACHINES_POOL_NAME}"
+    - name: ARM_RESOURCE_GROUP
+      value: ${AZURE_RESOURCE_GROUP}
 serviceAccount:
   name: ${KARPENTER_SERVICE_ACCOUNT_NAME}
   annotations:

pkg/apis/v1beta1/labels.go

@@ -99,6 +99,7 @@ var (
 
 	AnnotationAKSNodeClassHash        = apis.Group + "/aksnodeclass-hash"
 	AnnotationAKSNodeClassHashVersion = apis.Group + "/aksnodeclass-hash-version"
+	AnnotationAKSMachineResourceID    = apis.Group + "/aks-machine-resource-id" // resource ID of the associated AKS machine
 )
 
 const (

pkg/cloudprovider/cloudprovider.go

@@ -38,9 +38,11 @@ import (
 
 	// nolint SA1019 - deprecated package
 	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/compute/armcompute/v5"
+	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice/v7"
 
 	"github.com/Azure/karpenter-provider-azure/pkg/apis"
 	"github.com/Azure/karpenter-provider-azure/pkg/apis/v1beta1"
+	"github.com/Azure/karpenter-provider-azure/pkg/consts"
 	"github.com/Azure/karpenter-provider-azure/pkg/controllers/nodeclaim/inplaceupdate"
 	"github.com/Azure/karpenter-provider-azure/pkg/operator/options"
 
@@ -74,26 +76,29 @@ const (
 var _ cloudprovider.CloudProvider = (*CloudProvider)(nil)
 
 type CloudProvider struct {
-	instanceTypeProvider instancetype.Provider
-	vmInstanceProvider   instance.VMProvider
-	kubeClient           client.Client
-	imageProvider        imagefamily.NodeImageProvider
-	recorder             events.Recorder
+	instanceTypeProvider       instancetype.Provider
+	vmInstanceProvider         instance.VMProvider // Note that even when provision mode does not create with VM instance provider, it is still being used to handle existing VM instances.
+	aksMachineInstanceProvider instance.AKSMachineProvider
+	kubeClient                 client.Client
+	imageProvider              imagefamily.NodeImageProvider
+	recorder                   events.Recorder
 }
 
 func New(
 	instanceTypeProvider instancetype.Provider,
 	vmInstanceProvider instance.VMProvider,
+	aksMachineInstanceProvider instance.AKSMachineProvider,
 	recorder events.Recorder,
 	kubeClient client.Client,
 	imageProvider imagefamily.NodeImageProvider,
 ) *CloudProvider {
 	return &CloudProvider{
-		instanceTypeProvider: instanceTypeProvider,
-		vmInstanceProvider:   vmInstanceProvider,
-		kubeClient:           kubeClient,
-		imageProvider:        imageProvider,
-		recorder:             recorder,
+		instanceTypeProvider:       instanceTypeProvider,
+		vmInstanceProvider:         vmInstanceProvider,
+		aksMachineInstanceProvider: aksMachineInstanceProvider,
+		kubeClient:                 kubeClient,
+		imageProvider:              imageProvider,
+		recorder:                   recorder,
 	}
 }
 
@@ -147,6 +152,11 @@ func (c *CloudProvider) Create(ctx context.Context, nodeClaim *karpv1.NodeClaim)
 		return nil, cloudprovider.NewInsufficientCapacityError(fmt.Errorf("all requested instance types were unavailable during launch"))
 	}
 
+	// Choose provider based on provision mode
+	if options.FromContext(ctx).ProvisionMode == consts.ProvisionModeAKSMachineAPI {
+		return c.createAKSMachineInstance(ctx, nodeClass, nodeClaim, instanceTypes)
+	}
+
 	return c.createVMInstance(ctx, nodeClass, nodeClaim, instanceTypes)
 }
 
@@ -175,6 +185,39 @@ func (c *CloudProvider) createVMInstance(ctx context.Context, nodeClass *v1beta1
 	return newNodeClaim, nil
 }
 
+func (c *CloudProvider) createAKSMachineInstance(ctx context.Context, nodeClass *v1beta1.AKSNodeClass, nodeClaim *karpv1.NodeClaim, instanceTypes []*cloudprovider.InstanceType) (*karpv1.NodeClaim, error) {
+	// Begin the creation of the instance
+	aksMachinePromise, err := c.aksMachineInstanceProvider.BeginCreate(ctx, nodeClass, nodeClaim, instanceTypes)
+	if err != nil {
+		return nil, cloudprovider.NewCreateError(fmt.Errorf("creating AKS machine failed, %w", err), CreateInstanceFailedReason, truncateMessage(err.Error()))
+	}
+
+	// Handle the promise
+	if err := c.handleInstancePromise(ctx, aksMachinePromise, nodeClaim); err != nil {
+		return nil, err
+	}
+
+	// Convert the AKS machine to a NodeClaim
+	newNodeClaim, err := instance.BuildNodeClaimFromAKSMachineTemplate(
+		ctx, aksMachinePromise.AKSMachineTemplate,
+		aksMachinePromise.InstanceType,
+		aksMachinePromise.CapacityType,
+		lo.ToPtr(aksMachinePromise.Zone),
+		aksMachinePromise.AKSMachineID,
+		aksMachinePromise.VMResourceID,
+		false,
+		aksMachinePromise.AKSMachineNodeImageVersion)
+	if err != nil {
+		return nil, fmt.Errorf("failed to build NodeClaim from AKS machine template, %w", err)
+	}
+
+	if err := setAdditionalAnnotationsForNewNodeClaim(ctx, newNodeClaim, nodeClass); err != nil {
+		return nil, err
+	}
+
+	return newNodeClaim, nil
+}
+
 // handleInstancePromise handles the instance promise, primarily deciding on sync/async provisioning.
 func (c *CloudProvider) handleInstancePromise(ctx context.Context, instancePromise instance.InstancePromise, nodeClaim *karpv1.NodeClaim) error {
 	if isNodeClaimStandalone(nodeClaim) {
@@ -270,12 +313,29 @@ func (c *CloudProvider) waitUntilLaunched(ctx context.Context, nodeClaim *karpv1
 }
 
 func (c *CloudProvider) List(ctx context.Context) ([]*karpv1.NodeClaim, error) {
+	var nodeClaims []*karpv1.NodeClaim
+
+	// List AKS machine-based nodes
+	aksMachineInstances, err := c.aksMachineInstanceProvider.List(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("listing AKS machine instances, %w", err)
+	}
+
+	for _, aksMachineInstance := range aksMachineInstances {
+		nodeClaim, err := c.resolveNodeClaimFromAKSMachine(ctx, aksMachineInstance)
+		if err != nil {
+			return nil, fmt.Errorf("converting AKS machine instance to node claim, %w", err)
+		}
+
+		nodeClaims = append(nodeClaims, nodeClaim)
+	}
+
+	// List VM-based nodes
 	vmInstances, err := c.vmInstanceProvider.List(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("listing VM instances, %w", err)
 	}
 
-	var nodeClaims []*karpv1.NodeClaim
 	for _, instance := range vmInstances {
 		instanceType, err := c.resolveInstanceTypeFromVMInstance(ctx, instance)
 		if err != nil {
@@ -297,6 +357,28 @@ func (c *CloudProvider) Get(ctx context.Context, providerID string) (*karpv1.Nod
 		return nil, fmt.Errorf("getting vm name, %w", err)
 	}
 	ctx = log.IntoContext(ctx, log.FromContext(ctx).WithValues("vmName", vmName))
+
+	aksMachinesPoolName := options.FromContext(ctx).AKSMachinesPoolName
+	if aksMachineName, err := instance.GetAKSMachineNameFromVMName(aksMachinesPoolName, vmName); err == nil {
+		// This could be an AKS machine-based node; try getting the AKS machine instance
+		ctx := log.IntoContext(ctx, log.FromContext(ctx).WithValues("aksMachineName", aksMachineName))
+
+		aksMachine, err := c.aksMachineInstanceProvider.Get(ctx, aksMachineName)
+		if err == nil {
+			nodeClaim, err := c.resolveNodeClaimFromAKSMachine(ctx, aksMachine)
+			if err != nil {
+				return nil, fmt.Errorf("converting AKS machine instance to node claim, %w", err)
+			}
+			return nodeClaim, nil
+		} else if cloudprovider.IgnoreNodeClaimNotFoundError(err) != nil {
+			return nil, fmt.Errorf("getting AKS machine instance, %w", err)
+		}
+		// Fallback to legacy VM-based node if not found
+		// In the case that it is indeed AKS machine node, but somehow fail GET AKS machine and succeeded GET VM, ideally we want this call to fail.
+		// However, being misrepresented only once is not fatal. "Illegal" in-place update will be reconciled back to the before, and there is no drift for VM nodes that won't happen with AKS machine nodes + DriftAction.
+		// So, we could live with this for now.
+	}
+
 	vm, err := c.vmInstanceProvider.Get(ctx, vmName)
 	if err != nil {
 		return nil, fmt.Errorf("getting VM instance, %w", err)
@@ -334,6 +416,13 @@ func (c *CloudProvider) GetInstanceTypes(ctx context.Context, nodePool *karpv1.N
 
 func (c *CloudProvider) Delete(ctx context.Context, nodeClaim *karpv1.NodeClaim) error {
 	ctx = log.IntoContext(ctx, log.FromContext(ctx).WithValues("NodeClaim", nodeClaim.Name))
+
+	// AKS machine-based node?
+	if aksMachineName, isAKSMachine := instance.GetAKSMachineNameFromNodeClaim(nodeClaim); isAKSMachine {
+		return c.aksMachineInstanceProvider.Delete(ctx, aksMachineName)
+	}
+
+	// VM-based node
 	vmName, err := nodeclaimutils.GetVMName(nodeClaim.Status.ProviderID)
 	if err != nil {
 		return fmt.Errorf("getting VM name, %w", err)
@@ -481,7 +570,7 @@ func (c *CloudProvider) vmInstanceToNodeClaim(ctx context.Context, vm *armcomput
 		labels[karpv1.NodePoolLabelKey] = *tag
 	}
 
-	nodeClaim.Name = GetNodeClaimNameFromVMName(*vm.Name)
+	nodeClaim.Name = GenerateNodeClaimName(*vm.Name)
 	nodeClaim.Labels = labels
 	nodeClaim.Annotations = annotations
 	nodeClaim.CreationTimestamp = metav1.Time{Time: *vm.Properties.TimeCreated}
@@ -496,7 +585,7 @@ func (c *CloudProvider) vmInstanceToNodeClaim(ctx context.Context, vm *armcomput
 	return nodeClaim, nil
 }
 
-func GetNodeClaimNameFromVMName(vmName string) string {
+func GenerateNodeClaimName(vmName string) string {
 	return strings.TrimPrefix(vmName, "aks-")
 }
 
@@ -519,6 +608,7 @@ func setAdditionalAnnotationsForNewNodeClaim(ctx context.Context, nodeClaim *kar
 	// Additional annotations
 	// ASSUMPTION: this is not needed in other places that the core also wants NodeClaim (e.g., Get, List).
 	// As of the time of writing, AWS is doing something similar.
+	// Suggestion: could have added this in instance.BuildNodeClaimFromAKSMachine, but might sacrifice some performance (little?), and need to consider that the calculated hash may change.
 	inPlaceUpdateHash, err := inplaceupdate.HashFromNodeClaim(options.FromContext(ctx), nodeClaim, nodeClass)
 	if err != nil {
 		return fmt.Errorf("failed to calculate in place update hash, %w", err)
@@ -530,3 +620,30 @@ func setAdditionalAnnotationsForNewNodeClaim(ctx context.Context, nodeClaim *kar
 	})
 	return nil
 }
+
+func (c *CloudProvider) resolveNodeClaimFromAKSMachine(ctx context.Context, aksMachine *armcontainerservice.Machine) (*karpv1.NodeClaim, error) {
+	var instanceTypes []*cloudprovider.InstanceType
+	nodePool, err := instance.FindNodePoolFromAKSMachine(ctx, aksMachine, c.kubeClient)
+	if err == nil {
+		gotInstanceTypes, err := c.GetInstanceTypes(ctx, nodePool)
+		if err == nil {
+			instanceTypes = gotInstanceTypes
+		} else if client.IgnoreNotFound(err) != nil {
+			// Unknown error
+			return nil, fmt.Errorf("resolving node pool instance types, %w", err)
+		}
+		// If GetInstanceTypes returns not found, we tolerate. But, possible instance types will be empty.
+	} else if client.IgnoreNotFound(err) != nil {
+		// Unknown error
+		return nil, fmt.Errorf("resolving node pool, %w", err)
+	}
+	// If FindNodePoolFromAKSMachine returns not found, we tolerate. But, possible instance types will be empty.
+
+	// ASSUMPTION: all machines are in the same location, and in the current pool.
+	nodeClaim, err := instance.BuildNodeClaimFromAKSMachine(ctx, aksMachine, instanceTypes, c.aksMachineInstanceProvider.GetMachinesPoolLocation())
+	if err != nil {
+		return nil, fmt.Errorf("converting AKS machine instance to node claim, %w", err)
+	}
+
+	return nodeClaim, nil
+}