complete implementation CLB GetBackendPrivateIPs

pkg/provider/azure_loadbalancer_backendpool.go

@@ -26,7 +26,6 @@ import (
 
 	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/network/armnetwork/v6"
 	v1 "k8s.io/api/core/v1"
-	discovery_v1 "k8s.io/api/discovery/v1"
 	cloudprovider "k8s.io/cloud-provider"
 	"k8s.io/klog/v2"
 	utilnet "k8s.io/utils/net"
@@ -942,48 +941,30 @@ func (bpi *backendPoolTypePodIP) EnsureHostsInPool(_ context.Context, _ *v1.Serv
 	return nil
 }
 
-func (bpi *backendPoolTypePodIP) getAllBackendPoolNamesForEndpointSliceList(endpointSliceList []*discovery_v1.EndpointSlice) *utilsets.IgnoreCaseSet {
-	allBPs := utilsets.NewString()
-	ipv4 := bpi.getBackendPoolNamesForEndpointSliceList(endpointSliceList, false)
-	ipv6 := bpi.getBackendPoolNamesForEndpointSliceList(endpointSliceList, true)
-
-	allBPs.Insert(ipv4.UnsortedList()...)
-	allBPs.Insert(ipv6.UnsortedList()...)
-
-	return allBPs
-}
-
 func (bpi *backendPoolTypePodIP) GetBackendPrivateIPs(_ context.Context, _ string, service *v1.Service, lb *armnetwork.LoadBalancer) ([]string, []string) {
 	serviceName := getServiceName(service)
 
-	endpointSliceList, err := bpi.getEndpointSliceListForService(service)
-
+	lbBackendPoolName, err := bpi.getBackendPoolNameForCLBService(service)
 	if err != nil {
-		klog.Errorf("bpi.GetBackendPrivateIPs: failed to get endpoint slice list for service %q, error: %s", service.Name, err.Error())
+		klog.Errorf("bpi.GetBackendPrivateIPs: failed to get backend pool name for service %q, error: %s", service.Name, err.Error())
 		return nil, nil
 	}
 
-	lbBackendPoolNames := bpi.getAllBackendPoolNamesForEndpointSliceList(endpointSliceList)
-
 	if lb.Properties == nil || lb.Properties.BackendAddressPools == nil {
 		return nil, nil
 	}
 
-	backendPrivateIPv4s, backendPrivateIPv6s := utilsets.NewString(), utilsets.NewString()
+	backendPrivateIPs := utilsets.NewString()
 	for _, bp := range lb.Properties.BackendAddressPools {
-		found := lbBackendPoolNames.Has(ptr.Deref(bp.Name, ""))
+		found := lbBackendPoolName == ptr.Deref(bp.Name, "")
 		if found {
 			klog.V(10).Infof("bpi.GetBackendPrivateIPs for service (%s): found wanted backendpool %s", serviceName, ptr.Deref(bp.Name, ""))
 			if bp.Properties != nil && bp.Properties.LoadBalancerBackendAddresses != nil {
 				for _, backendAddress := range bp.Properties.LoadBalancerBackendAddresses {
 					ipAddress := backendAddress.Properties.IPAddress
 					if ipAddress != nil {
 						klog.V(2).Infof("bpi.GetBackendPrivateIPs for service (%s): lb backendpool - found private IP %q", serviceName, *ipAddress)
-						if utilnet.IsIPv4String(*ipAddress) {
-							backendPrivateIPv4s.Insert(*ipAddress)
-						} else if utilnet.IsIPv6String(*ipAddress) {
-							backendPrivateIPv6s.Insert(*ipAddress)
-						}
+						backendPrivateIPs.Insert(*ipAddress)
 					} else {
 						klog.V(4).Infof("bpi.GetBackendPrivateIPs for service (%s): lb backendpool - found null private IP", serviceName)
 					}
@@ -993,7 +974,10 @@ func (bpi *backendPoolTypePodIP) GetBackendPrivateIPs(_ context.Context, _ strin
 			klog.V(10).Infof("bpi.GetBackendPrivateIPs for service (%s): found unmanaged backendpool %s", serviceName, ptr.Deref(bp.Name, ""))
 		}
 	}
-	return backendPrivateIPv4s.UnsortedList(), backendPrivateIPv6s.UnsortedList()
+	if strings.HasSuffix(lbBackendPoolName, fmt.Sprintf("-%s", consts.IPVersionIPv6StringLower)) {
+		return nil, backendPrivateIPs.UnsortedList()
+	}
+	return backendPrivateIPs.UnsortedList(), nil
 }
 
 func (bpi *backendPoolTypePodIP) ReconcileBackendPools(ctx context.Context, _ string, service *v1.Service, lb *armnetwork.LoadBalancer) (bool, bool, *armnetwork.LoadBalancer, error) {

pkg/provider/azure_local_services.go

@@ -26,7 +26,6 @@ import (
 	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/network/armnetwork/v6"
 	v1 "k8s.io/api/core/v1"
 	discovery_v1 "k8s.io/api/discovery/v1"
-	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/sets"
 	"k8s.io/apimachinery/pkg/util/wait"
 	"k8s.io/client-go/informers"
@@ -618,73 +617,6 @@ func (az *Cloud) reconcileIPsInLocalServiceBackendPoolsAsync(
 	}
 }
 
-func (az *Cloud) getEndpointSliceListForService(service *v1.Service) ([]*discovery_v1.EndpointSlice, error) {
-	var (
-		esList       []*discovery_v1.EndpointSlice
-		foundInCache bool
-	)
-
-	if service.Spec.Type != v1.ServiceTypeLoadBalancer {
-		return esList, nil
-	}
-
-	az.endpointSlicesCache.Range(func(key, value interface{}) bool {
-		endpointSlice := value.(*discovery_v1.EndpointSlice)
-		if strings.EqualFold(getServiceNameOfEndpointSlice(endpointSlice), service.Name) &&
-			strings.EqualFold(endpointSlice.Namespace, service.Namespace) {
-			esList = append(esList, endpointSlice)
-			foundInCache = true
-		}
-		return true
-	})
-
-	if len(esList) == 0 {
-		klog.Infof("EndpointSlice for service %s/%s not found, try to list EndpointSlices", service.Namespace, service.Name)
-		eps, err := az.KubeClient.DiscoveryV1().EndpointSlices(service.Namespace).List(context.Background(), metav1.ListOptions{})
-		if err != nil {
-			klog.Errorf("Failed to list EndpointSlices for service %s/%s: %s", service.Namespace, service.Name, err.Error())
-			return nil, err
-		}
-		for _, endpointSlice := range eps.Items {
-			endpointSlice := endpointSlice
-			if strings.EqualFold(getServiceNameOfEndpointSlice(&endpointSlice), service.Name) {
-				esList = append(esList, &endpointSlice)
-
-				if !foundInCache {
-					az.endpointSlicesCache.Store(strings.ToLower(fmt.Sprintf("%s/%s", endpointSlice.Namespace, endpointSlice.Name)), endpointSlice)
-				}
-			}
-		}
-	}
-	if len(esList) == 0 {
-		return nil, fmt.Errorf("failed to find EndpointSlice for service %s/%s", service.Namespace, service.Name)
-	}
-
-	return esList, nil
-}
-
-func (az *Cloud) getBackendPoolNameForEndpointSlice(endpointSlice *discovery_v1.EndpointSlice, isIPv6 bool) string {
-	if isIPv6 {
-		return fmt.Sprintf("%s-%s", endpointSlice.GetUID(), consts.IPVersionIPv6StringLower)
-	}
-	return string(endpointSlice.GetUID())
-}
-
-func (az *Cloud) getBackendPoolNamesForEndpointSliceList(endpointSliceList []*discovery_v1.EndpointSlice, isIPv6 bool) *utilsets.IgnoreCaseSet {
-	backendPoolNames := utilsets.NewString()
-
-	for _, endpointSlice := range endpointSliceList {
-		if endpointSlice.AddressType == discovery_v1.AddressTypeIPv6 && !isIPv6 {
-			continue
-		}
-		if endpointSlice.AddressType == discovery_v1.AddressTypeIPv4 && isIPv6 {
-			continue
-		}
-		backendPoolNames.Insert(az.getBackendPoolNameForEndpointSlice(endpointSlice, isIPv6))
-	}
-	return backendPoolNames
-}
-
 func isDualStackService(service *v1.Service) bool {
 	return len(service.Spec.IPFamilies) == 2
 }