Repository: kubernetes-sigs/cloud-provider-azure
Pull request #4294 (2023-07-17 03:04:26)

Skip unmanaged Nodes for instancesV2
<!--  Thanks for sending a pull request!  Here are some tips for you:

1. If this is your first time, please read our contributor guidelines: https://git.k8s.io/community/contributors/guide/first-contribution.md#your-first-contribution and developer guide https://git.k8s.io/community/contributors/devel/development.md#development-guide
2. Please label this pull request according to what type of issue you are addressing, especially if this is a release targeted pull request. For reference on required PR/issue labels, read here:
https://git.k8s.io/community/contributors/devel/sig-release/release.md#issuepr-kind-label
3. Ensure you have added or ran the appropriate tests for your PR: https://git.k8s.io/community/contributors/devel/sig-testing/testing.md
4. If you want *faster* PR reviews, read how: https://git.k8s.io/community/contributors/guide/pull-requests.md#best-practices-for-faster-reviews
5. If the PR is unfinished, see how to mark it: https://git.k8s.io/community/contributors/guide/pull-requests.md#marking-unfinished-pull-requests
-->

#### What type of PR is this?
/kind feature
<!--
Add one of the following kinds:
/kind bug
/kind cleanup
/kind documentation
/kind feature
/kind design

Optionally add one or more of the following kinds if applicable:
/kind api-change
/kind deprecation
/kind failing-test
/kind flake
/kind regression
-->

#### What this PR does / why we need it:
Skip unmanaged Nodes for instancesV2
#### Which issue(s) this PR fixes:
<!--
*Automatically closes linked issue when PR is merged.
Usage: `Fixes #<issue number>`, or `Fixes (paste link of issue)`.
_If PR is about `failing-tests or flakes`, please post the related issues/tests in a comment and do not use `Fixes`_*
-->
Fixes #

#### Special notes for your reviewer:

#### Does this PR introduce a user-facing change?
<!--
If no, just write "NONE" in the release-note block below.
If yes, a release note is required:
Enter your extended release note in the block below. If the PR requires additional action from users switching to the new release, include the string "action required".

For more information on release notes see: https://git.k8s.io/community/contributors/guide/release-notes.md
-->
```release-note
Skip unmanaged Nodes for instancesV2
```

#### Additional documentation e.g., KEPs (Kubernetes Enhancement Proposals), usage docs, etc.:

<!--
This section can be blank if this pull request does not require a release note.

When adding links which point to resources within git repositories, like
KEPs or supporting documentation, please reference a specific commit and avoid
linking directly to the master branch. This ensures that links reference a
specific point in time, rather than a document that may change over time.

See here for guidance on getting permanent links to files: https://help.github.com/en/articles/getting-permanent-links-to-files

Please use the following format for linking documentation:
- [KEP]: <link>
- [Usage]: <link>
- [Other doc]: <link>
-->
```docs

```



Patch:
diff --git a/.pipelines/scripts/collect-log.sh b/.pipelines/scripts/collect-log.sh
index ed4da3f73..51caa9335 100755
--- a/.pipelines/scripts/collect-log.sh
+++ b/.pipelines/scripts/collect-log.sh
@@ -19,13 +19,13 @@ set -o nounset
 set -o pipefail
 
 echo "collecting logs of all pods in kube-system"
-mkdir -p "${ARTIFACT_DIR:-}/kube-system"
+mkdir "${ARTIFACT_DIR}/kube-system"
 kubectl get pod -A | grep "kube-system" | awk '{printf("%s\n",$2)}' | while read -r POD; do
-    kubectl logs ${POD} -n kube-system > "${ARTIFACT_DIR:-}/kube-system/${POD}.log" || echo "Cannot collect log from pod ${POD}"
+    kubectl logs ${POD} -n kube-system > "${ARTIFACT_DIR}/kube-system/${POD}.log" || echo "Cannot collect log from pod ${POD}"
 done
 
 echo "collecting logs of all nodes"
-mkdir "${ARTIFACT_DIR:-}/node-log"
+mkdir "${ARTIFACT_DIR}/node-log"
 LOG_IMAGE="mcr.microsoft.com/dotnet/runtime-deps:6.0"
 NODE_CMDS=("journalctl --no-pager --output=short-precise" \
            "journalctl --no-pager --output=short-precise -k" \
@@ -36,7 +36,7 @@ NODE_CMDS=("journalctl --no-pager --output=short-precise" \
            "ls /run/cluster-api/")
 NODE_LOG_FILE_NAMES=("journal.log" "kern.log" "kubelet-version.txt" "kubelet.log" "containerd.log" "cloud-init.log" "cloud-init-output.log" "sentinel-file-dir.txt")
 kubectl get node | grep "aks-" | awk '{printf("%s\n",$1)}' | while read -r NODE; do
-    NODE_LOG_DIR="${ARTIFACT_DIR:-}/node-log/${NODE}"
+    NODE_LOG_DIR="${ARTIFACT_DIR}/node-log/${NODE}"
     mkdir "${NODE_LOG_DIR}"
     for i in "${!NODE_CMDS[@]}"; do
         kubectl debug node/${NODE} -it --image=${LOG_IMAGE} -- /bin/sh -c "chroot /host ${NODE_CMDS[$i]}" > "${NODE_LOG_DIR}/${NODE_LOG_FILE_NAMES[$i]}" || echo "Cannot collect ${NODE_LOG_FILE_NAMES[$i]} log from node ${NODE}"
diff --git a/pkg/azclient/client-gen/go.mod b/pkg/azclient/client-gen/go.mod
index f7ba9dbdb..cbdf1e086 100644
--- a/pkg/azclient/client-gen/go.mod
+++ b/pkg/azclient/client-gen/go.mod
@@ -4,7 +4,7 @@ go 1.20
 
 require (
 	github.com/spf13/cobra v1.7.0
-	sigs.k8s.io/controller-tools v0.12.1
+	sigs.k8s.io/controller-tools v0.12.0
 )
 
 require (
diff --git a/pkg/azclient/client-gen/go.sum b/pkg/azclient/client-gen/go.sum
index fffbef2e7..4ec39b3b1 100644
--- a/pkg/azclient/client-gen/go.sum
+++ b/pkg/azclient/client-gen/go.sum
@@ -37,5 +37,5 @@ gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
 gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
 k8s.io/apimachinery v0.27.1 h1:EGuZiLI95UQQcClhanryclaQE6xjg1Bts6/L3cD7zyc=
 k8s.io/apimachinery v0.27.1/go.mod h1:5ikh59fK3AJ287GUvpUsryoMFtH9zj/ARfWCo3AyXTM=
-sigs.k8s.io/controller-tools v0.12.1 h1:GyQqxzH5wksa4n3YDIJdJJOopztR5VDM+7qsyg5yE4U=
-sigs.k8s.io/controller-tools v0.12.1/go.mod h1:rXlpTfFHZMpZA8aGq9ejArgZiieHd+fkk/fTatY8A2M=
+sigs.k8s.io/controller-tools v0.12.0 h1:TY6CGE6+6hzO7hhJFte65ud3cFmmZW947jajXkuDfBw=
+sigs.k8s.io/controller-tools v0.12.0/go.mod h1:rXlpTfFHZMpZA8aGq9ejArgZiieHd+fkk/fTatY8A2M=
diff --git a/pkg/azclient/go.mod b/pkg/azclient/go.mod
index f317eacb9..f1060e694 100644
--- a/pkg/azclient/go.mod
+++ b/pkg/azclient/go.mod
@@ -3,7 +3,7 @@ module sigs.k8s.io/cloud-provider-azure/pkg/azclient
 go 1.20
 
 require (
-	github.com/Azure/azure-sdk-for-go/sdk/azcore v1.7.0
+	github.com/Azure/azure-sdk-for-go/sdk/azcore v1.6.1
 	github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.3.0
 	github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/compute/armcompute/v5 v5.0.0
 	github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice/v4 v4.0.0
diff --git a/pkg/azclient/go.sum b/pkg/azclient/go.sum
index c7d6dc62c..7a53b37d0 100644
--- a/pkg/azclient/go.sum
+++ b/pkg/azclient/go.sum
@@ -1,5 +1,5 @@
-github.com/Azure/azure-sdk-for-go/sdk/azcore v1.7.0 h1:8q4SaHjFsClSvuVne0ID/5Ka8u3fcIHyqkLjcFpNRHQ=
-github.com/Azure/azure-sdk-for-go/sdk/azcore v1.7.0/go.mod h1:bjGvMhVMb+EEm3VRNQawDMUyMMjo+S5ewNjflkep/0Q=
+github.com/Azure/azure-sdk-for-go/sdk/azcore v1.6.1 h1:SEy2xmstIphdPwNBUi7uhvjyjhVKISfwjfOJmuy7kg4=
+github.com/Azure/azure-sdk-for-go/sdk/azcore v1.6.1/go.mod h1:bjGvMhVMb+EEm3VRNQawDMUyMMjo+S5ewNjflkep/0Q=
 github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.3.0 h1:vcYCAze6p19qBW7MhZybIsqD8sMV8js0NyQM8JDnVtg=
 github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.3.0/go.mod h1:OQeznEEkTZ9OrhHJoDD8ZDq51FHgXjqtP9z6bEwBq9U=
 github.com/Azure/azure-sdk-for-go/sdk/internal v1.3.0 h1:sXr+ck84g/ZlZUOZiNELInmMgOsuGwdjjVkEIde0OtY=
diff --git a/pkg/azclient/policy/etag/etag.go b/pkg/azclient/policy/etag/etag.go
deleted file mode 100644
index ccc09789d..000000000
--- a/pkg/azclient/policy/etag/etag.go
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
-Copyright 2023 The Kubernetes Authors.
-
-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 etag
-
-import (
-	"encoding/json"
-	"io"
-	"net/http"
-	"strings"
-
-	"github.com/Azure/azure-sdk-for-go/sdk/azcore"
-	"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
-	"github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming"
-)
-
-type Etag struct {
-	azcore.ETag `json:"etag,omitempty"`
-}
-
-func AppendEtag(req *policy.Request) (*http.Response, error) {
-	if req.Raw().Method == http.MethodPatch || req.Raw().Method == http.MethodPost || req.Raw().Method == http.MethodPut {
-		body, err := io.ReadAll(req.Body())
-		if err != nil {
-			return nil, err
-		}
-		var etag Etag
-		err = json.Unmarshal(body, &etag)
-		if err != nil {
-			return nil, err
-		}
-		if etag.ETag != "" {
-			req.Raw().Header.Set("If-Match", string(etag.ETag))
-		}
-		req.SetBody(streaming.NopCloser(strings.NewReader(string(body))), "application/json")
-	}
-
-	return req.Next()
-}
diff --git a/pkg/provider/azure.go b/pkg/provider/azure.go
index e608da04d..258e9ebec 100644
--- a/pkg/provider/azure.go
+++ b/pkg/provider/azure.go
@@ -76,6 +76,7 @@ import (
 	"sigs.k8s.io/cloud-provider-azure/pkg/azureclients/zoneclient"
 	azcache "sigs.k8s.io/cloud-provider-azure/pkg/cache"
 	"sigs.k8s.io/cloud-provider-azure/pkg/consts"
+	nodemanager "sigs.k8s.io/cloud-provider-azure/pkg/nodemanager"
 	"sigs.k8s.io/cloud-provider-azure/pkg/retry"
 
 	"sigs.k8s.io/yaml"
@@ -308,12 +309,7 @@ type MultipleStandardLoadBalancerConfigurationSpec struct {
 
 // MultipleStandardLoadBalancerConfigurationStatus stores the properties regarding multiple standard load balancers.
 type MultipleStandardLoadBalancerConfigurationStatus struct {
-	// ActiveServices stores the services that are supposed to use the load balancer.
 	ActiveServices sets.Set[string] `json:"activeServices" yaml:"activeServices"`
-
-	// ActiveNodes stores the nodes that are supposed to be in the load balancer.
-	// It will be used in EnsureHostsInPool to make sure the given ones are in the backend pool.
-	ActiveNodes sets.Set[string] `json:"activeNodes" yaml:"activeNodes"`
 }
 
 type InitSecretConfig struct {
@@ -387,9 +383,8 @@ type Cloud struct {
 	// unmanagedNodes holds a list of nodes not managed by Azure cloud provider.
 	unmanagedNodes sets.Set[string]
 	// excludeLoadBalancerNodes holds a list of nodes that should be excluded from LoadBalancer.
-	excludeLoadBalancerNodes   sets.Set[string]
-	nodePrivateIPs             map[string]sets.Set[string]
-	nodePrivateIPToNodeNameMap map[string]string
+	excludeLoadBalancerNodes sets.Set[string]
+	nodePrivateIPs           map[string]sets.Set[string]
 	// nodeInformerSynced is for determining if the informer has synced.
 	nodeInformerSynced cache.InformerSynced
 
@@ -426,14 +421,7 @@ type Cloud struct {
 	*ManagedDiskController
 	*controllerCommon
 
-	// multipleStandardLoadBalancerConfigurationsSynced make sure the `reconcileMultipleStandardLoadBalancerConfigurations`
-	// runs only once every time the cloud provide restarts.
 	multipleStandardLoadBalancerConfigurationsSynced bool
-	// nodesWithCorrectLoadBalancerByPrimaryVMSet marks nodes that are matched with load balancers by primary vmSet.
-	nodesWithCorrectLoadBalancerByPrimaryVMSet sync.Map
-
-	multipleStandardLoadBalancersActiveServicesLock sync.Mutex
-	multipleStandardLoadBalancersActiveNodesLock    sync.Mutex
 }
 
 // NewCloud returns a Cloud with initialized clients
@@ -499,14 +487,13 @@ func (az *Cloud) configSecretMetadata(secretName, secretNamespace, cloudConfigKe
 
 func NewCloudFromSecret(ctx context.Context, clientBuilder cloudprovider.ControllerClientBuilder, secretName, secretNamespace, cloudConfigKey string) (cloudprovider.Interface, error) {
 	az := &Cloud{
-		nodeNames:                  sets.New[string](),
-		nodeZones:                  map[string]sets.Set[string]{},
-		nodeResourceGroups:         map[string]string{},
-		unmanagedNodes:             sets.New[string](),
-		routeCIDRs:                 map[string]string{},
-		excludeLoadBalancerNodes:   sets.New[string](),
-		nodePrivateIPs:             map[string]sets.Set[string]{},
-		nodePrivateIPToNodeNameMap: map[string]string{},
+		nodeNames:                sets.New[string](),
+		nodeZones:                map[string]sets.Set[string]{},
+		nodeResourceGroups:       map[string]string{},
+		unmanagedNodes:           sets.New[string](),
+		routeCIDRs:               map[string]string{},
+		excludeLoadBalancerNodes: sets.New[string](),
+		nodePrivateIPs:           map[string]sets.Set[string]{},
 	}
 
 	az.configSecretMetadata(secretName, secretNamespace, cloudConfigKey)
@@ -532,14 +519,13 @@ func NewCloudWithoutFeatureGates(ctx context.Context, configReader io.Reader, ca
 	}
 
 	az := &Cloud{
-		nodeNames:                  sets.New[string](),
-		nodeZones:                  map[string]sets.Set[string]{},
-		nodeResourceGroups:         map[string]string{},
-		unmanagedNodes:             sets.New[string](),
-		routeCIDRs:                 map[string]string{},
-		excludeLoadBalancerNodes:   sets.New[string](),
-		nodePrivateIPs:             map[string]sets.Set[string]{},
-		nodePrivateIPToNodeNameMap: map[string]string{},
+		nodeNames:                sets.New[string](),
+		nodeZones:                map[string]sets.Set[string]{},
+		nodeResourceGroups:       map[string]string{},
+		unmanagedNodes:           sets.New[string](),
+		routeCIDRs:               map[string]string{},
+		excludeLoadBalancerNodes: sets.New[string](),
+		nodePrivateIPs:           map[string]sets.Set[string]{},
 	}
 
 	err = az.InitializeCloudFromConfig(ctx, config, false, callFromCCM)
@@ -743,24 +729,6 @@ func (az *Cloud) checkEnableMultipleStandardLoadBalancers() error {
 	if az.isLBBackendPoolTypeNodeIPConfig() {
 		return fmt.Errorf("multiple standard load balancers cannot be used with backend pool type %s", consts.LoadBalancerBackendPoolConfigurationTypeNodeIPConfiguration)
 	}
-
-	names := sets.New[string]()
-	primaryVMSets := sets.New[string]()
-	for _, multiSLBConfig := range az.MultipleStandardLoadBalancerConfigurations {
-		if names.Has(multiSLBConfig.Name) {
-			return fmt.Errorf("duplicated multiple standard load balancer configuration name %s", multiSLBConfig.Name)
-		}
-		names.Insert(multiSLBConfig.Name)
-
-		if multiSLBConfig.PrimaryVMSet == "" {
-			return fmt.Errorf("multiple standard load balancer configuration %s must have primary VMSet", multiSLBConfig.Name)
-		}
-		if primaryVMSets.Has(multiSLBConfig.PrimaryVMSet) {
-			return fmt.Errorf("duplicated primary VMSet %s in multiple standard load balancer configurations %s", multiSLBConfig.PrimaryVMSet, multiSLBConfig.Name)
-		}
-		primaryVMSets.Insert(multiSLBConfig.PrimaryVMSet)
-	}
-
 	return nil
 }
 
@@ -1220,14 +1188,12 @@ func (az *Cloud) updateNodeCaches(prevNode, newNode *v1.Node) {
 		// if the node is being deleted from the cluster, exclude it from load balancers
 		if newNode == nil {
 			az.excludeLoadBalancerNodes.Insert(prevNode.ObjectMeta.Name)
-			az.nodesWithCorrectLoadBalancerByPrimaryVMSet.Delete(strings.ToLower(prevNode.ObjectMeta.Name))
 		}
 
 		// Remove from nodePrivateIPs cache.
 		for _, address := range getNodePrivateIPAddresses(prevNode) {
 			klog.V(4).Infof("removing IP address %s of the node %s", address, prevNode.Name)
 			az.nodePrivateIPs[prevNode.Name].Delete(address)
-			delete(az.nodePrivateIPToNodeNameMap, address)
 		}
 	}
 
@@ -1269,6 +1235,15 @@ func (az *Cloud) updateNodeCaches(prevNode, newNode *v1.Node) {
 			az.excludeLoadBalancerNodes.Insert(newNode.ObjectMeta.Name)
 			klog.V(6).Infof("excluding Node %q from LoadBalancer because it has exclude-from-external-load-balancers label", newNode.ObjectMeta.Name)
 
+		case !isNodeReady(newNode) && nodemanager.GetCloudTaint(newNode.Spec.Taints) == nil:
+			// If not in ready state and not a newly created node, add to excludeLoadBalancerNodes cache.
+			// New nodes (tainted with "node.cloudprovider.kubernetes.io/uninitialized") should not be
+			// excluded from load balancers regardless of their state, so as to reduce the number of
+			// VMSS API calls and not provoke VMScaleSetActiveModelsCountLimitReached.
+			// (https://github.com/kubernetes-sigs/cloud-provider-azure/issues/851)
+			az.excludeLoadBalancerNodes.Insert(newNode.ObjectMeta.Name)
+			klog.V(6).Infof("excluding Node %q from LoadBalancer because it is not in ready state or a newly created one", newNode.ObjectMeta.Name)
+
 		default:
 			// Nodes not falling into the three cases above are valid backends and
 			// should not appear in excludeLoadBalancerNodes cache.
@@ -1280,13 +1255,9 @@ func (az *Cloud) updateNodeCaches(prevNode, newNode *v1.Node) {
 			if az.nodePrivateIPs[newNode.Name] == nil {
 				az.nodePrivateIPs[newNode.Name] = sets.New[string]()
 			}
-			if az.nodePrivateIPToNodeNameMap == nil {
-				az.nodePrivateIPToNodeNameMap = make(map[string]string)
-			}
 
 			klog.V(6).Infof("adding IP address %s of the node %s", address, newNode.Name)
 			az.nodePrivateIPs[newNode.Name].Insert(address)
-			az.nodePrivateIPToNodeNameMap[address] = newNode.Name
 		}
 	}
 }
@@ -1413,15 +1384,11 @@ func (az *Cloud) ShouldNodeExcludedFromLoadBalancer(nodeName string) (bool, erro
 	return az.excludeLoadBalancerNodes.Has(nodeName), nil
 }
 
-func (az *Cloud) getActiveNodesByLoadBalancerName(lbName string) sets.Set[string] {
-	az.multipleStandardLoadBalancersActiveNodesLock.Lock()
-	defer az.multipleStandardLoadBalancersActiveNodesLock.Unlock()
-
-	for _, multiSLBConfig := range az.MultipleStandardLoadBalancerConfigurations {
-		if strings.EqualFold(strings.TrimSuffix(lbName, consts.InternalLoadBalancerNameSuffix), multiSLBConfig.Name) {
-			return multiSLBConfig.ActiveNodes
+func isNodeReady(node *v1.Node) bool {
+	for _, cond := range node.Status.Conditions {
+		if cond.Type == v1.NodeReady && cond.Status == v1.ConditionTrue {
+			return true
 		}
 	}
-
-	return sets.New[string]()
+	return false
 }
diff --git a/pkg/provider/azure_instances.go b/pkg/provider/azure_instances.go
index 8b1e54ed4..40b9a63e0 100644
--- a/pkg/provider/azure_instances.go
+++ b/pkg/provider/azure_instances.go
@@ -225,6 +225,15 @@ func (az *Cloud) InstanceExists(ctx context.Context, node *v1.Node) (bool, error
 	if node == nil {
 		return false, nil
 	}
+	unmanaged, err := az.IsNodeUnmanaged(node.Name)
+	if err != nil {
+		return false, err
+	}
+	if unmanaged {
+		klog.V(4).Infof("InstanceExists: omitting unmanaged node %q", node.Name)
+		return false, nil
+	}
+
 	providerID := node.Spec.ProviderID
 	if providerID == "" {
 		var err error
@@ -295,6 +304,14 @@ func (az *Cloud) InstanceShutdown(ctx context.Context, node *v1.Node) (bool, err
 	if node == nil {
 		return false, nil
 	}
+	unmanaged, err := az.IsNodeUnmanaged(node.Name)
+	if err != nil {
+		return false, err
+	}
+	if unmanaged {
+		klog.V(4).Infof("InstanceShutdown: omitting unmanaged node %q", node.Name)
+		return false, nil
+	}
 	providerID := node.Spec.ProviderID
 	if providerID == "" {
 		var err error
@@ -490,11 +507,18 @@ func (az *Cloud) CurrentNodeName(ctx context.Context, hostname string) (types.No
 // translated into specific fields in the Node object on registration.
 // Use the node.name or node.spec.providerID field to find the node in the cloud provider.
 func (az *Cloud) InstanceMetadata(ctx context.Context, node *v1.Node) (*cloudprovider.InstanceMetadata, error) {
+	meta := cloudprovider.InstanceMetadata{}
 	if node == nil {
-		return &cloudprovider.InstanceMetadata{}, nil
+		return &meta, nil
+	}
+	unmanaged, err := az.IsNodeUnmanaged(node.Name)
+	if err != nil {
+		return &meta, err
+	}
+	if unmanaged {
+		klog.V(4).Infof("InstanceMetadata: omitting unmanaged node %q", node.Name)
+		return &meta, nil
 	}
-
-	meta := cloudprovider.InstanceMetadata{}
 
 	if node.Spec.ProviderID != "" {
 		meta.ProviderID = node.Spec.ProviderID
diff --git a/pkg/provider/azure_loadbalancer.go b/pkg/provider/azure_loadbalancer.go
index bca5c3d2e..c53f6348b 100644
--- a/pkg/provider/azure_loadbalancer.go
+++ b/pkg/provider/azure_loadbalancer.go
@@ -86,13 +86,13 @@ func (az *Cloud) GetLoadBalancer(ctx context.Context, clusterName string, servic
 		return nil, az.existsPip(clusterName, service), err
 	}
 
-	_, status, _, existsLb, _, err := az.getServiceLoadBalancer(service, clusterName, nil, false, existingLBs)
+	_, status, _, existsLb, err := az.getServiceLoadBalancer(service, clusterName, nil, false, existingLBs)
 	if err != nil || existsLb {
 		return status, existsLb || az.existsPip(clusterName, service), err
 	}
 
 	flippedService := flipServiceInternalAnnotation(service)
-	_, status, _, existsLb, _, err = az.getServiceLoadBalancer(flippedService, clusterName, nil, false, existingLBs)
+	_, status, _, existsLb, err = az.getServiceLoadBalancer(flippedService, clusterName, nil, false, existingLBs)
 	if err != nil || existsLb {
 		return status, existsLb || az.existsPip(clusterName, service), err
 	}
@@ -277,7 +277,7 @@ func (az *Cloud) EnsureLoadBalancerDeleted(ctx context.Context, clusterName stri
 		klog.V(5).InfoS("EnsureLoadBalancerDeleted Finish", "service", serviceName, "cluster", clusterName, "service_spec", service, "error", err)
 	}()
 
-	_, _, lbIPsPrimaryPIPs, _, _, err := az.getServiceLoadBalancer(service, clusterName, nil, false, []network.LoadBalancer{})
+	_, _, lbIPsPrimaryPIPs, _, err := az.getServiceLoadBalancer(service, clusterName, nil, false, []network.LoadBalancer{})
 	if err != nil && !retry.HasStatusForbiddenOrIgnoredError(err) {
 		return err
 	}
@@ -332,11 +332,8 @@ func (az *Cloud) shouldChangeLoadBalancer(service *v1.Service, currLBName, clust
 	}
 
 	if az.useMultipleStandardLoadBalancers() {
-		if currLBName != expectedLBName {
-			klog.V(2).Infof("shouldChangeLoadBalancer(%s, %s, %s): change the LB to another one %s", service.Name, currLBName, clusterName, expectedLBName)
-			return true
-		}
-		return false
+		klog.V(2).Infof("shouldChangeLoadBalancer(%s, %s, %s): change the LB to another one %s", service.Name, currLBName, clusterName, expectedLBName)
+		return currLBName != expectedLBName
 	}
 
 	// basic LB
@@ -367,12 +364,9 @@ func (az *Cloud) shouldChangeLoadBalancer(service *v1.Service, currLBName, clust
 	return true
 }
 
-// removeFrontendIPConfigurationFromLoadBalancer removes the given ip configs from the load balancer
-// and delete the load balancer if there is no ip config on it. It returns the name of the deleted load balancer
-// and it will be used in reconcileLoadBalancer to remove the load balancer from the list.
-func (az *Cloud) removeFrontendIPConfigurationFromLoadBalancer(lb *network.LoadBalancer, existingLBs []network.LoadBalancer, fips []*network.FrontendIPConfiguration, clusterName string, service *v1.Service) (string, error) {
+func (az *Cloud) removeFrontendIPConfigurationFromLoadBalancer(lb *network.LoadBalancer, existingLBs []network.LoadBalancer, fips []*network.FrontendIPConfiguration, clusterName string, service *v1.Service) error {
 	if lb == nil || lb.LoadBalancerPropertiesFormat == nil || lb.FrontendIPConfigurations == nil {
-		return "", nil
+		return nil
 	}
 	fipConfigs := *lb.FrontendIPConfigurations
 	for i, fipConfig := range fipConfigs {
@@ -414,11 +408,10 @@ func (az *Cloud) removeFrontendIPConfigurationFromLoadBalancer(lb *network.LoadB
 		// clean up any private link service associated with the frontEndIPConfig
 		if err := az.reconcilePrivateLinkService(clusterName, service, fip, false /* wantPLS */); err != nil {
 			klog.Errorf("removeFrontendIPConfigurationFromLoadBalancer(%s, %s, %s, %s): failed to clean up PLS: %v", pointer.StringDeref(lb.Name, ""), pointer.StringDeref(fip.Name, ""), clusterName, service.Name, err)
-			return "", err
+			return err
 		}
 	}
 
-	var deletedLBName string
 	fipNames := []string{}
 	for _, fip := range fips {
 		fipNames = append(fipNames, pointer.StringDeref(fip.Name, ""))
@@ -429,19 +422,18 @@ func (az *Cloud) removeFrontendIPConfigurationFromLoadBalancer(lb *network.LoadB
 		err := az.cleanOrphanedLoadBalancer(lb, existingLBs, service, clusterName)
 		if err != nil {
 			klog.Errorf("%s: failed to cleanupOrphanedLoadBalancer: %v", logPrefix, err)
-			return "", err
+			return err
 		}
-		deletedLBName = pointer.StringDeref(lb.Name, "")
 	} else {
 		klog.V(2).Infof("%s: updating the load balancer", logPrefix)
 		err := az.CreateOrUpdateLB(service, *lb)
 		if err != nil {
 			klog.Errorf("%s: failed to CreateOrUpdateLB: %v", logPrefix, err)
-			return "", err
+			return err
 		}
 		_ = az.lbCache.Delete(pointer.StringDeref(lb.Name, ""))
 	}
-	return deletedLBName, nil
+	return nil
 }
 
 func (az *Cloud) cleanOrphanedLoadBalancer(lb *network.LoadBalancer, existingLBs []network.LoadBalancer, service *v1.Service, clusterName string) error {
@@ -543,22 +535,6 @@ func (az *Cloud) safeDeleteLoadBalancer(lb network.LoadBalancer, clusterName, vm
 	}
 	_ = az.lbCache.Delete(pointer.StringDeref(lb.Name, ""))
 
-	// Remove corresponding nodes in ActiveNodes and nodesWithCorrectLoadBalancerByPrimaryVMSet.
-	for i := range az.MultipleStandardLoadBalancerConfigurations {
-		if strings.EqualFold(
-			strings.TrimSuffix(pointer.StringDeref(lb.Name, ""), consts.InternalLoadBalancerNameSuffix),
-			az.MultipleStandardLoadBalancerConfigurations[i].Name,
-		) {
-			if az.MultipleStandardLoadBalancerConfigurations[i].ActiveNodes != nil {
-				for nodeName := range az.MultipleStandardLoadBalancerConfigurations[i].ActiveNodes {
-					az.nodesWithCorrectLoadBalancerByPrimaryVMSet.Delete(strings.ToLower(nodeName))
-				}
-			}
-			az.MultipleStandardLoadBalancerConfigurations[i].ActiveNodes = sets.New[string]()
-			break
-		}
-	}
-
 	return nil
 }
 
@@ -567,20 +543,20 @@ func (az *Cloud) safeDeleteLoadBalancer(lb network.LoadBalancer, clusterName, vm
 // In case the selected load balancer does not exist it returns network.LoadBalancer struct
 // with added metadata (such as name, location) and existsLB set to FALSE.
 // By default - cluster default LB is returned.
-func (az *Cloud) getServiceLoadBalancer(service *v1.Service, clusterName string, nodes []*v1.Node, wantLb bool, existingLBs []network.LoadBalancer) (lb *network.LoadBalancer, status *v1.LoadBalancerStatus, lbIPsPrimaryPIPs []string, exists bool, deletedLBName string, err error) {
+func (az *Cloud) getServiceLoadBalancer(service *v1.Service, clusterName string, nodes []*v1.Node, wantLb bool, existingLBs []network.LoadBalancer) (lb *network.LoadBalancer, status *v1.LoadBalancerStatus, lbIPsPrimaryPIPs []string, exists bool, err error) {
 	isInternal := requiresInternalLoadBalancer(service)
 	var defaultLB *network.LoadBalancer
 	primaryVMSetName := az.VMSet.GetPrimaryVMSetName()
 	defaultLBName, err := az.getAzureLoadBalancerName(service, &existingLBs, clusterName, primaryVMSetName, isInternal)
 	if err != nil {
-		return nil, nil, nil, false, "", err
+		return nil, nil, nil, false, err
 	}
 
 	// reuse the lb list from reconcileSharedLoadBalancer to reduce the api call
 	if len(existingLBs) == 0 {
 		existingLBs, err = az.ListLB(service)
 		if err != nil {
-			return nil, nil, nil, false, "", err
+			return nil, nil, nil, false, err
 		}
 	}
 
@@ -598,7 +574,7 @@ func (az *Cloud) getServiceLoadBalancer(service *v1.Service, clusterName string,
 		var fipConfigs []*network.FrontendIPConfiguration
 		status, lbIPsPrimaryPIPs, fipConfigs, err = az.getServiceLoadBalancerStatus(service, &existingLB)
 		if err != nil {
-			return nil, nil, nil, false, "", err
+			return nil, nil, nil, false, err
 		}
 		if status == nil {
 			// service is not on this load balancer
@@ -608,16 +584,14 @@ func (az *Cloud) getServiceLoadBalancer(service *v1.Service, clusterName string,
 
 		// select another load balancer instead of returning
 		// the current one if the change is needed
-		var err error
 		if wantLb && az.shouldChangeLoadBalancer(service, pointer.StringDeref(existingLB.Name, ""), clusterName, defaultLBName) {
 			fipConfigNames := []string{}
 			for _, fipConfig := range fipConfigs {
 				fipConfigNames = append(fipConfigNames, pointer.StringDeref(fipConfig.Name, ""))
 			}
-			deletedLBName, err = az.removeFrontendIPConfigurationFromLoadBalancer(&existingLB, existingLBs, fipConfigs, clusterName, service)
-			if err != nil {
+			if err := az.removeFrontendIPConfigurationFromLoadBalancer(&existingLB, existingLBs, fipConfigs, clusterName, service); err != nil {
 				klog.Errorf("getServiceLoadBalancer(%s, %s, %v): failed to remove frontend IP configurations %q from load balancer: %v", service.Name, clusterName, wantLb, fipConfigNames, err)
-				return nil, nil, nil, false, "", err
+				return nil, nil, nil, false, err
 			}
 			az.reconcileMultipleStandardLoadBalancerConfigurationStatus(
 				false,
@@ -627,7 +601,7 @@ func (az *Cloud) getServiceLoadBalancer(service *v1.Service, clusterName string,
 			break
 		}
 
-		return &existingLB, status, lbIPsPrimaryPIPs, true, "", nil
+		return &existingLB, status, lbIPsPrimaryPIPs, true, nil
 	}
 
 	// Service does not have a load balancer, select one.
@@ -637,10 +611,10 @@ func (az *Cloud) getServiceLoadBalancer(service *v1.Service, clusterName string,
 		// select new load balancer for service
 		selectedLB, exists, err := az.selectLoadBalancer(clusterName, service, &existingLBs, nodes)
 		if err != nil {
-			return nil, nil, nil, false, "", err
+			return nil, nil, nil, false, err
 		}
 
-		return selectedLB, status, lbIPsPrimaryPIPs, exists, "", err
+		return selectedLB, status, lbIPsPrimaryPIPs, exists, err
 	}
 
 	// create a default LB with meta data if not present
@@ -663,7 +637,7 @@ func (az *Cloud) getServiceLoadBalancer(service *v1.Service, clusterName string,
 		}
 	}
 
-	return defaultLB, nil, nil, false, deletedLBName, nil
+	return defaultLB, nil, nil, false, nil
 }
 
 // selectLoadBalancer selects load balancer for the service in the cluster.
@@ -1441,13 +1415,7 @@ func (az *Cloud) findFrontendIPConfigsOfService(
 // load balancer typed services and add service names to the ActiveServices queue
 // of the corresponding load balancer configuration. It also checks if there is a configuration
 // named <clustername>. If not, an error will be reported.
-func (az *Cloud) reconcileMultipleStandardLoadBalancerConfigurations(
-	lbs *[]network.LoadBalancer,
-	service *v1.Service,
-	clusterName string,
-	existingLBs *[]network.LoadBalancer,
-	nodes []*v1.Node,
-) (err error) {
+func (az *Cloud) reconcileMultipleStandardLoadBalancerConfigurations(clusterName string, existingLBs *[]network.LoadBalancer) (err error) {
 	if !az.useMultipleStandardLoadBalancers() {
 		return nil
 	}
@@ -1506,13 +1474,11 @@ func (az *Cloud) reconcileMultipleStandardLoadBalancerConfigurations(
 					)
 					for i := range az.MultipleStandardLoadBalancerConfigurations {
 						if strings.EqualFold(strings.TrimSuffix(lbName, consts.InternalLoadBalancerNameSuffix), az.MultipleStandardLoadBalancerConfigurations[i].Name) {
-							az.multipleStandardLoadBalancersActiveServicesLock.Lock()
 							if az.MultipleStandardLoadBalancerConfigurations[i].ActiveServices == nil {
 								az.MultipleStandardLoadBalancerConfigurations[i].ActiveServices = sets.New[string]()
 							}
-							az.MultipleStandardLoadBalancerConfigurations[i].ActiveServices.Insert(strings.ToLower(svcName))
-							az.multipleStandardLoadBalancersActiveServicesLock.Unlock()
 							klog.V(2).Infof("reconcileMultipleStandardLoadBalancerConfigurations: service(%s) is active on lb(%s)", svcName, lbName)
+							az.MultipleStandardLoadBalancerConfigurations[i].ActiveServices.Insert(svcName)
 						}
 					}
 				}
@@ -1520,7 +1486,7 @@ func (az *Cloud) reconcileMultipleStandardLoadBalancerConfigurations(
 		}
 	}
 
-	return az.reconcileMultipleStandardLoadBalancerBackendNodes("", lbs, service, nodes)
+	return nil
 }
 
 // reconcileLoadBalancer ensures load balancer exists and the frontend ip config is setup.
@@ -1537,19 +1503,16 @@ func (az *Cloud) reconcileLoadBalancer(clusterName string, service *v1.Service,
 		return nil, fmt.Errorf("reconcileLoadBalancer: failed to list managed LB: %w", err)
 	}
 
-	if err := az.reconcileMultipleStandardLoadBalancerConfigurations(&existingLBs, service, clusterName, &existingLBs, nodes); err != nil {
+	if err := az.reconcileMultipleStandardLoadBalancerConfigurations(clusterName, &existingLBs); err != nil {
 		klog.Errorf("reconcileLoadBalancer: failed to reconcile multiple standard load balancer configurations: %s", err.Error())
 		return nil, err
 	}
 
-	lb, lbStatus, _, _, deletedLBName, err := az.getServiceLoadBalancer(service, clusterName, nodes, wantLb, existingLBs)
+	lb, lbStatus, _, _, err := az.getServiceLoadBalancer(service, clusterName, nodes, wantLb, existingLBs)
 	if err != nil {
 		klog.Errorf("reconcileLoadBalancer: failed to get load balancer for service %q, error: %v", serviceName, err)
 		return nil, err
 	}
-	if deletedLBName != "" {
-		removeLBFromList(&existingLBs, deletedLBName)
-	}
 
 	lbName := *lb.Name
 	lbResourceGroup := az.getLoadBalancerResourceGroup()
@@ -1701,18 +1664,6 @@ func (az *Cloud) reconcileLoadBalancer(clusterName string, service *v1.Service,
 				return nil, fmt.Errorf("load balancer %q not found", lbName)
 			}
 			lb = newLB
-
-			var found bool
-			for i, existingLB := range existingLBs {
-				if strings.EqualFold(pointer.StringDeref(existingLB.Name, ""), pointer.StringDeref(newLB.Name, "")) {
-					existingLBs[i] = *newLB
-					found = true
-					break
-				}
-			}
-			if !found {
-				existingLBs = append(existingLBs, *newLB)
-			}
 		}
 	}
 
@@ -1724,31 +1675,12 @@ func (az *Cloud) reconcileLoadBalancer(clusterName string, service *v1.Service,
 			_ = az.lbCache.Delete(lbName)
 		}()
 
-		if az.useMultipleStandardLoadBalancers() {
-			err := az.reconcileMultipleStandardLoadBalancerBackendNodes(lbName, &existingLBs, service, nodes)
-			if err != nil {
-				return nil, err
-			}
-		}
-
-		// Need to reconcile every managed backend pools of all managed load balancers in
-		// the cluster when using multiple standard load balancers.
-		// This is because there are chances for backend pools from more than one load balancers
-		// change in one reconciliation loop.
-		var lbToReconcile []network.LoadBalancer
-		lbToReconcile = append(lbToReconcile, *lb)
-		if az.useMultipleStandardLoadBalancers() {
-			lbToReconcile = existingLBs
-		}
-		for _, lb := range lbToReconcile {
-			lbName := pointer.StringDeref(lb.Name, "")
-			if lb.LoadBalancerPropertiesFormat != nil && lb.LoadBalancerPropertiesFormat.BackendAddressPools != nil {
-				for _, backendPool := range *lb.LoadBalancerPropertiesFormat.BackendAddressPools {
-					isIPv6 := isBackendPoolIPv6(pointer.StringDeref(backendPool.Name, ""))
-					if strings.EqualFold(pointer.StringDeref(backendPool.Name, ""), getBackendPoolName(clusterName, isIPv6)) {
-						if err := az.LoadBalancerBackendPool.EnsureHostsInPool(service, nodes, lbBackendPoolIDs[isIPv6], vmSetName, clusterName, lbName, backendPool); err != nil {
-							return nil, err
-						}
+		if lb.LoadBalancerPropertiesFormat != nil && lb.LoadBalancerPropertiesFormat.BackendAddressPools != nil {
+			for _, backendPool := range *lb.LoadBalancerPropertiesFormat.BackendAddressPools {
+				isIPv6 := isBackendPoolIPv6(pointer.StringDeref(backendPool.Name, ""))
+				if strings.EqualFold(pointer.StringDeref(backendPool.Name, ""), getBackendPoolName(clusterName, isIPv6)) {
+					if err := az.LoadBalancerBackendPool.EnsureHostsInPool(service, nodes, lbBackendPoolIDs[isIPv6], vmSetName, clusterName, lbName, backendPool); err != nil {
+						return nil, err
 					}
 				}
 			}
@@ -1763,259 +1695,21 @@ func (az *Cloud) reconcileLoadBalancer(clusterName string, service *v1.Service,
 	return lb, nil
 }
 
-// removeLBFromList removes the given lb from the list
-func removeLBFromList(lbs *[]network.LoadBalancer, lbName string) {
-	if lbs != nil {
-		for i := len(*lbs) - 1; i >= 0; i-- {
-			if strings.EqualFold(pointer.StringDeref((*lbs)[i].Name, ""), lbName) {
-				*lbs = append((*lbs)[:i], (*lbs)[i+1:]...)
-				break
-			}
-		}
-	}
-}
-
-// removeNodeFromLBConfig searches for the occurrence of the given node in the lb configs and removes it
-func (az *Cloud) removeNodeFromLBConfig(nodeNameToLBConfigIDXMap map[string]int, nodeName string) {
-	if idx, ok := nodeNameToLBConfigIDXMap[nodeName]; ok {
-		currentLBConfigName := az.MultipleStandardLoadBalancerConfigurations[idx].Name
-		klog.V(4).Infof("reconcileMultipleStandardLoadBalancerBackendNodes: remove node(%s) on lb(%s)", nodeName, currentLBConfigName)
-		az.multipleStandardLoadBalancersActiveNodesLock.Lock()
-		az.MultipleStandardLoadBalancerConfigurations[idx].ActiveNodes.Delete(strings.ToLower(nodeName))
-		az.multipleStandardLoadBalancersActiveNodesLock.Unlock()
-	}
-}
-
-// removeDeletedNodesFromLoadBalancerConfigurations removes the deleted nodes
-// that do not exist in nodes list from the load balancer configurations
-func (az *Cloud) removeDeletedNodesFromLoadBalancerConfigurations(nodes []*v1.Node) map[string]int {
-	nodeNamesSet := sets.New[string]()
-	for _, node := range nodes {
-		nodeNamesSet.Insert(strings.ToLower(node.Name))
-	}
-
-	az.multipleStandardLoadBalancersActiveNodesLock.Lock()
-	defer az.multipleStandardLoadBalancersActiveNodesLock.Unlock()
-
-	// Remove the nodes from the load balancer configurations if they are not in the node list.
-	nodeNameToLBConfigIDXMap := make(map[string]int)
-	for i, multiSLBConfig := range az.MultipleStandardLoadBalancerConfigurations {
-		if multiSLBConfig.ActiveNodes != nil {
-			for nodeName := range multiSLBConfig.ActiveNodes {
-				if nodeNamesSet.Has(nodeName) {
-					nodeNameToLBConfigIDXMap[nodeName] = i
-				} else {
-					klog.V(4).Infof("reconcileMultipleStandardLoadBalancerBackendNodes: node(%s) is gone, remove it from lb(%s)", nodeName, multiSLBConfig.Name)
-					az.MultipleStandardLoadBalancerConfigurations[i].ActiveNodes, _ = safeRemoveKeyFromStringsSet(az.MultipleStandardLoadBalancerConfigurations[i].ActiveNodes, strings.ToLower(nodeName))
-				}
-			}
-		}
-	}
-
-	return nodeNameToLBConfigIDXMap
-}
-
-// accommodateNodesByPrimaryVMSet decides which load balancer configuration the node should be added to by primary vmSet
-func (az *Cloud) accommodateNodesByPrimaryVMSet(
-	lbName string,
-	lbs *[]network.LoadBalancer,
-	nodes []*v1.Node,
-	nodeNameToLBConfigIDXMap map[string]int,
-) error {
-	for _, node := range nodes {
-		if _, ok := az.nodesWithCorrectLoadBalancerByPrimaryVMSet.Load(strings.ToLower(node.Name)); ok {
-			continue
-		}
-
-		// TODO(niqi): reduce the API calls for VMAS and standalone VMs
-		vmSetName, err := az.VMSet.GetNodeVMSetName(node)
-		if err != nil {
-			klog.Errorf("accommodateNodesByPrimaryVMSet: failed to get vmSetName for node(%s): %s", node.Name, err.Error())
-			return err
-		}
-		for i := range az.MultipleStandardLoadBalancerConfigurations {
-			multiSLBConfig := az.MultipleStandardLoadBalancerConfigurations[i]
-			if strings.EqualFold(multiSLBConfig.PrimaryVMSet, vmSetName) {
-				var foundPrimaryLB bool
-				if lbs != nil {
-					for _, lb := range *lbs {
-						if strings.EqualFold(strings.TrimSuffix(pointer.StringDeref(lb.Name, ""), consts.InternalLoadBalancerNameSuffix), multiSLBConfig.Name) {
-							foundPrimaryLB = true
-							break
-						}
-					}
-				}
-				if !foundPrimaryLB && !strings.EqualFold(strings.TrimSuffix(lbName, consts.InternalLoadBalancerNameSuffix), multiSLBConfig.Name) {
-					klog.V(4).Infof("accommodateNodesByPrimaryVMSet: node(%s) should be on lb(%s) because of primary vmSet (%s), but the lb is not found and will not be created this time, will ignore the primaryVMSet", node.Name, multiSLBConfig.Name, vmSetName)
-					continue
-				}
-
-				az.nodesWithCorrectLoadBalancerByPrimaryVMSet.Store(strings.ToLower(node.Name), sets.Empty{})
-				if !multiSLBConfig.ActiveNodes.Has(node.Name) {
-					klog.V(4).Infof("accommodateNodesByPrimaryVMSet: node(%s) should be on lb(%s) because of primary vmSet (%s)", node.Name, multiSLBConfig.Name, vmSetName)
-
-					az.removeNodeFromLBConfig(nodeNameToLBConfigIDXMap, node.Name)
-
-					az.multipleStandardLoadBalancersActiveNodesLock.Lock()
-					az.MultipleStandardLoadBalancerConfigurations[i].ActiveNodes = safeAddKeyToStringsSet(az.MultipleStandardLoadBalancerConfigurations[i].ActiveNodes, strings.ToLower(node.Name))
-					az.multipleStandardLoadBalancersActiveNodesLock.Unlock()
-				}
-				break
-			}
-		}
-	}
-
-	return nil
-}
-
-// accommodateNodesByNodeSelector decides which load balancer configuration the node should be added to by node selector
-func (az *Cloud) accommodateNodesByNodeSelector(
-	lbName string,
-	lbs *[]network.LoadBalancer,
-	service *v1.Service,
-	nodes []*v1.Node,
-	nodeNameToLBConfigIDXMap map[string]int,
-) error {
-	for _, node := range nodes {
-		// Skip nodes that have been matched with a load balancer
-		// by primary vmSet.
-		if _, ok := az.nodesWithCorrectLoadBalancerByPrimaryVMSet.Load(strings.ToLower(node.Name)); ok {
-			continue
-		}
-
-		// If the vmSet of the node does not match any load balancer,
-		// pick all load balancers whose node selector matches the node.
-		var eligibleLBsIDX []int
-		for i, multiSLBConfig := range az.MultipleStandardLoadBalancerConfigurations {
-			if multiSLBConfig.NodeSelector != nil &&
-				(len(multiSLBConfig.NodeSelector.MatchLabels) > 0 || len(multiSLBConfig.NodeSelector.MatchExpressions) > 0) {
-				nodeSelector, err := metav1.LabelSelectorAsSelector(multiSLBConfig.NodeSelector)
-				if err != nil {
-					klog.Errorf("accommodateNodesByNodeSelector: failed to parse nodeSelector for lb(%s): %s", multiSLBConfig.Name, err.Error())
-					return err
-				}
-				if nodeSelector.Matches(labels.Set(node.Labels)) {
-					var foundLB bool
-					if lbs != nil {
-						for _, lb := range *lbs {
-							if strings.EqualFold(strings.TrimSuffix(pointer.StringDeref(lb.Name, ""), consts.InternalLoadBalancerNameSuffix), multiSLBConfig.Name) {
-								foundLB = true
-								break
-							}
-						}
-					}
-					klog.V(4).Infof("accommodateNodesByNodeSelector: lb(%s) matches node(%s) labels", multiSLBConfig.Name, node.Name)
-					if !foundLB && !strings.EqualFold(strings.TrimSuffix(lbName, consts.InternalLoadBalancerNameSuffix), multiSLBConfig.Name) {
-						klog.V(4).Infof("accommodateNodesByNodeSelector: but the lb is not found and will not be created this time, will ignore this load balancer")
-						continue
-					}
-					eligibleLBsIDX = append(eligibleLBsIDX, i)
-				}
-			}
-		}
-		// If no load balancer is matched, all load balancers without node selector are eligible.
-		if len(eligibleLBsIDX) == 0 {
-			for i, multiSLBConfig := range az.MultipleStandardLoadBalancerConfigurations {
-				if multiSLBConfig.NodeSelector == nil {
-					eligibleLBsIDX = append(eligibleLBsIDX, i)
-				}
-			}
-		}
-		if idx, ok := nodeNameToLBConfigIDXMap[node.Name]; ok {
-			if IntInSlice(idx, eligibleLBsIDX) {
-				klog.V(4).Infof("accommodateNodesByNodeSelector: node(%s) is already on the eligible lb(%s)", node.Name, az.MultipleStandardLoadBalancerConfigurations[idx].Name)
-				continue
-			}
-		}
-
-		// Pick one with the fewest nodes among all eligible load balancers.
-		minNodesIDX := -1
-		minNodes := math.MaxInt32
-		az.multipleStandardLoadBalancersActiveNodesLock.Lock()
-		for _, idx := range eligibleLBsIDX {
-			multiSLBConfig := az.MultipleStandardLoadBalancerConfigurations[idx]
-			if multiSLBConfig.ActiveNodes.Len() < minNodes {
-				minNodes = multiSLBConfig.ActiveNodes.Len()
-				minNodesIDX = idx
-			}
-		}
-		az.multipleStandardLoadBalancersActiveNodesLock.Unlock()
-
-		if idx, ok := nodeNameToLBConfigIDXMap[node.Name]; ok && idx != minNodesIDX {
-			az.removeNodeFromLBConfig(nodeNameToLBConfigIDXMap, node.Name)
-		}
-
-		// Emit a warning for the orphaned node.
-		if minNodesIDX == -1 {
-			warningMsg := fmt.Sprintf("failed to find a lb for node %s", node.Name)
-			az.Event(service, v1.EventTypeWarning, "FailedToFindLoadBalancerForNode", warningMsg)
-			continue
-		}
-
-		klog.V(4).Infof("accommodateNodesByNodeSelector: node(%s) should be on lb(%s) it is the eligible LB with fewest number of nodes", node.Name, az.MultipleStandardLoadBalancerConfigurations[minNodesIDX].Name)
-		az.multipleStandardLoadBalancersActiveNodesLock.Lock()
-		az.MultipleStandardLoadBalancerConfigurations[minNodesIDX].ActiveNodes = safeAddKeyToStringsSet(az.MultipleStandardLoadBalancerConfigurations[minNodesIDX].ActiveNodes, strings.ToLower(node.Name))
-		az.multipleStandardLoadBalancersActiveNodesLock.Unlock()
-	}
-
-	return nil
-}
-
-// reconcileMultipleStandardLoadBalancerBackendNodes makes sure the arrangement of nodes
-// across load balancer configurations is expected. This is used in two places:
-// 1. Every time the cloud provide restarts.
-// 2. Every time we ensure hosts in pool.
-// It consists of two parts. First we put corresponding nodes to the load balancers
-// whose primary vmSet matches the node. Then we put the rest of the nodes to the
-// most eligible load balancers according to the node selector and the number of
-// nodes currently in the load balancer.
-// For availability set (no cache) amd vmss flex (with cache) clusters,
-// a list call will be introduced every time we
-// try to get the vmSet of a node. This is acceptable because of two reasons:
-// 1. In AKS, we don't support multiple availability sets in a cluster so the
-// cluster scale is small. For self-managed clusters, it is not recommended to
-// use multiple standard load balancers with availability sets.
-// 2. We only check nodes that are not matched by primary vmSet before we ensure
-// hosts in pool. So the number API calls is under control.
-func (az *Cloud) reconcileMultipleStandardLoadBalancerBackendNodes(
-	lbName string,
-	lbs *[]network.LoadBalancer,
-	service *v1.Service,
-	nodes []*v1.Node,
-) error {
-	// Remove the nodes from the load balancer configurations if they are not in the node list.
-	nodeNameToLBConfigIDXMap := az.removeDeletedNodesFromLoadBalancerConfigurations(nodes)
-
-	err := az.accommodateNodesByPrimaryVMSet(lbName, lbs, nodes, nodeNameToLBConfigIDXMap)
-	if err != nil {
-		return err
-	}
-
-	err = az.accommodateNodesByNodeSelector(lbName, lbs, service, nodes, nodeNameToLBConfigIDXMap)
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
 func (az *Cloud) reconcileMultipleStandardLoadBalancerConfigurationStatus(wantLb bool, svcName, lbName string) {
 	lbName = strings.TrimSuffix(lbName, consts.InternalLoadBalancerNameSuffix)
 	for i := range az.MultipleStandardLoadBalancerConfigurations {
 		if strings.EqualFold(lbName, az.MultipleStandardLoadBalancerConfigurations[i].Name) {
-			az.multipleStandardLoadBalancersActiveServicesLock.Lock()
 			if az.MultipleStandardLoadBalancerConfigurations[i].ActiveServices == nil {
 				az.MultipleStandardLoadBalancerConfigurations[i].ActiveServices = sets.New[string]()
 			}
 
 			if wantLb {
 				klog.V(4).Infof("reconcileMultipleStandardLoadBalancerConfigurationStatus: service(%s) is active on lb(%s)", svcName, lbName)
-				az.MultipleStandardLoadBalancerConfigurations[i].ActiveServices.Insert(strings.ToLower(svcName))
+				az.MultipleStandardLoadBalancerConfigurations[i].ActiveServices.Insert(svcName)
 			} else {
 				klog.V(4).Infof("reconcileMultipleStandardLoadBalancerConfigurationStatus: service(%s) is not active on lb(%s) any more", svcName, lbName)
-				az.MultipleStandardLoadBalancerConfigurations[i].ActiveServices, _ = safeRemoveKeyFromStringsSet(az.MultipleStandardLoadBalancerConfigurations[i].ActiveServices, strings.ToLower(svcName))
+				az.MultipleStandardLoadBalancerConfigurations[i].ActiveServices.Delete(svcName)
 			}
-			az.multipleStandardLoadBalancersActiveServicesLock.Unlock()
 			break
 		}
 	}
@@ -3036,7 +2730,7 @@ func (az *Cloud) shouldUpdateLoadBalancer(clusterName string, service *v1.Servic
 		return false, fmt.Errorf("shouldUpdateLoadBalancer: failed to list managed load balancers: %w", err)
 	}
 
-	_, _, _, existsLb, _, _ := az.getServiceLoadBalancer(service, clusterName, nodes, false, existingManagedLBs)
+	_, _, _, existsLb, _ := az.getServiceLoadBalancer(service, clusterName, nodes, false, existingManagedLBs)
 	return existsLb && service.ObjectMeta.DeletionTimestamp == nil && service.Spec.Type == v1.ServiceTypeLoadBalancer, nil
 }
 
@@ -3996,13 +3690,13 @@ func (az *Cloud) getAzureLoadBalancerName(
 	// 1. Filter out the eligible load balancers.
 	// 2. Choose the most eligible load balancer.
 	if az.useMultipleStandardLoadBalancers() {
-		eligibleLBs, err := az.getEligibleLoadBalancersForService(service)
+		eligibleLBs, err := az.getEligibleLoadBalancers(service)
 		if err != nil {
 			return "", err
 		}
 
 		currentLBName := az.getServiceCurrentLoadBalancerName(service)
-		lbNamePrefix = getMostEligibleLBForService(currentLBName, eligibleLBs, existingLBs)
+		lbNamePrefix = getMostEligibleLBName(currentLBName, eligibleLBs, existingLBs)
 	}
 
 	if isInternal {
@@ -4011,14 +3705,14 @@ func (az *Cloud) getAzureLoadBalancerName(
 	return lbNamePrefix, nil
 }
 
-func getMostEligibleLBForService(
+func getMostEligibleLBName(
 	currentLBName string,
 	eligibleLBs []string,
 	existingLBs *[]network.LoadBalancer,
 ) string {
 	// 1. If the LB is eligible and being used, choose it.
 	if StringInSlice(currentLBName, eligibleLBs) {
-		klog.V(4).Infof("getMostEligibleLBForService: choose %s as it is eligible and being used", currentLBName)
+		klog.V(4).Infof("getMostEligibleLBName: choose %s as it is eligible and being used", currentLBName)
 		return currentLBName
 	}
 
@@ -4034,7 +3728,7 @@ func getMostEligibleLBForService(
 			}
 		}
 		if !found {
-			klog.V(4).Infof("getMostEligibleLBForService: choose %s as it is eligible and not existing", eligibleLB)
+			klog.V(4).Infof("getMostEligibleLBName: choose %s as it is eligible and not existing", eligibleLB)
 			return eligibleLB
 		}
 	}
@@ -4057,7 +3751,7 @@ func getMostEligibleLBForService(
 	}
 
 	if expectedLBName != "" {
-		klog.V(4).Infof("getMostEligibleLBForService: choose %s with fewest %d rules", expectedLBName, ruleCount)
+		klog.V(4).Infof("getMostEligibleLBName: choose %s with fewest %d rules", expectedLBName, ruleCount)
 	}
 
 	return expectedLBName
@@ -4065,14 +3759,14 @@ func getMostEligibleLBForService(
 
 func (az *Cloud) getServiceCurrentLoadBalancerName(service *v1.Service) string {
 	for _, multiSLBConfig := range az.MultipleStandardLoadBalancerConfigurations {
-		if az.isLoadBalancerInUseByService(service, multiSLBConfig) {
+		if isLoadBalancerInUseByService(service, multiSLBConfig) {
 			return multiSLBConfig.Name
 		}
 	}
 	return ""
 }
 
-// getEligibleLoadBalancersForService filter out the eligible load balancers for the service.
+// getEligibleLoadBalancers filter out the eligible load balancers for the service.
 // It follows four kinds of constraints:
 // 1. Service annotation `service.beta.kubernetes.io/azure-load-balancer-configurations: lb1,lb2`.
 // 2. AllowServicePlacement flag. Default to true, if set to false, the new services will not be put onto the LB.
@@ -4081,7 +3775,7 @@ func (az *Cloud) getServiceCurrentLoadBalancerName(service *v1.Service) string {
 // If there is no ServiceLabel selector on the LB, all services can be valid.
 // 4. ServiceNamespaceSelector. The service will be put onto the LB only if the service is in the namespaces specified in the selector.
 // If there is no ServiceNamespace selector on the LB, all services can be valid.
-func (az *Cloud) getEligibleLoadBalancersForService(service *v1.Service) ([]string, error) {
+func (az *Cloud) getEligibleLoadBalancers(service *v1.Service) ([]string, error) {
 	var (
 		eligibleLBs               []MultipleStandardLoadBalancerConfiguration
 		eligibleLBNames           []string
@@ -4098,16 +3792,13 @@ func (az *Cloud) getEligibleLoadBalancersForService(service *v1.Service) ([]stri
 		lbNamesSet := sets.New[string](lbsFromAnnotation...)
 		for _, multiSLBConfig := range az.MultipleStandardLoadBalancerConfigurations {
 			if lbNamesSet.Has(strings.ToLower(multiSLBConfig.Name)) {
-				klog.V(4).Infof("getEligibleLoadBalancersForService: service %q selects load balancer %q by annotation", service.Name, multiSLBConfig.Name)
+				klog.V(4).Infof("getEligibleLoadBalancers: service %q selects load balancer %q by annotation", service.Name, multiSLBConfig.Name)
 				eligibleLBs = append(eligibleLBs, multiSLBConfig)
 				lbSelectedByAnnotation = append(lbSelectedByAnnotation, multiSLBConfig.Name)
 			}
 		}
-		if len(lbSelectedByAnnotation) == 0 {
-			return nil, fmt.Errorf("service %q selects %d load balancers by annotation, but none of them is defined in cloud provider configuration", service.Name, len(lbsFromAnnotation))
-		}
 	} else {
-		klog.V(4).Infof("getEligibleLoadBalancersForService: service %q does not select any load balancer by annotation, all load balancers are eligible", service.Name)
+		klog.V(4).Infof("getEligibleLoadBalancers: service %q does not select any load balancer by annotation, all load balancers are eligible", service.Name)
 		eligibleLBs = append(eligibleLBs, az.MultipleStandardLoadBalancerConfigurations...)
 		for _, eligibleLB := range eligibleLBs {
 			lbSelectedByAnnotation = append(lbSelectedByAnnotation, eligibleLB.Name)
@@ -4120,10 +3811,10 @@ func (az *Cloud) getEligibleLoadBalancersForService(service *v1.Service) ([]stri
 		// 2. If the LB does not allow service placement, it is not eligible,
 		// unless the service is already using the LB.
 		if !pointer.BoolDeref(eligibleLB.AllowServicePlacement, true) {
-			if az.isLoadBalancerInUseByService(service, eligibleLB) {
-				klog.V(4).Infof("getEligibleLoadBalancersForService: although load balancer %q has AllowServicePlacement=false, service %q is allowed to be placed on load balancer %q because it is using the load balancer", eligibleLB.Name, service.Name, eligibleLB.Name)
+			if isLoadBalancerInUseByService(service, eligibleLB) {
+				klog.V(4).Infof("getEligibleLoadBalancers: although load balancer %q has AllowServicePlacement=false, service %q is allowed to be placed on load balancer %q because it is using the load balancer", eligibleLB.Name, service.Name, eligibleLB.Name)
 			} else {
-				klog.V(4).Infof("getEligibleLoadBalancersForService: service %q is not allowed to be placed on load balancer %q", service.Name, eligibleLB.Name)
+				klog.V(4).Infof("getEligibleLoadBalancers: service %q is not allowed to be placed on load balancer %q", service.Name, eligibleLB.Name)
 				eligibleLBs = append(eligibleLBs[:i], eligibleLBs[i+1:]...)
 				lbFailedPlacementFlag = append(lbFailedPlacementFlag, eligibleLB.Name)
 				continue
@@ -4139,7 +3830,7 @@ func (az *Cloud) getEligibleLoadBalancersForService(service *v1.Service) ([]stri
 				return []string{}, err
 			}
 			if !serviceLabelSelector.Matches(labels.Set(service.Labels)) {
-				klog.V(2).Infof("getEligibleLoadBalancersForService: service %q does not match label selector %q for load balancer %q", service.Name, eligibleLB.ServiceLabelSelector.String(), eligibleLB.Name)
+				klog.V(2).Infof("getEligibleLoadBalancers: service %q does not match label selector %q for load balancer %q", service.Name, eligibleLB.ServiceLabelSelector.String(), eligibleLB.Name)
 				eligibleLBs = append(eligibleLBs[:i], eligibleLBs[i+1:]...)
 				lbFailedLabelSelector = append(lbFailedLabelSelector, eligibleLB.Name)
 				continue
@@ -4160,7 +3851,7 @@ func (az *Cloud) getEligibleLoadBalancersForService(service *v1.Service) ([]stri
 				return []string{}, err
 			}
 			if !serviceNamespaceSelector.Matches(labels.Set(ns.Labels)) {
-				klog.V(2).Infof("getEligibleLoadBalancersForService: namespace %q does not match namespace selector %q for load balancer %q", service.Namespace, eligibleLB.ServiceNamespaceSelector.String(), eligibleLB.Name)
+				klog.V(2).Infof("getEligibleLoadBalancers: namespace %q does not match namespace selector %q for load balancer %q", service.Namespace, eligibleLB.ServiceNamespaceSelector.String(), eligibleLB.Name)
 				eligibleLBs = append(eligibleLBs[:i], eligibleLBs[i+1:]...)
 				lbFailedNamespaceSelector = append(lbFailedNamespaceSelector, eligibleLB.Name)
 				continue
@@ -4191,10 +3882,7 @@ func (az *Cloud) getEligibleLoadBalancersForService(service *v1.Service) ([]stri
 	return eligibleLBNames, nil
 }
 
-func (az *Cloud) isLoadBalancerInUseByService(service *v1.Service, lbConfig MultipleStandardLoadBalancerConfiguration) bool {
-	az.multipleStandardLoadBalancersActiveServicesLock.Lock()
-	defer az.multipleStandardLoadBalancersActiveServicesLock.Unlock()
-
+func isLoadBalancerInUseByService(service *v1.Service, lbConfig MultipleStandardLoadBalancerConfiguration) bool {
 	serviceName := getServiceName(service)
 	if lbConfig.ActiveServices != nil {
 		return lbConfig.ActiveServices.Has(serviceName)
diff --git a/pkg/provider/azure_loadbalancer_backendpool.go b/pkg/provider/azure_loadbalancer_backendpool.go
index 162832319..964e78abb 100644
--- a/pkg/provider/azure_loadbalancer_backendpool.go
+++ b/pkg/provider/azure_loadbalancer_backendpool.go
@@ -196,7 +196,7 @@ func (bc *backendPoolTypeNodeIPConfig) ReconcileBackendPools(clusterName string,
 			if bp.BackendAddressPoolPropertiesFormat != nil &&
 				bp.LoadBalancerBackendAddresses != nil &&
 				len(*bp.LoadBalancerBackendAddresses) > 0 {
-				if removeNodeIPAddressesFromBackendPool(bp, []string{}, true, false) {
+				if removeNodeIPAddressesFromBackendPool(bp, []string{}, true) {
 					isMigration = true
 					bp.VirtualNetwork = nil
 					if err := bc.CreateOrUpdateLBBackendPool(lbName, bp); err != nil {
@@ -395,15 +395,7 @@ func (bi *backendPoolTypeNodeIP) EnsureHostsInPool(service *v1.Service, nodes []
 	var (
 		changed               bool
 		numOfAdd, numOfDelete int
-		activeNodes           sets.Set[string]
 	)
-	if bi.useMultipleStandardLoadBalancers() {
-		activeNodes = bi.getActiveNodesByLoadBalancerName(lbName)
-		if activeNodes == nil {
-			activeNodes = sets.New[string]()
-		}
-	}
-
 	lbBackendPoolName := getBackendPoolName(clusterName, isIPv6)
 	if strings.EqualFold(pointer.StringDeref(backendPool.Name, ""), lbBackendPoolName) &&
 		backendPool.BackendAddressPoolPropertiesFormat != nil {
@@ -434,14 +426,6 @@ func (bi *backendPoolTypeNodeIP) EnsureHostsInPool(service *v1.Service, nodes []
 
 			privateIP := getNodePrivateIPAddress(node, isIPv6)
 			nodePrivateIPsSet.Insert(privateIP)
-
-			if bi.useMultipleStandardLoadBalancers() {
-				if activeNodes == nil || !activeNodes.Has(node.Name) {
-					klog.V(4).Infof("bi.EnsureHostsInPool: node %s should not be in load balancer %q", node.Name, lbName)
-					continue
-				}
-			}
-
 			if !existingIPs.Has(privateIP) {
 				name := node.Name
 				if utilnet.IsIPv6String(privateIP) {
@@ -464,25 +448,13 @@ func (bi *backendPoolTypeNodeIP) EnsureHostsInPool(service *v1.Service, nodes []
 		for _, loadBalancerBackendAddress := range *backendPool.LoadBalancerBackendAddresses {
 			ip := pointer.StringDeref(loadBalancerBackendAddress.IPAddress, "")
 			if !nodePrivateIPsSet.Has(ip) {
-				klog.V(4).Infof("bi.EnsureHostsInPool: removing IP %s because it is deleted or should be excluded", ip)
+				klog.V(4).Infof("bi.EnsureHostsInPool: removing IP %s", ip)
 				nodeIPsToBeDeleted = append(nodeIPsToBeDeleted, ip)
 				changed = true
 				numOfDelete++
-			} else if bi.useMultipleStandardLoadBalancers() && activeNodes != nil {
-				nodeName, ok := bi.nodePrivateIPToNodeNameMap[ip]
-				if !ok {
-					klog.Warningf("bi.EnsureHostsInPool: cannot find node name for private IP %s", ip)
-					continue
-				}
-				if !activeNodes.Has(nodeName) {
-					klog.V(4).Infof("bi.EnsureHostsInPool: removing IP %s because it should not be in this load balancer", ip)
-					nodeIPsToBeDeleted = append(nodeIPsToBeDeleted, ip)
-					changed = true
-					numOfDelete++
-				}
 			}
 		}
-		removeNodeIPAddressesFromBackendPool(backendPool, nodeIPsToBeDeleted, false, bi.useMultipleStandardLoadBalancers())
+		removeNodeIPAddressesFromBackendPool(backendPool, nodeIPsToBeDeleted, false)
 	}
 	if changed {
 		klog.V(2).Infof("bi.EnsureHostsInPool: updating backend pool %s of load balancer %s to add %d nodes and remove %d nodes", lbBackendPoolName, lbName, numOfAdd, numOfDelete)
@@ -656,7 +628,7 @@ func (bi *backendPoolTypeNodeIP) ReconcileBackendPools(clusterName string, servi
 				}
 			}
 			if len(nodeIPAddressesToBeDeleted) > 0 {
-				if removeNodeIPAddressesFromBackendPool(bp, nodeIPAddressesToBeDeleted, false, false) {
+				if removeNodeIPAddressesFromBackendPool(bp, nodeIPAddressesToBeDeleted, false) {
 					updated = true
 				}
 			}
@@ -772,11 +744,7 @@ func newBackendPool(lb *network.LoadBalancer, isBackendPoolPreConfigured bool, p
 	return isBackendPoolPreConfigured
 }
 
-func removeNodeIPAddressesFromBackendPool(
-	backendPool network.BackendAddressPool,
-	nodeIPAddresses []string,
-	removeAll, useMultipleStandardLoadBalancers bool,
-) bool {
+func removeNodeIPAddressesFromBackendPool(backendPool network.BackendAddressPool, nodeIPAddresses []string, removeAll bool) bool {
 	changed := false
 	nodeIPsSet := sets.New(nodeIPAddresses...)
 
@@ -806,9 +774,7 @@ func removeNodeIPAddressesFromBackendPool(
 		return changed
 	}
 
-	// Allow the pool to be empty when EnsureHostsInPool for multiple standard load balancers clusters,
-	// or one node could occur in multiple backend pools.
-	if len(addresses) == 0 && !useMultipleStandardLoadBalancers {
+	if len(addresses) == 0 {
 		klog.V(2).Info("removeNodeIPAddressFromBackendPool: the pool is empty or will be empty after removing the unwanted IP addresses, skipping the removal")
 		changed = false
 	} else if changed {
diff --git a/pkg/provider/azure_utils.go b/pkg/provider/azure_utils.go
index eef784774..d038fc4ce 100644
--- a/pkg/provider/azure_utils.go
+++ b/pkg/provider/azure_utils.go
@@ -26,7 +26,6 @@ import (
 	"github.com/Azure/azure-sdk-for-go/services/network/mgmt/2022-07-01/network"
 
 	v1 "k8s.io/api/core/v1"
-	"k8s.io/apimachinery/pkg/util/sets"
 	"k8s.io/klog/v2"
 	utilnet "k8s.io/utils/net"
 	"k8s.io/utils/pointer"
@@ -548,35 +547,3 @@ func stringSlice(s *[]string) []string {
 	}
 	return nil
 }
-
-// IntInSlice checks if an int is in a list
-func IntInSlice(i int, list []int) bool {
-	for _, item := range list {
-		if item == i {
-			return true
-		}
-	}
-	return false
-}
-
-func safeAddKeyToStringsSet(set sets.Set[string], key string) sets.Set[string] {
-	if set != nil {
-		set.Insert(key)
-	} else {
-		set = sets.New[string](key)
-	}
-
-	return set
-}
-
-func safeRemoveKeyFromStringsSet(set sets.Set[string], key string) (sets.Set[string], bool) {
-	var has bool
-	if set != nil {
-		if set.Has(key) {
-			has = true
-		}
-		set.Delete(key)
-	}
-
-	return set, has
-}


Test patch:
diff --git a/.pipelines/scripts/run-e2e.sh b/.pipelines/scripts/run-e2e.sh
index 1b2a4dca9..1bb767283 100755
--- a/.pipelines/scripts/run-e2e.sh
+++ b/.pipelines/scripts/run-e2e.sh
@@ -59,10 +59,6 @@ get_k8s_version() {
 }
 
 cleanup() {
-  if [[ "${SKIP_COLLECT_LOG_AND_CLEAN_UP:-}" == "true" ]]; then
-    return
-  fi
-
   if [[ -n ${KUBECONFIG:-} ]]; then
       kubectl get node -owide || echo "Unable to get nodes"
       kubectl get pod --all-namespaces=true -owide || echo "Unable to get pods"
@@ -96,51 +92,43 @@ if [[ -z "${CLUSTER_CONFIG_PATH:-}" ]]; then
     export AZURE_LOADBALANCER_SKU=standard
   fi
 fi
-echo "Choose cluster config file: ${CLUSTER_CONFIG_PATH:-}"
 
-if [[ -z "${CUSTOM_CONFIG_PATH:-}" ]]; then
-  # basic-lb and vmas
-  CUSTOM_CONFIG_PATH="${REPO_ROOT}/.pipelines/templates/customconfiguration.json"
-  if [[ "${CLUSTER_TYPE:-}" == "autoscaling" ]]; then
-    CUSTOM_CONFIG_PATH="${REPO_ROOT}/.pipelines/templates/customconfiguration-autoscaling.json"
-  elif [[ "${CLUSTER_TYPE:-}" == "autoscaling-multipool" ]]; then
-    CUSTOM_CONFIG_PATH="${REPO_ROOT}/.pipelines/templates/customconfiguration-autoscaling-multipool.json"
-  fi
+# basic-lb and vmas
+CUSTOM_CONFIG_PATH="${CUSTOM_CONFIG_PATH:-${REPO_ROOT}/.pipelines/templates/customconfiguration.json}"
+if [[ "${CLUSTER_TYPE:-}" == "autoscaling" ]]; then
+  CUSTOM_CONFIG_PATH="${CUSTOM_CONFIG_PATH:-${REPO_ROOT}/.pipelines/templates/customconfiguration-autoscaling.json}"
+elif [[ "${CLUSTER_TYPE:-}" == "autoscaling-multipool" ]]; then
+  CUSTOM_CONFIG_PATH="${CUSTOM_CONFIG_PATH:-${REPO_ROOT}/.pipelines/templates/customconfiguration-autoscaling-multipool.json}"
 fi
-echo "Choose custom config file: ${CUSTOM_CONFIG_PATH:-}"
 
-if [[ "${SKIP_BUILD_KUBETEST2_AKS:-}" != "true" ]]; then
-  rm -rf kubetest2-aks
-  git clone https://github.com/kubernetes-sigs/cloud-provider-azure.git
-  cp -r cloud-provider-azure/kubetest2-aks .
-  rm -rf cloud-provider-azure
-  git config --global --add safe.directory "$(pwd)" || true
-  pushd kubetest2-aks
-  go get -d sigs.k8s.io/kubetest2@latest
-  go install sigs.k8s.io/kubetest2@latest
-  go mod tidy
-  make deployer
-  if [[ -n "${RELEASE_PIPELINE:-}" ]]; then
-    make install
-  else
-    sudo GOPATH="/home/vsts/go" make install
-  fi
-  popd
+rm -rf kubetest2-aks
+git clone https://github.com/kubernetes-sigs/cloud-provider-azure.git
+cp -r cloud-provider-azure/kubetest2-aks .
+rm -rf cloud-provider-azure
+git config --global --add safe.directory "$(pwd)" || true
+pushd kubetest2-aks
+go get -d sigs.k8s.io/kubetest2@latest
+go install sigs.k8s.io/kubetest2@latest
+go mod tidy
+make deployer
+if [[ -n "${RELEASE_PIPELINE:-}" ]]; then
+  make install
+else
+  sudo GOPATH="/home/vsts/go" make install
 fi
+popd
 
 get_k8s_version
 echo "AKS Kubernetes version is: ${AKS_KUBERNETES_VERSION:-}"
 
-if [[ "${SKIP_BUILD_KUBETEST2_AKS:-}" != "true" ]]; then
-  if [[ -n "${RELEASE_PIPELINE:-}" ]]; then
-    rm -rf kubetest2-aks
-    if [[ "${AKS_KUBERNETES_VERSION:-}" < "1.24" ]]; then
-      go mod tidy -compat=1.17
-    else
-      go mod tidy
-    fi
-    go mod vendor
+if [[ -n "${RELEASE_PIPELINE:-}" ]]; then
+  rm -rf kubetest2-aks
+  if [[ "${AKS_KUBERNETES_VERSION:-}" < "1.24" ]]; then
+    go mod tidy -compat=1.17
+  else
+    go mod tidy
   fi
+  go mod vendor
 fi
 
 kubetest2 aks --up --rgName "${RESOURCE_GROUP:-}" \
@@ -169,21 +157,11 @@ done
 kubectl wait --for=condition=Ready node --all --timeout=5m
 kubectl get node -owide
 
-if [[ "${CLUSTER_TYPE:-}" =~ "autoscaling" ]]; then
-  az aks update --subscription ${AZURE_SUBSCRIPTION_ID:-} --resource-group "${RESOURCE_GROUP:-}" --name "${CLUSTER_NAME:-}" \
-    --cluster-autoscaler-profile skip-nodes-with-system-pods=false scale-down-delay-after-add=1m scale-down-unneeded-time=1m scale-down-unready-time=2m
-  if [[ "${CLUSTER_TYPE:-}" == "autoscaling-multipool" ]]; then
-    az aks update --subscription ${AZURE_SUBSCRIPTION_ID:-} --resource-group "${RESOURCE_GROUP:-}" --name "${CLUSTER_NAME:-}" \
-      --cluster-autoscaler-profile balance-similar-node-groups=true
-  fi
-fi
+echo "Running e2e"
 
-if [[ "${SKIP_E2E:-}" != "true" ]]; then
-  echo "Running e2e"
-  export E2E_ON_AKS_CLUSTER=true
-  if [[ "${CLUSTER_TYPE:-}" =~ "autoscaling" ]]; then
-    export LABEL_FILTER=${LABEL_FILTER:-Feature:Autoscaling || !Serial && !Slow}
-    export SKIP_ARGS=${SKIP_ARGS:-""}
-  fi
-  make test-ccm-e2e
+export E2E_ON_AKS_CLUSTER=true
+if [[ "${CLUSTER_TYPE:-}" =~ "autoscaling" ]]; then
+  export LABEL_FILTER=${LABEL_FILTER:-Feature:Autoscaling || !Serial && !Slow}
+  export SKIP_ARGS=${SKIP_ARGS:-""}
 fi
+make test-ccm-e2e
diff --git a/kubetest2-aks/go.mod b/kubetest2-aks/go.mod
index f75d4e2f8..4fd03e761 100644
--- a/kubetest2-aks/go.mod
+++ b/kubetest2-aks/go.mod
@@ -3,7 +3,7 @@ module sigs.k8s.io/cloud-provider-azure/kubetest2-aks
 go 1.18
 
 require (
-	github.com/Azure/azure-sdk-for-go/sdk/azcore v1.7.0
+	github.com/Azure/azure-sdk-for-go/sdk/azcore v1.6.1
 	github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.3.0
 	github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/containerservice/armcontainerservice/v2 v2.4.0
 	github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/resources/armresources v1.1.1
diff --git a/kubetest2-aks/go.sum b/kubetest2-aks/go.sum
index 44b20f313..6b4180ee4 100644
--- a/kubetest2-aks/go.sum
+++ b/kubetest2-aks/go.sum
@@ -1,5 +1,5 @@
-github.com/Azure/azure-sdk-for-go/sdk/azcore v1.7.0 h1:8q4SaHjFsClSvuVne0ID/5Ka8u3fcIHyqkLjcFpNRHQ=
-github.com/Azure/azure-sdk-for-go/sdk/azcore v1.7.0/go.mod h1:bjGvMhVMb+EEm3VRNQawDMUyMMjo+S5ewNjflkep/0Q=
+github.com/Azure/azure-sdk-for-go/sdk/azcore v1.6.1 h1:SEy2xmstIphdPwNBUi7uhvjyjhVKISfwjfOJmuy7kg4=
+github.com/Azure/azure-sdk-for-go/sdk/azcore v1.6.1/go.mod h1:bjGvMhVMb+EEm3VRNQawDMUyMMjo+S5ewNjflkep/0Q=
 github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.3.0 h1:vcYCAze6p19qBW7MhZybIsqD8sMV8js0NyQM8JDnVtg=
 github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.3.0/go.mod h1:OQeznEEkTZ9OrhHJoDD8ZDq51FHgXjqtP9z6bEwBq9U=
 github.com/Azure/azure-sdk-for-go/sdk/internal v1.3.0 h1:sXr+ck84g/ZlZUOZiNELInmMgOsuGwdjjVkEIde0OtY=
diff --git a/pkg/azclient/policy/etag/etag_suite_test.go b/pkg/azclient/policy/etag/etag_suite_test.go
deleted file mode 100644
index 618d56cbf..000000000
--- a/pkg/azclient/policy/etag/etag_suite_test.go
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
-Copyright 2023 The Kubernetes Authors.
-
-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 etag_test
-
-import (
-	"testing"
-
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-)
-
-func TestEtag(t *testing.T) {
-	RegisterFailHandler(Fail)
-	RunSpecs(t, "Etag Suite")
-}
diff --git a/pkg/azclient/policy/etag/etag_test.go b/pkg/azclient/policy/etag/etag_test.go
deleted file mode 100644
index a256494f6..000000000
--- a/pkg/azclient/policy/etag/etag_test.go
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
-Copyright 2023 The Kubernetes Authors.
-
-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 etag_test
-
-import (
-	"context"
-	"net/http"
-	"strings"
-
-	"github.com/Azure/azure-sdk-for-go/sdk/azcore/policy"
-	"github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime"
-	"github.com/Azure/azure-sdk-for-go/sdk/azcore/streaming"
-	. "github.com/onsi/ginkgo/v2"
-	. "github.com/onsi/gomega"
-	"sigs.k8s.io/cloud-provider-azure/pkg/azclient/policy/etag"
-	"sigs.k8s.io/cloud-provider-azure/pkg/azclient/utils"
-)
-
-var _ = Describe("Etag", func() {
-	Describe("AppendEtag", func() {
-		It("should append etag", func() {
-			pipeline := runtime.NewPipeline("testmodule", "v0.1.0", runtime.PipelineOptions{}, &policy.ClientOptions{
-				PerCallPolicies: []policy.Policy{
-					utils.FuncPolicyWrapper(etag.AppendEtag),
-					utils.FuncPolicyWrapper(
-						func(req *policy.Request) (*http.Response, error) {
-							Expect(req.Raw().Header.Get("If-Match")).To(Equal("etag"))
-							return nil, nil
-						},
-					),
-				},
-			})
-			req, err := runtime.NewRequest(context.Background(), http.MethodPut, "http://localhost:8080")
-			Expect(err).NotTo(HaveOccurred())
-			err = req.SetBody(streaming.NopCloser(strings.NewReader(`{"etag":"etag"}`)), "application/json")
-			Expect(err).NotTo(HaveOccurred())
-			_, err = pipeline.Do(req)
-			Expect(err).NotTo(HaveOccurred())
-		})
-	})
-})
diff --git a/pkg/provider/azure_instances_test.go b/pkg/provider/azure_instances_test.go
index a13334131..48f0de8e4 100644
--- a/pkg/provider/azure_instances_test.go
+++ b/pkg/provider/azure_instances_test.go
@@ -24,6 +24,7 @@ import (
 	"strings"
 	"testing"
 
+	"k8s.io/apimachinery/pkg/util/sets"
 	"k8s.io/apimachinery/pkg/util/wait"
 
 	"github.com/Azure/azure-sdk-for-go/services/compute/mgmt/2022-08-01/compute"
@@ -880,7 +881,20 @@ func TestInstanceMetadata(t *testing.T) {
 	ctrl := gomock.NewController(t)
 	defer ctrl.Finish()
 
-	t.Run("", func(t *testing.T) {
+	t.Run("instance not exists", func(t *testing.T) {
+		cloud := GetTestCloud(ctrl)
+		cloud.unmanagedNodes = sets.New("node0")
+
+		meta, err := cloud.InstanceMetadata(context.Background(), &v1.Node{
+			ObjectMeta: metav1.ObjectMeta{
+				Name: "node0",
+			},
+		})
+		assert.NoError(t, err)
+		assert.Equal(t, cloudprovider.InstanceMetadata{}, *meta)
+	})
+
+	t.Run("instance exists", func(t *testing.T) {
 		cloud := GetTestCloud(ctrl)
 		expectedVM := buildDefaultTestVirtualMachine("as", []string{"/subscriptions/subscription/resourceGroups/rg/providers/Microsoft.Network/networkInterfaces/k8s-agentpool1-00000000-nic-1"})
 		expectedVM.HardwareProfile = &compute.HardwareProfile{
diff --git a/pkg/provider/azure_loadbalancer_backendpool_test.go b/pkg/provider/azure_loadbalancer_backendpool_test.go
index e165a9ce9..e757be9ba 100644
--- a/pkg/provider/azure_loadbalancer_backendpool_test.go
+++ b/pkg/provider/azure_loadbalancer_backendpool_test.go
@@ -87,29 +87,11 @@ func TestEnsureHostsInPoolNodeIP(t *testing.T) {
 				},
 			},
 		},
-		{
-			ObjectMeta: metav1.ObjectMeta{
-				Name: "vmss-2",
-			},
-			Status: v1.NodeStatus{
-				Addresses: []v1.NodeAddress{
-					{
-						Type:    v1.NodeInternalIP,
-						Address: "10.0.0.4",
-					},
-					{
-						Type:    v1.NodeInternalIP,
-						Address: "2001::4",
-					},
-				},
-			},
-		},
 	}
 
 	testcases := []struct {
 		desc                string
 		backendPool         network.BackendAddressPool
-		multiSLBConfigs     []MultipleStandardLoadBalancerConfiguration
 		expectedBackendPool network.BackendAddressPool
 	}{
 		{
@@ -147,12 +129,6 @@ func TestEnsureHostsInPoolNodeIP(t *testing.T) {
 								IPAddress: pointer.String("10.0.0.2"),
 							},
 						},
-						{
-							Name: pointer.String("vmss-2"),
-							LoadBalancerBackendAddressPropertiesFormat: &network.LoadBalancerBackendAddressPropertiesFormat{
-								IPAddress: pointer.String("10.0.0.4"),
-							},
-						},
 					},
 				},
 			},
@@ -187,54 +163,6 @@ func TestEnsureHostsInPoolNodeIP(t *testing.T) {
 								IPAddress: pointer.String("2001::2"),
 							},
 						},
-						{
-							Name: pointer.String("vmss-2-IPv6"),
-							LoadBalancerBackendAddressPropertiesFormat: &network.LoadBalancerBackendAddressPropertiesFormat{
-								IPAddress: pointer.String("2001::4"),
-							},
-						},
-					},
-				},
-			},
-		},
-		{
-			desc: "should add correct nodes to the pool and remove unwanted ones when using multi-slb",
-			backendPool: network.BackendAddressPool{
-				Name: pointer.String("kubernetes"),
-				BackendAddressPoolPropertiesFormat: &network.BackendAddressPoolPropertiesFormat{
-					LoadBalancerBackendAddresses: &[]network.LoadBalancerBackendAddress{
-						{
-							LoadBalancerBackendAddressPropertiesFormat: &network.LoadBalancerBackendAddressPropertiesFormat{
-								IPAddress: pointer.String("10.0.0.1"),
-							},
-						},
-						{
-							LoadBalancerBackendAddressPropertiesFormat: &network.LoadBalancerBackendAddressPropertiesFormat{
-								IPAddress: pointer.String("10.0.0.3"),
-							},
-						},
-					},
-				},
-			},
-			multiSLBConfigs: []MultipleStandardLoadBalancerConfiguration{
-				{
-					Name: "kubernetes",
-					MultipleStandardLoadBalancerConfigurationStatus: MultipleStandardLoadBalancerConfigurationStatus{
-						ActiveNodes: sets.New[string]("vmss-2"),
-					},
-				},
-			},
-			expectedBackendPool: network.BackendAddressPool{
-				Name: pointer.String("kubernetes"),
-				BackendAddressPoolPropertiesFormat: &network.BackendAddressPoolPropertiesFormat{
-					VirtualNetwork: &network.SubResource{ID: pointer.String("/subscriptions/subscription/resourceGroups/rg/providers/Microsoft.Network/virtualNetworks/vnet")},
-					LoadBalancerBackendAddresses: &[]network.LoadBalancerBackendAddress{
-						{
-							Name: pointer.String("vmss-2"),
-							LoadBalancerBackendAddressPropertiesFormat: &network.LoadBalancerBackendAddressPropertiesFormat{
-								IPAddress: pointer.String("10.0.0.4"),
-							},
-						},
 					},
 				},
 			},
@@ -243,18 +171,8 @@ func TestEnsureHostsInPoolNodeIP(t *testing.T) {
 
 	for _, tc := range testcases {
 		t.Run(tc.desc, func(t *testing.T) {
-			if len(tc.multiSLBConfigs) > 0 {
-				az.MultipleStandardLoadBalancerConfigurations = tc.multiSLBConfigs
-				az.LoadBalancerSku = consts.LoadBalancerSkuStandard
-				az.nodePrivateIPToNodeNameMap = map[string]string{
-					"10.0.0.2": "vmss-0",
-					"2001::2":  "vmss-0",
-					"10.0.0.1": "vmss-1",
-					"2001::1":  "vmss-1",
-					"10.0.0.4": "vmss-2",
-					"2001::4":  "vmss-2",
-				}
-			}
+			mockVMSet := NewMockVMSet(ctrl)
+			az.VMSet = mockVMSet
 
 			lbClient := mockloadbalancerclient.NewMockInterface(ctrl)
 			lbClient.EXPECT().CreateOrUpdateBackendPools(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).Return(nil)
@@ -794,7 +712,7 @@ func buildTestLoadBalancerBackendPoolWithIPs(name string, ips []string) network.
 func TestRemoveNodeIPAddressFromBackendPool(t *testing.T) {
 	for _, tc := range []struct {
 		description                           string
-		removeAll, useMultiSLB                bool
+		removeAll                             bool
 		unwantedIPs, existingIPs, expectedIPs []string
 	}{
 		{
@@ -809,13 +727,6 @@ func TestRemoveNodeIPAddressFromBackendPool(t *testing.T) {
 			existingIPs: []string{"1.2.3.4", "4.3.2.1"},
 			expectedIPs: []string{"1.2.3.4", "4.3.2.1"},
 		},
-		{
-			description: "removeNodeIPAddressFromBackendPool should make the backend pool empty for multi-SLB",
-			unwantedIPs: []string{"1.2.3.4", "4.3.2.1"},
-			existingIPs: []string{"1.2.3.4", "4.3.2.1"},
-			useMultiSLB: true,
-			expectedIPs: []string{},
-		},
 		{
 			description: "removeNodeIPAddressFromBackendPool should remove all the IP addresses from the backend pool",
 			removeAll:   true,
@@ -828,7 +739,7 @@ func TestRemoveNodeIPAddressFromBackendPool(t *testing.T) {
 			backendPool := buildTestLoadBalancerBackendPoolWithIPs("kubernetes", tc.existingIPs)
 			expectedBackendPool := buildTestLoadBalancerBackendPoolWithIPs("kubernetes", tc.expectedIPs)
 
-			removeNodeIPAddressesFromBackendPool(backendPool, tc.unwantedIPs, tc.removeAll, tc.useMultiSLB)
+			removeNodeIPAddressesFromBackendPool(backendPool, tc.unwantedIPs, tc.removeAll)
 			assert.Equal(t, expectedBackendPool, backendPool)
 		})
 	}
diff --git a/pkg/provider/azure_loadbalancer_test.go b/pkg/provider/azure_loadbalancer_test.go
index db6238f1c..925f570cb 100644
--- a/pkg/provider/azure_loadbalancer_test.go
+++ b/pkg/provider/azure_loadbalancer_test.go
@@ -1792,7 +1792,7 @@ func TestGetServiceLoadBalancerCommon(t *testing.T) {
 			}
 			az.LoadBalancerSku = test.sku
 			service := test.service
-			lb, status, _, exists, _, err := az.getServiceLoadBalancer(&service, testClusterName,
+			lb, status, _, exists, err := az.getServiceLoadBalancer(&service, testClusterName,
 				clusterResources.nodes, test.wantLB, []network.LoadBalancer{})
 			assert.Equal(t, test.expectedLB, lb)
 			assert.Equal(t, test.expectedStatus, status)
@@ -1825,7 +1825,7 @@ func TestGetServiceLoadBalancerWithExtendedLocation(t *testing.T) {
 	mockLBsClient.EXPECT().List(gomock.Any(), "rg").Return(nil, nil)
 	az.LoadBalancerClient = mockLBsClient
 
-	lb, status, _, exists, _, err := az.getServiceLoadBalancer(&service, testClusterName,
+	lb, status, _, exists, err := az.getServiceLoadBalancer(&service, testClusterName,
 		clusterResources.nodes, false, []network.LoadBalancer{})
 	assert.Equal(t, expectedLB, lb, "GetServiceLoadBalancer shall return a default LB with expected location.")
 	assert.Nil(t, status, "GetServiceLoadBalancer: Status should be nil for default LB.")
@@ -1850,7 +1850,7 @@ func TestGetServiceLoadBalancerWithExtendedLocation(t *testing.T) {
 	mockLBsClient.EXPECT().List(gomock.Any(), "rg").Return(nil, nil)
 	az.LoadBalancerClient = mockLBsClient
 
-	lb, status, _, exists, _, err = az.getServiceLoadBalancer(&service, testClusterName,
+	lb, status, _, exists, err = az.getServiceLoadBalancer(&service, testClusterName,
 		clusterResources.nodes, true, []network.LoadBalancer{})
 	assert.Equal(t, expectedLB, lb, "GetServiceLoadBalancer shall return a new LB with expected location.")
 	assert.Nil(t, status, "GetServiceLoadBalancer: Status should be nil for new LB.")
@@ -6321,7 +6321,7 @@ func TestRemoveFrontendIPConfigurationFromLoadBalancerDelete(t *testing.T) {
 		mockPLSClient := cloud.PrivateLinkServiceClient.(*mockprivatelinkserviceclient.MockInterface)
 		mockPLSClient.EXPECT().List(gomock.Any(), "rg").Return(expectedPLS, nil).MaxTimes(1)
 		existingLBs := []network.LoadBalancer{{Name: pointer.String("lb")}}
-		_, err := cloud.removeFrontendIPConfigurationFromLoadBalancer(&lb, existingLBs, []*network.FrontendIPConfiguration{fip}, "testCluster", &service)
+		err := cloud.removeFrontendIPConfigurationFromLoadBalancer(&lb, existingLBs, []*network.FrontendIPConfiguration{fip}, "testCluster", &service)
 		assert.NoError(t, err)
 	})
 }
@@ -6352,7 +6352,7 @@ func TestRemoveFrontendIPConfigurationFromLoadBalancerUpdate(t *testing.T) {
 		expectedPLS := make([]network.PrivateLinkService, 0)
 		mockPLSClient := cloud.PrivateLinkServiceClient.(*mockprivatelinkserviceclient.MockInterface)
 		mockPLSClient.EXPECT().List(gomock.Any(), "rg").Return(expectedPLS, nil).MaxTimes(1)
-		_, err := cloud.removeFrontendIPConfigurationFromLoadBalancer(&lb, []network.LoadBalancer{}, []*network.FrontendIPConfiguration{fip}, "testCluster", &service)
+		err := cloud.removeFrontendIPConfigurationFromLoadBalancer(&lb, []network.LoadBalancer{}, []*network.FrontendIPConfiguration{fip}, "testCluster", &service)
 		assert.NoError(t, err)
 	})
 }
@@ -7038,14 +7038,10 @@ func TestSafeDeleteLoadBalancer(t *testing.T) {
 	cloud := GetTestCloud(ctrl)
 
 	testCases := []struct {
-		desc                          string
-		expectedDeleteCall            bool
-		expectedDecoupleErr           error
-		multiSLBConfigs               []MultipleStandardLoadBalancerConfiguration
-		nodesWithCorrectVMSet         sets.Set[string]
-		expectedMultiSLBConfigs       []MultipleStandardLoadBalancerConfiguration
-		expectedNodesWithCorrectVMSet sets.Set[string]
-		expectedErr                   *retry.Error
+		desc                string
+		expectedDeleteCall  bool
+		expectedDecoupleErr error
+		expectedErr         *retry.Error
 	}{
 		{
 			desc:               "Standard SKU: should delete the load balancer",
@@ -7061,40 +7057,6 @@ func TestSafeDeleteLoadBalancer(t *testing.T) {
 				fmt.Errorf("safeDeleteLoadBalancer: failed to EnsureBackendPoolDeleted: %w", errors.New("error")),
 			),
 		},
-		{
-			desc:               "should cleanup active nodes when using multi-slb",
-			expectedDeleteCall: true,
-			multiSLBConfigs: []MultipleStandardLoadBalancerConfiguration{
-				{
-					Name: "test",
-					MultipleStandardLoadBalancerConfigurationStatus: MultipleStandardLoadBalancerConfigurationStatus{
-						ActiveNodes: sets.New[string]("node1", "node2"),
-					},
-				},
-				{
-					Name: "test2",
-					MultipleStandardLoadBalancerConfigurationStatus: MultipleStandardLoadBalancerConfigurationStatus{
-						ActiveNodes: sets.New[string]("node3"),
-					},
-				},
-			},
-			nodesWithCorrectVMSet: sets.New[string]("node1", "node2", "node3"),
-			expectedMultiSLBConfigs: []MultipleStandardLoadBalancerConfiguration{
-				{
-					Name: "test",
-					MultipleStandardLoadBalancerConfigurationStatus: MultipleStandardLoadBalancerConfigurationStatus{
-						ActiveNodes: sets.New[string](),
-					},
-				},
-				{
-					Name: "test2",
-					MultipleStandardLoadBalancerConfigurationStatus: MultipleStandardLoadBalancerConfigurationStatus{
-						ActiveNodes: sets.New[string]("node3"),
-					},
-				},
-			},
-			expectedNodesWithCorrectVMSet: sets.New[string]("node3"),
-		},
 	}
 
 	for _, tc := range testCases {
@@ -7113,12 +7075,6 @@ func TestSafeDeleteLoadBalancer(t *testing.T) {
 			).Return(false, tc.expectedDecoupleErr)
 			cloud.VMSet = mockVMSet
 			cloud.LoadBalancerClient = mockLBClient
-			if len(tc.multiSLBConfigs) > 0 {
-				cloud.MultipleStandardLoadBalancerConfigurations = tc.multiSLBConfigs
-				for nodeName := range tc.nodesWithCorrectVMSet {
-					cloud.nodesWithCorrectLoadBalancerByPrimaryVMSet.Store(nodeName, sets.Empty{})
-				}
-			}
 			svc := getTestService("svc", v1.ProtocolTCP, nil, false, 80)
 			lb := network.LoadBalancer{
 				Name: pointer.String("test"),
@@ -7128,15 +7084,6 @@ func TestSafeDeleteLoadBalancer(t *testing.T) {
 			}
 			err := cloud.safeDeleteLoadBalancer(lb, "cluster", "vmss", &svc)
 			assert.Equal(t, tc.expectedErr, err)
-			if len(tc.multiSLBConfigs) > 0 {
-				assert.Equal(t, tc.expectedMultiSLBConfigs, cloud.MultipleStandardLoadBalancerConfigurations)
-				actualNodesWithCorrectLoadBalancerByPrimaryVMSet := sets.New[string]()
-				cloud.nodesWithCorrectLoadBalancerByPrimaryVMSet.Range(func(key, value interface{}) bool {
-					actualNodesWithCorrectLoadBalancerByPrimaryVMSet.Insert(key.(string))
-					return true
-				})
-				assert.Equal(t, tc.expectedNodesWithCorrectVMSet, actualNodesWithCorrectLoadBalancerByPrimaryVMSet)
-			}
 		})
 	}
 }
@@ -7204,21 +7151,6 @@ func TestGetEligibleLoadBalancers(t *testing.T) {
 			},
 			expectedLBs: []string{"a"},
 		},
-		{
-			description: "should report an error if a service selects a load balancer that is not defined in the configuration",
-			svc:         getTestService("test", v1.ProtocolTCP, map[string]string{consts.ServiceAnnotationLoadBalancerConfigurations: "b"}, false),
-			lbConfigs: []MultipleStandardLoadBalancerConfiguration{
-				{
-					Name: "a",
-					MultipleStandardLoadBalancerConfigurationSpec: MultipleStandardLoadBalancerConfigurationSpec{},
-				},
-				{
-					Name: "c",
-					MultipleStandardLoadBalancerConfigurationSpec: MultipleStandardLoadBalancerConfigurationSpec{},
-				},
-			},
-			expectedErr: errors.New(`service "test" selects 1 load balancers by annotation, but none of them is defined in cloud provider configuration`),
-		},
 		{
 			description: "should respect namespace selector",
 			svc:         getTestService("test", v1.ProtocolTCP, nil, false),
@@ -7465,7 +7397,7 @@ func TestGetEligibleLoadBalancers(t *testing.T) {
 				tc.svc.Labels = tc.labels
 			}
 
-			lbs, err := az.getEligibleLoadBalancersForService(&tc.svc)
+			lbs, err := az.getEligibleLoadBalancers(&tc.svc)
 			assert.Equal(t, tc.expectedLBs, lbs)
 			if tc.expectedErr != nil {
 				assert.Equal(t, tc.expectedErr.Error(), err.Error())
@@ -7710,7 +7642,7 @@ func TestGetMostEligibleLBName(t *testing.T) {
 		},
 	} {
 		t.Run(tc.description, func(t *testing.T) {
-			lbName := getMostEligibleLBForService(tc.currentLBName, tc.eligibleLBs, tc.existingLBs)
+			lbName := getMostEligibleLBName(tc.currentLBName, tc.eligibleLBs, tc.existingLBs)
 			assert.Equal(t, tc.expectedLBName, lbName)
 		})
 	}
@@ -7724,7 +7656,6 @@ func TestReconcileMultipleStandardLoadBalancerConfigurations(t *testing.T) {
 		description            string
 		useMultipleLB          bool
 		noPrimaryConfig        bool
-		nodes                  []*v1.Node
 		expectedActiveServices map[string]sets.Set[string]
 		expectedErr            error
 	}{
@@ -7732,8 +7663,8 @@ func TestReconcileMultipleStandardLoadBalancerConfigurations(t *testing.T) {
 			description:   "should set active services correctly",
 			useMultipleLB: true,
 			expectedActiveServices: map[string]sets.Set[string]{
-				"kubernetes": sets.New[string]("default/lbsvconkubernetes"),
-				"lb1":        sets.New[string]("ns1/lbsvconlb1"),
+				"kubernetes": sets.New[string]("default/LBSvcOnKubernetes"),
+				"lb1":        sets.New[string]("ns1/LBSvcOnLB1"),
 			},
 		},
 		{
@@ -7826,8 +7757,7 @@ func TestReconcileMultipleStandardLoadBalancerConfigurations(t *testing.T) {
 				}
 			}
 
-			svc := getTestService("test", v1.ProtocolTCP, nil, false)
-			err := az.reconcileMultipleStandardLoadBalancerConfigurations(&existingLBs, &svc, "kubernetes", &existingLBs, tc.nodes)
+			err := az.reconcileMultipleStandardLoadBalancerConfigurations("kubernetes", &existingLBs)
 			assert.Equal(t, err, tc.expectedErr)
 
 			activeServices := make(map[string]sets.Set[string])
@@ -8288,319 +8218,3 @@ func TestServiceOwnsFrontendIP(t *testing.T) {
 		})
 	}
 }
-
-func TestReconcileMultipleStandardLoadBalancerNodes(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-
-	for _, tc := range []struct {
-		description          string
-		lbName               string
-		existingLBConfigs    []MultipleStandardLoadBalancerConfiguration
-		existingNodes        []*v1.Node
-		existingLBs          []network.LoadBalancer
-		expectedPutLBTimes   int
-		expectedLBToNodesMap map[string]sets.Set[string]
-	}{
-		{
-			description: "should remove unwanted nodes and arrange existing nodes with primary vmSet as expected",
-			existingLBConfigs: []MultipleStandardLoadBalancerConfiguration{
-				{
-					Name: "lb1",
-					MultipleStandardLoadBalancerConfigurationSpec: MultipleStandardLoadBalancerConfigurationSpec{
-						PrimaryVMSet: "vmss-1",
-					},
-					MultipleStandardLoadBalancerConfigurationStatus: MultipleStandardLoadBalancerConfigurationStatus{
-						ActiveNodes: sets.Set[string]{"node1": sets.Empty{}, "node2": sets.Empty{}},
-					},
-				},
-				{
-					Name: "lb2",
-					MultipleStandardLoadBalancerConfigurationSpec: MultipleStandardLoadBalancerConfigurationSpec{
-						PrimaryVMSet: "vmss-2",
-					},
-					MultipleStandardLoadBalancerConfigurationStatus: MultipleStandardLoadBalancerConfigurationStatus{
-						ActiveNodes: sets.Set[string]{"node3": sets.Empty{}, "node4": sets.Empty{}},
-					},
-				},
-			},
-			existingNodes: []*v1.Node{
-				getTestNodeWithMetadata("node1", "vmss-1", nil, "10.1.0.1"),
-				getTestNodeWithMetadata("node2", "vmss-2", nil, "10.1.0.2"),
-				getTestNodeWithMetadata("node3", "vmss-2", nil, "10.1.0.3"),
-			},
-			existingLBs: []network.LoadBalancer{
-				{
-					Name: pointer.String("lb1-internal"),
-					LoadBalancerPropertiesFormat: &network.LoadBalancerPropertiesFormat{
-						BackendAddressPools: &[]network.BackendAddressPool{
-							{
-								Name: pointer.String("kubernetes"),
-								BackendAddressPoolPropertiesFormat: &network.BackendAddressPoolPropertiesFormat{
-									LoadBalancerBackendAddresses: &[]network.LoadBalancerBackendAddress{
-										{
-											Name: pointer.String("node1"),
-											LoadBalancerBackendAddressPropertiesFormat: &network.LoadBalancerBackendAddressPropertiesFormat{
-												IPAddress: pointer.String("10.1.0.1"),
-											},
-										},
-										{
-											Name: pointer.String("node2"),
-											LoadBalancerBackendAddressPropertiesFormat: &network.LoadBalancerBackendAddressPropertiesFormat{
-												IPAddress: pointer.String("10.1.0.2"),
-											},
-										},
-									},
-								},
-							},
-						},
-					},
-				},
-				{
-					Name: pointer.String("lb2"),
-					LoadBalancerPropertiesFormat: &network.LoadBalancerPropertiesFormat{
-						BackendAddressPools: &[]network.BackendAddressPool{
-							{
-								Name: pointer.String("kubernetes"),
-								BackendAddressPoolPropertiesFormat: &network.BackendAddressPoolPropertiesFormat{
-									LoadBalancerBackendAddresses: &[]network.LoadBalancerBackendAddress{
-										{
-											Name: pointer.String("node3"),
-											LoadBalancerBackendAddressPropertiesFormat: &network.LoadBalancerBackendAddressPropertiesFormat{
-												IPAddress: pointer.String("10.1.0.3"),
-											},
-										},
-										{
-											Name: pointer.String("node4"),
-											LoadBalancerBackendAddressPropertiesFormat: &network.LoadBalancerBackendAddressPropertiesFormat{
-												IPAddress: pointer.String("10.1.0.4"),
-											},
-										},
-									},
-								},
-							},
-						},
-					},
-				},
-			},
-			expectedPutLBTimes: 1,
-			expectedLBToNodesMap: map[string]sets.Set[string]{
-				"lb1": {"node1": sets.Empty{}},
-				"lb2": {"node2": sets.Empty{}, "node3": sets.Empty{}},
-			},
-		},
-		{
-			description: "should respect node selector",
-			lbName:      "lb2-internal",
-			existingLBConfigs: []MultipleStandardLoadBalancerConfiguration{
-				{
-					Name: "lb1",
-					MultipleStandardLoadBalancerConfigurationSpec: MultipleStandardLoadBalancerConfigurationSpec{
-						PrimaryVMSet: "vmss-1",
-						NodeSelector: &metav1.LabelSelector{
-							MatchLabels: map[string]string{"k1": "v1"},
-						},
-					},
-					MultipleStandardLoadBalancerConfigurationStatus: MultipleStandardLoadBalancerConfigurationStatus{
-						ActiveNodes: sets.Set[string]{"node1": sets.Empty{}, "node2": sets.Empty{}},
-					},
-				},
-				{
-					Name: "lb2",
-					MultipleStandardLoadBalancerConfigurationSpec: MultipleStandardLoadBalancerConfigurationSpec{
-						PrimaryVMSet: "vmss-2",
-						NodeSelector: &metav1.LabelSelector{
-							MatchLabels: map[string]string{"k2": "v2"},
-						},
-					},
-					MultipleStandardLoadBalancerConfigurationStatus: MultipleStandardLoadBalancerConfigurationStatus{
-						ActiveNodes: sets.Set[string]{"node3": sets.Empty{}, "node4": sets.Empty{}},
-					},
-				},
-				{
-					Name: "lb3",
-					MultipleStandardLoadBalancerConfigurationSpec: MultipleStandardLoadBalancerConfigurationSpec{
-						PrimaryVMSet: "vmss-2",
-						NodeSelector: &metav1.LabelSelector{
-							MatchLabels: map[string]string{"k2": "v2"},
-						},
-					},
-				},
-				{
-					Name: "lb4",
-					MultipleStandardLoadBalancerConfigurationSpec: MultipleStandardLoadBalancerConfigurationSpec{
-						PrimaryVMSet: "vmss-2",
-					},
-				},
-			},
-			existingNodes: []*v1.Node{
-				getTestNodeWithMetadata("node1", "vmss-1", map[string]string{"k2": "v2"}, "10.1.0.1"),
-				getTestNodeWithMetadata("node2", "vmss-3", map[string]string{"k3": "v3"}, "10.1.0.2"),
-				getTestNodeWithMetadata("node3", "vmss-3", map[string]string{"k2": "v2"}, "10.1.0.3"),
-				getTestNodeWithMetadata("node5", "vmss-3", map[string]string{"k2": "v2"}, "10.1.0.5"),
-				getTestNodeWithMetadata("node6", "vmss-3", map[string]string{"k3": "v3"}, "10.1.0.6"),
-			},
-			existingLBs: []network.LoadBalancer{
-				{
-					Name: pointer.String("lb1-internal"),
-					LoadBalancerPropertiesFormat: &network.LoadBalancerPropertiesFormat{
-						BackendAddressPools: &[]network.BackendAddressPool{
-							{
-								Name: pointer.String("kubernetes"),
-								BackendAddressPoolPropertiesFormat: &network.BackendAddressPoolPropertiesFormat{
-									LoadBalancerBackendAddresses: &[]network.LoadBalancerBackendAddress{
-										{
-											Name: pointer.String("node1"),
-											LoadBalancerBackendAddressPropertiesFormat: &network.LoadBalancerBackendAddressPropertiesFormat{
-												IPAddress: pointer.String("10.1.0.1"),
-											},
-										},
-										{
-											Name: pointer.String("node2"),
-											LoadBalancerBackendAddressPropertiesFormat: &network.LoadBalancerBackendAddressPropertiesFormat{
-												IPAddress: pointer.String("10.1.0.2"),
-											},
-										},
-									},
-								},
-							},
-						},
-					},
-				},
-				{
-					Name: pointer.String("lb3"),
-					LoadBalancerPropertiesFormat: &network.LoadBalancerPropertiesFormat{
-						BackendAddressPools: &[]network.BackendAddressPool{
-							{
-								Name: pointer.String("kubernetes"),
-							},
-						},
-					},
-				},
-			},
-			expectedLBToNodesMap: map[string]sets.Set[string]{
-				"lb1": {"node1": sets.Empty{}},
-				"lb2": {"node3": sets.Empty{}},
-				"lb3": {"node5": sets.Empty{}},
-				"lb4": {"node2": sets.Empty{}, "node6": sets.Empty{}},
-			},
-		},
-		{
-			description: "should remove the node on the lb if it is no longer eligible",
-			existingLBConfigs: []MultipleStandardLoadBalancerConfiguration{
-				{
-					Name: "lb1",
-					MultipleStandardLoadBalancerConfigurationSpec: MultipleStandardLoadBalancerConfigurationSpec{
-						PrimaryVMSet: "vmss-1",
-						NodeSelector: &metav1.LabelSelector{
-							MatchLabels: map[string]string{"k1": "v1"},
-						},
-					},
-					MultipleStandardLoadBalancerConfigurationStatus: MultipleStandardLoadBalancerConfigurationStatus{
-						ActiveNodes: sets.Set[string]{"node1": sets.Empty{}, "node2": sets.Empty{}},
-					},
-				},
-			},
-			existingNodes: []*v1.Node{
-				getTestNodeWithMetadata("node1", "vmss-2", map[string]string{"k2": "v2"}, "10.1.0.1"),
-			},
-			expectedLBToNodesMap: map[string]sets.Set[string]{
-				"lb1": {},
-			},
-		},
-		{
-			description: "should skip lbs that do not exist or will not be created",
-			existingLBConfigs: []MultipleStandardLoadBalancerConfiguration{
-				{
-					Name: "lb1",
-					MultipleStandardLoadBalancerConfigurationSpec: MultipleStandardLoadBalancerConfigurationSpec{
-						PrimaryVMSet: "vmss-1",
-						NodeSelector: &metav1.LabelSelector{
-							MatchLabels: map[string]string{"k1": "v1"},
-						},
-					},
-				},
-				{
-					Name: "lb2",
-					MultipleStandardLoadBalancerConfigurationSpec: MultipleStandardLoadBalancerConfigurationSpec{
-						PrimaryVMSet: "vmss-2",
-						NodeSelector: &metav1.LabelSelector{
-							MatchLabels: map[string]string{"k2": "v2"},
-						},
-					},
-				},
-				{
-					Name: "lb3",
-					MultipleStandardLoadBalancerConfigurationSpec: MultipleStandardLoadBalancerConfigurationSpec{
-						PrimaryVMSet: "vmss-2",
-						NodeSelector: &metav1.LabelSelector{
-							MatchLabels: map[string]string{"k3": "v3"},
-						},
-					},
-				},
-				{
-					Name: "lb4",
-				},
-			},
-			existingLBs: []network.LoadBalancer{
-				{
-					Name: pointer.String("lb2-internal"),
-					LoadBalancerPropertiesFormat: &network.LoadBalancerPropertiesFormat{
-						BackendAddressPools: &[]network.BackendAddressPool{
-							{Name: pointer.String("kubernetes")},
-						},
-					},
-				},
-			},
-			existingNodes: []*v1.Node{
-				getTestNodeWithMetadata("node1", "vmss-1", map[string]string{"k1": "v1"}, "10.1.0.1"),
-				getTestNodeWithMetadata("node2", "vmss-3", map[string]string{"k3": "v3"}, "10.1.0.2"),
-				getTestNodeWithMetadata("node3", "vmss-3", map[string]string{"k2": "v2"}, "10.1.0.3"),
-				getTestNodeWithMetadata("node5", "vmss-3", map[string]string{"k2": "v2"}, "10.1.0.5"),
-				getTestNodeWithMetadata("node6", "vmss-3", map[string]string{"k3": "v3"}, "10.1.0.6"),
-			},
-			expectedLBToNodesMap: map[string]sets.Set[string]{
-				"lb1": nil,
-				"lb2": {"node3": sets.Empty{}, "node5": sets.Empty{}},
-				"lb3": nil,
-				"lb4": {"node1": sets.Empty{}, "node2": sets.Empty{}, "node6": sets.Empty{}},
-			},
-		},
-	} {
-		t.Run(tc.description, func(t *testing.T) {
-			az := GetTestCloud(ctrl)
-			ss, _ := NewTestScaleSet(ctrl)
-			ss.DisableAvailabilitySetNodes = true
-			az.VMSet = ss
-			az.MultipleStandardLoadBalancerConfigurations = tc.existingLBConfigs
-			svc := getTestService("test", v1.ProtocolTCP, nil, false)
-			_ = az.reconcileMultipleStandardLoadBalancerBackendNodes(tc.lbName, &tc.existingLBs, &svc, tc.existingNodes)
-
-			expectedLBToNodesMap := make(map[string]sets.Set[string])
-			for _, multiSLBConfig := range az.MultipleStandardLoadBalancerConfigurations {
-				expectedLBToNodesMap[multiSLBConfig.Name] = multiSLBConfig.ActiveNodes
-			}
-			assert.Equal(t, tc.expectedLBToNodesMap, expectedLBToNodesMap)
-		})
-	}
-}
-
-func getTestNodeWithMetadata(nodeName, vmssName string, labels map[string]string, ip string) *v1.Node {
-	return &v1.Node{
-		ObjectMeta: metav1.ObjectMeta{
-			Name:   nodeName,
-			Labels: labels,
-		},
-		Spec: v1.NodeSpec{
-			ProviderID: fmt.Sprintf("azure:///subscriptions/sub/resourceGroups/rg/providers/Microsoft.Compute/virtualMachineScaleSets/%s/virtualMachines/0", vmssName),
-		},
-		Status: v1.NodeStatus{
-			Addresses: []v1.NodeAddress{
-				{
-					Type:    v1.NodeInternalIP,
-					Address: ip,
-				},
-			},
-		},
-	}
-}
diff --git a/pkg/provider/azure_test.go b/pkg/provider/azure_test.go
index 1c1a2d496..211680d33 100644
--- a/pkg/provider/azure_test.go
+++ b/pkg/provider/azure_test.go
@@ -3554,7 +3554,7 @@ func TestUpdateNodeCacheExcludeLoadBalancer(t *testing.T) {
 	az.nodeZones = map[string]sets.Set[string]{zone: nodesInZone}
 	az.nodeResourceGroups = map[string]string{"aNode": "rg"}
 
-	// a non-ready node should be included
+	// a non-ready node should be excluded
 	az.unmanagedNodes = sets.New[string]()
 	az.excludeLoadBalancerNodes = sets.New[string]()
 	az.nodeNames = sets.New[string]()
@@ -3575,9 +3575,9 @@ func TestUpdateNodeCacheExcludeLoadBalancer(t *testing.T) {
 		},
 	}
 	az.updateNodeCaches(nil, &nonReadyNode)
-	assert.Equal(t, 0, len(az.excludeLoadBalancerNodes))
+	assert.Equal(t, 1, len(az.excludeLoadBalancerNodes))
 
-	// node becomes ready => no impact on az.excludeLoadBalancerNodes
+	// node becomes ready, it should be removed from az.excludeLoadBalancerNodes
 	readyNode := v1.Node{
 		ObjectMeta: metav1.ObjectMeta{
 			Labels: map[string]string{
@@ -3896,73 +3896,3 @@ func TestSetLBDefaults(t *testing.T) {
 	_ = az.setLBDefaults(config)
 	assert.Equal(t, config.LoadBalancerSku, consts.LoadBalancerSkuStandard)
 }
-
-func TestCheckEnableMultipleStandardLoadBalancers(t *testing.T) {
-	ctrl := gomock.NewController(t)
-	defer ctrl.Finish()
-	az := GetTestCloud(ctrl)
-	az.LoadBalancerBackendPoolConfigurationType = consts.LoadBalancerBackendPoolConfigurationTypeNodeIP
-
-	az.MultipleStandardLoadBalancerConfigurations = []MultipleStandardLoadBalancerConfiguration{
-		{
-			Name: "kubernetes",
-			MultipleStandardLoadBalancerConfigurationSpec: MultipleStandardLoadBalancerConfigurationSpec{
-				PrimaryVMSet: "vmss-0",
-			},
-		},
-		{
-			Name: "lb1",
-			MultipleStandardLoadBalancerConfigurationSpec: MultipleStandardLoadBalancerConfigurationSpec{
-				PrimaryVMSet: "vmss-1",
-			},
-		},
-		{
-			Name: "kubernetes",
-			MultipleStandardLoadBalancerConfigurationSpec: MultipleStandardLoadBalancerConfigurationSpec{
-				PrimaryVMSet: "vmss-2",
-			},
-		},
-	}
-
-	err := az.checkEnableMultipleStandardLoadBalancers()
-	assert.Equal(t, "duplicated multiple standard load balancer configuration name kubernetes", err.Error())
-
-	az.MultipleStandardLoadBalancerConfigurations = []MultipleStandardLoadBalancerConfiguration{
-		{
-			Name: "kubernetes",
-			MultipleStandardLoadBalancerConfigurationSpec: MultipleStandardLoadBalancerConfigurationSpec{
-				PrimaryVMSet: "vmss-0",
-			},
-		},
-		{
-			Name: "lb1",
-		},
-	}
-
-	err = az.checkEnableMultipleStandardLoadBalancers()
-	assert.Equal(t, "multiple standard load balancer configuration lb1 must have primary VMSet", err.Error())
-
-	az.MultipleStandardLoadBalancerConfigurations = []MultipleStandardLoadBalancerConfiguration{
-		{
-			Name: "kubernetes",
-			MultipleStandardLoadBalancerConfigurationSpec: MultipleStandardLoadBalancerConfigurationSpec{
-				PrimaryVMSet: "vmss-0",
-			},
-		},
-		{
-			Name: "lb1",
-			MultipleStandardLoadBalancerConfigurationSpec: MultipleStandardLoadBalancerConfigurationSpec{
-				PrimaryVMSet: "vmss-2",
-			},
-		},
-		{
-			Name: "lb2",
-			MultipleStandardLoadBalancerConfigurationSpec: MultipleStandardLoadBalancerConfigurationSpec{
-				PrimaryVMSet: "vmss-2",
-			},
-		},
-	}
-
-	err = az.checkEnableMultipleStandardLoadBalancers()
-	assert.Equal(t, "duplicated primary VMSet vmss-2 in multiple standard load balancer configurations lb2", err.Error())
-}
diff --git a/tests/e2e/autoscaling/autoscaler.go b/tests/e2e/autoscaling/autoscaler.go
index 4560e9264..d4fce903a 100644
--- a/tests/e2e/autoscaling/autoscaler.go
+++ b/tests/e2e/autoscaling/autoscaler.go
@@ -204,8 +204,6 @@ var _ = Describe("Cluster size autoscaler", Label(utils.TestSuiteLabelFeatureAut
 	})
 
 	It("should balance the sizes of multiple node group if the `--balance-node-groups` is set to true", Label(utils.TestSuiteLabelMultiNodePools), func() {
-		Skip("--balance-node-groups is not supported due to autoscaler bug. This label should be ignored: kubernetes.azure.com/consolidated-additional-properties")
-
 		By("Checking the number of node pools")
 		if len(initNodepoolNodeMap) < 2 {
 			Skip("multiple node pools are needed in this scenario")
diff --git a/tests/e2e/network/ensureloadbalancer.go b/tests/e2e/network/ensureloadbalancer.go
index e53adca91..252ea9447 100644
--- a/tests/e2e/network/ensureloadbalancer.go
+++ b/tests/e2e/network/ensureloadbalancer.go
@@ -498,7 +498,7 @@ var _ = Describe("Ensure LoadBalancer", Label(utils.TestSuiteLabelLB), func() {
 					pipNames = append(pipNames, utils.GetNameWithSuffix(ipNameBase, utils.Suffixes[consts.IPVersionIPv6]))
 				}
 				utils.Logf("update pip names %s", strings.Join(pipNames, ","))
-				service = updateServicePIPNames(tc.IPFamily, service, pipNames)
+				service = updateServicePIPNames(service, pipNames)
 			}
 			_, err := cs.CoreV1().Services(ns.Name).Create(context.TODO(), service, metav1.CreateOptions{})
 			defer func() {
@@ -551,14 +551,11 @@ var _ = Describe("Ensure LoadBalancer", Label(utils.TestSuiteLabelLB), func() {
 					service = updateServiceLBIPs(service, false, sharedIPs)
 				}
 			} else {
-				var pipNames []string
-				for _, sharedIP := range sharedIPs {
-					pip, err := tc.GetPublicIPFromAddress(tc.GetResourceGroup(), sharedIP)
-					Expect(err).NotTo(HaveOccurred())
-					pipNames = append(pipNames, pointer.StringDeref(pip.Name, ""))
-				}
+				pip, err := tc.GetPublicIPFromAddress(tc.GetResourceGroup(), sharedIPs[0])
+				Expect(err).NotTo(HaveOccurred())
+				pipNames := []string{pointer.StringDeref(pip.Name, "")}
 				utils.Logf("update pip names %s", strings.Join(pipNames, ","))
-				service = updateServicePIPNames(tc.IPFamily, service, pipNames)
+				service = updateServicePIPNames(service, pipNames)
 			}
 			_, err := cs.CoreV1().Services(ns.Name).Create(context.TODO(), service, metav1.CreateOptions{})
 			Expect(err).NotTo(HaveOccurred())
@@ -1285,17 +1282,16 @@ func updateServiceLBIPs(service *v1.Service, isInternal bool, ips []string) (res
 	return
 }
 
-func updateServicePIPNames(ipFamily utils.IPFamily, service *v1.Service, pipNames []string) *v1.Service {
+func updateServicePIPNames(service *v1.Service, pipNames []string) *v1.Service {
 	if service.Annotations == nil {
 		service.Annotations = map[string]string{}
 	}
 
-	isDualStack := ipFamily == utils.DualStack
 	for _, pipName := range pipNames {
-		if !isDualStack || !strings.HasSuffix(pipName, "-IPv6") {
-			service.Annotations[consts.ServiceAnnotationPIPNameDualStack[consts.IPVersionIPv4]] = pipName
-		} else {
+		if strings.HasSuffix(pipName, "-IPv6") {
 			service.Annotations[consts.ServiceAnnotationPIPNameDualStack[consts.IPVersionIPv6]] = pipName
+		} else {
+			service.Annotations[consts.ServiceAnnotationPIPNameDualStack[consts.IPVersionIPv4]] = pipName
 		}
 	}