[release-1.34]feat: implement tagsList-based Interconnect Group ID retrieval from IMDS (#10007)

* Label node with Interconnect Group ID (placeholder implementation)

What type of PR is this?
/kind feature

What this PR does / why we need it:
This adds the infrastructure/plumbing code for Interconnect Group node labeling but with a placeholder implementation that returns empty string. This allows the infrastructure to be in place and tested without breaking anything, while the actual IMDS parsing implementation can be added later when the format is finalized.

Which issue(s) this PR fixes:
N/A (New feature - infrastructure preparation)

Special notes for your reviewer:
Changes:
- pkg/consts: Add LabelInterconnectGroup constant
- pkg/provider: Add GetInterconnectGroupId method (returns empty)
- pkg/nodemanager: Add GetInterconnectGroupId to interface and integration code
- pkg/node: Implement GetInterconnectGroupId for both IMDS and ARM providers (both return empty)
- pkg/provider: Add minimal unit test

Behavior:
- GetInterconnectGroupId() always returns ("", nil)
- No label is applied to nodes
- No errors, nothing breaks
- Infrastructure is ready for future implementation

This approach allows:
1. Code review and testing of the infrastructure separately
2. Future IMDS parsing logic to be added without modifying the interface
3. Safe deployment - guaranteed not to break anything
4. No assumptions about IMDS format (no TagsList or other structures added)

Does this PR introduce a user-facing change?
NONE

Additional documentation e.g., KEPs (Kubernetes Enhancement Proposals), usage docs, etc.:
NONE

* Implement TagsList-based Interconnect Group ID retrieval from IMDS

This commit implements the actual IMDS parsing logic to retrieve the
Platform Interconnect Group ID from Azure instance metadata using the
tagsList field.

Implementation changes:
- Add TagNameInterconnectGroup constant for the IMDS tag name
- Add Tag struct to represent IMDS tag key-value pairs
- Add TagsList field to ComputeMetadata struct for JSON unmarshaling
- Implement GetInterconnectGroupID to parse tagsList and extract
  Platform_Interconnect_Group tag value
- Add comprehensive tests with HTTP mock server:
  * Tag present in tagsList
  * Tag absent from tagsList
  * Empty tagsList
  * UseInstanceMetadata disabled

Test updates:
- Update TestNodeInitialized and TestUpdateCloudNode to verify
  Interconnect Group labeling alongside PlatformSubFaultDomain
- Tests return actual group IDs and validate labels are set correctly

This builds on the infrastructure from PR #9559 which added the label
constant and placeholder function.

* fix: address review feedback for Interconnect Group ID retrieval

---------

Co-authored-by: wtao <wtao@microsoft.com>

Author: anndono

pkg/consts/consts.go

@@ -43,6 +43,11 @@ const (
 	LabelFailureDomainBetaRegion = "failure-domain.beta.kubernetes.io/region"
 	// LabelPlatformSubFaultDomain is the label key of platformSubFaultDomain
 	LabelPlatformSubFaultDomain = "topology.kubernetes.azure.com/sub-fault-domain"
+	// LabelPlatformInterconnectGroup is the label key of Platform Interconnect Group
+	LabelPlatformInterconnectGroup = "topology.kubernetes.azure.com/interconnect-group"
+
+	// TagNameInterconnectGroup is the tag name in IMDS tagsList for Platform Interconnect Group
+	TagNameInterconnectGroup = "Platform_Interconnect_Group"
 
 	// ADFSIdentitySystem is the override value for tenantID on Azure Stack clouds.
 	ADFSIdentitySystem = "adfs"

pkg/node/node.go

@@ -86,3 +86,8 @@ func (np *IMDSNodeProvider) GetZone(ctx context.Context, _ types.NodeName) (clou
 func (np *IMDSNodeProvider) GetPlatformSubFaultDomain(ctx context.Context) (string, error) {
 	return np.azure.GetPlatformSubFaultDomain(ctx)
 }
+
+// GetInterconnectGroupID returns the Interconnect Group ID from IMDS.
+func (np *IMDSNodeProvider) GetInterconnectGroupID(ctx context.Context) (string, error) {
+	return np.azure.GetInterconnectGroupID(ctx)
+}

pkg/node/nodearm.go

@@ -90,3 +90,8 @@ func (np *ARMNodeProvider) GetZone(ctx context.Context, name types.NodeName) (cl
 func (np *ARMNodeProvider) GetPlatformSubFaultDomain(_ context.Context) (string, error) {
 	return "", nil
 }
+
+// GetInterconnectGroupID returns empty string for ARM provider.
+func (np *ARMNodeProvider) GetInterconnectGroupID(_ context.Context) (string, error) {
+	return "", nil
+}

pkg/nodemanager/mock/mock_node_provider.go

@@ -62,6 +62,8 @@ type NodeProvider interface {
 	GetZone(ctx context.Context, name types.NodeName) (cloudprovider.Zone, error)
 	// GetPlatformSubFaultDomain returns the PlatformSubFaultDomain from IMDS if set.
 	GetPlatformSubFaultDomain(ctx context.Context) (string, error)
+	// GetInterconnectGroupID returns the Interconnect Group ID from IMDS if set.
+	GetInterconnectGroupID(ctx context.Context) (string, error)
 }
 
 // labelReconcile holds information about a label to reconcile and how to reconcile it.
@@ -508,6 +510,14 @@ func (cnc *CloudNodeController) getNodeModifiersFromCloudProvider(ctx context.Co
 		nodeModifiers = append(nodeModifiers, addCloudNodeLabel(consts.LabelPlatformSubFaultDomain, platformSubFaultDomain))
 	}
 
+	interconnectGroupID, err := cnc.getInterconnectGroupID(ctx)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get interconnectGroupID: %w", err)
+	}
+	if interconnectGroupID != "" {
+		nodeModifiers = append(nodeModifiers, addCloudNodeLabel(consts.LabelPlatformInterconnectGroup, interconnectGroupID))
+	}
+
 	return nodeModifiers, nil
 }
 
@@ -656,6 +666,14 @@ func (cnc *CloudNodeController) getPlatformSubFaultDomain(ctx context.Context) (
 	return subFD, nil
 }
 
+func (cnc *CloudNodeController) getInterconnectGroupID(ctx context.Context) (string, error) {
+	ig, err := cnc.nodeProvider.GetInterconnectGroupID(ctx)
+	if err != nil {
+		return "", fmt.Errorf("cnc.getInterconnectGroupID: %w", err)
+	}
+	return ig, nil
+}
+
 func (cnc *CloudNodeController) updateNetworkingCondition(node *v1.Node, networkReady bool) error {
 	logger := log.Background().WithName("updateNetworkingCondition")
 	_, condition := nodeutil.GetNodeCondition(&(node.Status), v1.NodeNetworkUnavailable)

pkg/nodemanager/nodemanager.go

@@ -183,6 +183,7 @@ func TestNodeInitialized(t *testing.T) {
 		},
 	}, nil).AnyTimes()
 	mockNP.EXPECT().GetPlatformSubFaultDomain(ctx).Return("1", nil)
+	mockNP.EXPECT().GetInterconnectGroupID(ctx).Return("group-123", nil)
 
 	cloudNodeController := NewCloudNodeController(
 		"node0",
@@ -199,6 +200,7 @@ func TestNodeInitialized(t *testing.T) {
 	assert.Equal(t, "node0", fnh.UpdatedNodes[0].Name, "Node was not updated")
 	assert.Equal(t, 0, len(fnh.UpdatedNodes[0].Spec.Taints), "Node Taint was not removed after cloud init")
 	assert.Equal(t, "1", fnh.UpdatedNodes[0].Labels[consts.LabelPlatformSubFaultDomain])
+	assert.Equal(t, "group-123", fnh.UpdatedNodes[0].Labels[consts.LabelPlatformInterconnectGroup])
 }
 
 func TestUpdateCloudNode(t *testing.T) {
@@ -261,6 +263,7 @@ func TestUpdateCloudNode(t *testing.T) {
 		},
 	}, nil).AnyTimes()
 	mockNP.EXPECT().GetPlatformSubFaultDomain(ctx).Return("1", nil)
+	mockNP.EXPECT().GetInterconnectGroupID(ctx).Return("group-456", nil)
 
 	eventBroadcaster := record.NewBroadcaster()
 	cloudNodeController := NewCloudNodeController(
@@ -281,6 +284,7 @@ func TestUpdateCloudNode(t *testing.T) {
 	assert.Equal(t, 2, len(fnh.UpdatedNodes[0].Status.Conditions), "Node Contions was not updated")
 	assert.Equal(t, "NetworkUnavailable", string(fnh.UpdatedNodes[0].Status.Conditions[0].Type), "Node Condition NetworkUnavailable was not updated")
 	assert.Equal(t, "1", fnh.UpdatedNodes[0].Labels[consts.LabelPlatformSubFaultDomain])
+	assert.Equal(t, "group-456", fnh.UpdatedNodes[0].Labels[consts.LabelPlatformInterconnectGroup])
 }
 
 // This test checks that a node without the external cloud provider taint are NOT cloudprovider initialized
@@ -394,6 +398,7 @@ func TestZoneInitialized(t *testing.T) {
 			},
 		}, nil).AnyTimes()
 		mockNP.EXPECT().GetPlatformSubFaultDomain(ctx).Return("", nil)
+		mockNP.EXPECT().GetInterconnectGroupID(ctx).Return("", nil)
 
 		eventBroadcaster := record.NewBroadcaster()
 		cloudNodeController := &CloudNodeController{
@@ -475,6 +480,7 @@ func TestZoneInitialized(t *testing.T) {
 			},
 		}, nil).AnyTimes()
 		mockNP.EXPECT().GetPlatformSubFaultDomain(ctx).Return("", nil)
+		mockNP.EXPECT().GetInterconnectGroupID(ctx).Return("", nil)
 
 		eventBroadcaster := record.NewBroadcaster()
 		cloudNodeController := &CloudNodeController{
@@ -572,6 +578,7 @@ func TestAddCloudNode(t *testing.T) {
 		},
 	}, nil).AnyTimes()
 	mockNP.EXPECT().GetPlatformSubFaultDomain(gomock.Any()).Return("", nil)
+	mockNP.EXPECT().GetInterconnectGroupID(gomock.Any()).Return("", nil)
 
 	factory := informers.NewSharedInformerFactory(fnh, 0)
 	nodeInformer := factory.Core().V1().Nodes()
@@ -736,6 +743,7 @@ func TestNodeProvidedIPAddresses(t *testing.T) {
 		},
 	}, nil).AnyTimes()
 	mockNP.EXPECT().GetPlatformSubFaultDomain(ctx).Return("", nil)
+	mockNP.EXPECT().GetInterconnectGroupID(ctx).Return("", nil)
 
 	eventBroadcaster := record.NewBroadcaster()
 	cloudNodeController := NewCloudNodeController(
@@ -1158,6 +1166,7 @@ func TestNodeProviderID(t *testing.T) {
 		},
 	}, nil).AnyTimes()
 	mockNP.EXPECT().GetPlatformSubFaultDomain(ctx).Return("", nil).AnyTimes()
+	mockNP.EXPECT().GetInterconnectGroupID(ctx).Return("", nil).AnyTimes()
 
 	eventBroadcaster := record.NewBroadcaster()
 	cloudNodeController := &CloudNodeController{
@@ -1244,6 +1253,7 @@ func TestNodeProviderIDAlreadySet(t *testing.T) {
 		},
 	}, nil).AnyTimes()
 	mockNP.EXPECT().GetPlatformSubFaultDomain(ctx).Return("", nil).AnyTimes()
+	mockNP.EXPECT().GetInterconnectGroupID(ctx).Return("", nil).AnyTimes()
 
 	eventBroadcaster := record.NewBroadcaster()
 	cloudNodeController := &CloudNodeController{

pkg/nodemanager/nodemanager_test.go

@@ -61,6 +61,12 @@ type Subnet struct {
 	Prefix  string `json:"prefix"`
 }
 
+// Tag represents a key-value tag in IMDS.
+type Tag struct {
+	Name  string `json:"name"`
+	Value string `json:"value"`
+}
+
 // ComputeMetadata represents compute information
 type ComputeMetadata struct {
 	Environment            string `json:"azEnvironment,omitempty"`
@@ -77,6 +83,7 @@ type ComputeMetadata struct {
 	VMScaleSetName         string `json:"vmScaleSetName,omitempty"`
 	SubscriptionID         string `json:"subscriptionId,omitempty"`
 	ResourceID             string `json:"resourceId,omitempty"`
+	TagsList               []Tag  `json:"tagsList,omitempty"`
 }
 
 // InstanceMetadata represents instance information.
@@ -292,3 +299,35 @@ func (az *Cloud) GetPlatformSubFaultDomain(ctx context.Context) (string, error)
 	}
 	return "", nil
 }
+
+// GetInterconnectGroupID returns the Platform Interconnect Group ID from IMDS if set.
+// It reads the value from the Platform_Interconnect_Group tag in tagsList.
+func (az *Cloud) GetInterconnectGroupID(ctx context.Context) (string, error) {
+	logger := log.FromContextOrBackground(ctx).WithName("GetInterconnectGroupID")
+	if az.UseInstanceMetadata {
+		metadata, err := az.Metadata.GetMetadata(ctx, azcache.CacheReadTypeUnsafe)
+		if err != nil {
+			return "", err
+		}
+		if metadata.Compute == nil {
+			_ = az.Metadata.imsCache.Delete(consts.MetadataCacheKey)
+			return "", errors.New("failure of getting compute information from instance metadata")
+		}
+
+		// Check tagsList for Platform_Interconnect_Group tag
+		for _, tag := range metadata.Compute.TagsList {
+			if tag.Name == consts.TagNameInterconnectGroup {
+				if tag.Value == "" {
+					logger.V(4).Info("Interconnect Group tag is present but value is empty")
+					return "", nil
+				}
+				logger.V(2).Info("found Interconnect Group ID from tagsList", "InterconnectGroupID", tag.Value)
+				return tag.Value, nil
+			}
+		}
+
+		// Tag not found - this is normal for VMs without Interconnect Groups
+		logger.V(4).Info("Tag not found in IMDS", "tagName", consts.TagNameInterconnectGroup)
+	}
+	return "", nil
+}

pkg/provider/azure_instance_metadata.go

@@ -22,6 +22,7 @@ import (
 	"fmt"
 	"net"
 	"net/http"
+	"net/http/httptest"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
@@ -150,3 +151,85 @@ func TestGetPlatformSubFaultDomain(t *testing.T) {
 		})
 	}
 }
+
+func TestGetInterconnectGroupID(t *testing.T) {
+	testCases := []struct {
+		name                string
+		useInstanceMetadata bool
+		respString          string
+		expectedID          string
+		expectedErr         bool
+	}{
+		{
+			name:                "InterconnectGroup tag present",
+			useInstanceMetadata: true,
+			respString:          `{"compute":{"tagsList":[{"name":"Platform_Interconnect_Group","value":"group-123"},{"name":"Other_Tag","value":"other"}]}}`,
+			expectedID:          "group-123",
+			expectedErr:         false,
+		},
+		{
+			name:                "InterconnectGroup tag absent",
+			useInstanceMetadata: true,
+			respString:          `{"compute":{"tagsList":[{"name":"Other_Tag","value":"other"}]}}`,
+			expectedID:          "",
+			expectedErr:         false,
+		},
+		{
+			name:                "InterconnectGroup tag present with empty value",
+			useInstanceMetadata: true,
+			respString:          `{"compute":{"tagsList":[{"name":"Platform_Interconnect_Group","value":""}]}}`,
+			expectedID:          "",
+			expectedErr:         false,
+		},
+		{
+			name:                "Empty tagsList",
+			useInstanceMetadata: true,
+			respString:          `{"compute":{"tagsList":[]}}`,
+			expectedID:          "",
+			expectedErr:         false,
+		},
+		{
+			name:                "Compute metadata is nil",
+			useInstanceMetadata: true,
+			respString:          `{}`,
+			expectedID:          "",
+			expectedErr:         true,
+		},
+		{
+			name:                "UseInstanceMetadata false",
+			useInstanceMetadata: false,
+			respString:          `{"compute":{"tagsList":[{"name":"Platform_Interconnect_Group","value":"group-123"}]}}`,
+			expectedID:          "",
+			expectedErr:         false,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			cloud := &Cloud{
+				Config: config.Config{
+					Location:            "eastus",
+					UseInstanceMetadata: tc.useInstanceMetadata,
+				},
+			}
+
+			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+				fmt.Fprint(w, tc.respString)
+			}))
+			defer server.Close()
+
+			var err error
+			cloud.Metadata, err = NewInstanceMetadataService(server.URL + "/")
+			assert.NoError(t, err)
+
+			id, err := cloud.GetInterconnectGroupID(context.TODO())
+
+			if tc.expectedErr {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+				assert.Equal(t, tc.expectedID, id)
+			}
+		})
+	}
+}