From 3b66135049a545b17618a43cdde76f89b05ec310 Mon Sep 17 00:00:00 2001 From: Lucas Barros Date: Tue, 10 Nov 2026 00:29:28 -0300 Subject: [PATCH] fix: remove node IP annotations the linode no longer has updateNodeMetadata only set node.k8s.linode.com/private-ip and node.k8s.linode.com/public-ipv6 when the linode had a value, so an address removed from the linode stayed on the node forever. getNodePrivateIP prefers the annotation, so NodeBalancer backends kept pointing at the removed private IP instead of falling back to the node's InternalIP. handleNode also saw the mismatch on every refresh and sent a Node update that changed nothing. Remove the annotation when the expected value is empty. Signed-off-by: Lucas Barros --- cloud/linode/node_controller.go | 23 +++++++++---- cloud/linode/node_controller_test.go | 51 ++++++++++++++++++++++++++++ 2 files changed, 67 insertions(+), 7 deletions(-) diff --git a/cloud/linode/node_controller.go b/cloud/linode/node_controller.go index d69f29ec..4e984750 100644 --- a/cloud/linode/node_controller.go +++ b/cloud/linode/node_controller.go @@ -340,19 +340,28 @@ func (s *nodeController) updateNodeMetadata(ctx context.Context, node *v1.Node, nodeResult.Spec.ProviderID = ccmUtils.ProviderIDPrefix + strconv.Itoa(linode.ID) } - // Try to update the expectedPrivateIP if its not set or doesn't match - if nodeResult.Annotations[annotations.AnnLinodeNodePrivateIP] != privateIP && privateIP != "" { - nodeResult.Annotations[annotations.AnnLinodeNodePrivateIP] = privateIP - } - if nodeResult.Annotations[annotations.AnnLinodeNodePublicIPv6] != publicIPv6 && publicIPv6 != "" { - nodeResult.Annotations[annotations.AnnLinodeNodePublicIPv6] = publicIPv6 - } + // Keep the IP annotations in sync with the linode. An address the + // linode no longer has is removed, so load balancers stop using it. + setOrDeleteAnnotation(nodeResult, annotations.AnnLinodeNodePrivateIP, privateIP) + setOrDeleteAnnotation(nodeResult, annotations.AnnLinodeNodePublicIPv6, publicIPv6) updatedNode, err = s.kubeclient.CoreV1().Nodes().Update(ctx, nodeResult, metav1.UpdateOptions{}) return err }) return updatedNode, err } +// setOrDeleteAnnotation sets the annotation to value, or removes it when value is empty. +func setOrDeleteAnnotation(node *v1.Node, key, value string) { + if value == "" { + delete(node.Annotations, key) + return + } + if node.Annotations == nil { + node.Annotations = map[string]string{} + } + node.Annotations[key] = value +} + func (s *nodeController) handleNode(ctx context.Context, node *v1.Node) error { klog.V(3).InfoS("NodeController handling node metadata", "node", klog.KObj(node)) diff --git a/cloud/linode/node_controller_test.go b/cloud/linode/node_controller_test.go index e6b38c8a..3aa2dcfb 100644 --- a/cloud/linode/node_controller_test.go +++ b/cloud/linode/node_controller_test.go @@ -267,6 +267,57 @@ func TestNodeController_handleNode(t *testing.T) { assert.NoError(t, err, "expected no error during handleNode") } +func TestNodeController_handleNodeRemovesStaleIPAnnotations(t *testing.T) { + ctrl := gomock.NewController(t) + defer ctrl.Finish() + client := mocks.NewMockClient(ctrl) + kubeClient := fake.NewClientset() + publicIP := net.ParseIP("172.234.31.123") + node := &v1.Node{ + ObjectMeta: metav1.ObjectMeta{ + Name: "test-node", + Labels: map[string]string{annotations.AnnLinodeHostUUID: "123"}, + Annotations: map[string]string{ + annotations.AnnLinodeNodePrivateIP: "192.168.159.135", + annotations.AnnLinodeNodePublicIPv6: "2001:db8::f03c:91ff:fe2b:1a2b/128", + "other": "kept", + }, + }, + Spec: v1.NodeSpec{ProviderID: "linode://123"}, + Status: v1.NodeStatus{ + Addresses: []v1.NodeAddress{{Type: v1.NodeInternalIP, Address: "10.0.0.2"}}, + }, + } + _, err := kubeClient.CoreV1().Nodes().Create(t.Context(), node, metav1.CreateOptions{}) + require.NoError(t, err) + + nodeCtrl := newNodeController(kubeClient, client, nil, services.NewInstances(client)) + // The private IPv4 and the IPv6 range were removed from the linode. + client.EXPECT().ListInstances(gomock.Any(), &linodego.ListOptions{PageSize: linodeClient.MaxPageSize, Filter: "{}"}).Times(1).Return([]linodego.Instance{ + {ID: 123, Label: "test-node", IPv4: []net.IP{publicIP}, HostUUID: "123"}, + }, nil) + require.NoError(t, nodeCtrl.handleNode(t.Context(), node)) + + updated, err := kubeClient.CoreV1().Nodes().Get(t.Context(), "test-node", metav1.GetOptions{}) + require.NoError(t, err) + assert.NotContains(t, updated.Annotations, annotations.AnnLinodeNodePrivateIP) + assert.NotContains(t, updated.Annotations, annotations.AnnLinodeNodePublicIPv6) + assert.Equal(t, "kept", updated.Annotations["other"]) + + // Backends fall back to the node's InternalIP instead of the removed address. + backendIP, err := getNodePrivateIP(updated, 0) + require.NoError(t, err) + assert.Equal(t, "10.0.0.2", backendIP) + + // A later refresh (served from the instance cache) sees nothing to change. + nodeCtrl.seenMetadata["test-node"] = nodeMetadata{seenAt: time.Now().Add(-2 * nodeCtrl.ttl)} + before := updated.ResourceVersion + require.NoError(t, nodeCtrl.handleNode(t.Context(), updated)) + again, err := kubeClient.CoreV1().Nodes().Get(t.Context(), "test-node", metav1.GetOptions{}) + require.NoError(t, err) + assert.Equal(t, before, again.ResourceVersion) +} + func TestNodeController_metadataNeedsRefresh(t *testing.T) { publicIP := net.ParseIP("172.234.31.123") privateIP := net.ParseIP("192.168.159.135")