Repository: kubernetes/kubernetes
Pull request #130161: kubelet: clean up cloud provider code because cloud provider only supports empty or external and cloud is nil
Author: login: carlory
Labels: name: area/kubelet
name: kind/cleanup
description: Categorizes issue or PR as related to cleaning up code, process, or technical debt.
name: sig/scalability
description: Categorizes an issue or PR as relevant to SIG Scalability.
name: lgtm
description: "Looks good to me", indicates that a PR is ready to be merged.
name: area/cloudprovider
name: sig/node
description: Categorizes an issue or PR as relevant to SIG Node.
name: size/XXL
description: Denotes a PR that changes 1000+ lines, ignoring generated files.
name: release-note-action-required
description: Denotes a PR that introduces potentially breaking changes that require user action.
name: approved
description: Indicates a PR has been approved by an approver from all required OWNERS files.
name: cncf-cla: yes
description: Indicates the PR's author has signed the CNCF CLA.
name: sig/cloud-provider
description: Categorizes an issue or PR as relevant to SIG Cloud Provider.
name: needs-priority
description: Indicates a PR lacks a `priority/foo` label and requires one.
name: triage/accepted
description: Indicates an issue or PR is ready to be actively worked on.
Created: 2025-02-14T10:23:56Z | Merged: 2025-05-17T20:05:14Z

<!--  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 cleanup

#### What this PR does / why we need it:

A follow-up of https://github.com/kubernetes/kubernetes/pull/124519

the `--cloud-provider` flag of kubelet only supports empty or external, and cloud is nil

#### 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`_*
-->
Related to https://github.com/kubernetes/enhancements/issues/2395

#### 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
ACTION REQUIRED:
kubelet:  removed the deprecated flag `--cloud-config` from the command line.
```

#### 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
- [KEP]: https://github.com/kubernetes/enhancements/issues/2395
```



Diff:
diff --git a/cmd/kubelet/app/options/options.go b/cmd/kubelet/app/options/options.go
index a6efdadb7a9c5..5c68c49f6ee70 100644
--- a/cmd/kubelet/app/options/options.go
+++ b/cmd/kubelet/app/options/options.go
@@ -290,14 +290,14 @@ func (f *KubeletFlags) AddFlags(mainfs *pflag.FlagSet) {
 		"On success, a kubeconfig file referencing the generated client certificate and key is written to the path specified by --kubeconfig. "+
 		"The client certificate and key file will be stored in the directory pointed by --cert-dir.")
 
-	fs.StringVar(&f.HostnameOverride, "hostname-override", f.HostnameOverride, "If non-empty, will use this string as identification instead of the actual hostname. If --cloud-provider is set, the cloud provider determines the name of the node (consult cloud provider documentation to determine if and how the hostname is used).")
+	fs.StringVar(&f.HostnameOverride, "hostname-override", f.HostnameOverride, "If non-empty, will use this string as identification instead of the actual hostname.")
 
 	fs.StringVar(&f.NodeIP, "node-ip", f.NodeIP, "IP address (or comma-separated dual-stack IP addresses) of the node. If unset, kubelet will use the node's default IPv4 address, if any, or its default IPv6 address if it has no IPv4 addresses. You can pass '::' to make it prefer the default IPv6 address rather than the default IPv4 address. If cloud-provider is set to external, this flag will help to bootstrap the node with the corresponding IP.")
 
 	fs.StringVar(&f.CertDirectory, "cert-dir", f.CertDirectory, "The directory where the TLS certs are located. "+
 		"If --tls-cert-file and --tls-private-key-file are provided, this flag will be ignored.")
 
-	fs.StringVar(&f.CloudProvider, "cloud-provider", f.CloudProvider, "The provider for cloud services. Set to empty string for running with no cloud provider. Set to 'external' for running with an external cloud provider. If set, the cloud provider determines the name of the node (consult cloud provider documentation to determine if and how the hostname is used).")
+	fs.StringVar(&f.CloudProvider, "cloud-provider", f.CloudProvider, "The provider for cloud services. Set to empty string for running with no cloud provider. Set to 'external' for running with an external cloud provider.")
 
 	fs.StringVar(&f.RootDirectory, "root-dir", f.RootDirectory, "Directory path for managing kubelet files (volume mounts,etc).")
 	fs.BoolVar(&f.SeccompDefault, "seccomp-default", f.SeccompDefault, "Enable the use of `RuntimeDefault` as the default seccomp profile for all workloads.")
@@ -320,8 +320,6 @@ func (f *KubeletFlags) AddFlags(mainfs *pflag.FlagSet) {
 	fs.MarkDeprecated("register-schedulable", "will be removed in a future version")
 	fs.StringVar(&f.ExperimentalMounterPath, "experimental-mounter-path", f.ExperimentalMounterPath, "[Experimental] Path of mounter binary. Leave empty to use the default mount.")
 	fs.MarkDeprecated("experimental-mounter-path", "will be removed in 1.25 or later. in favor of using CSI.")
-	fs.StringVar(&f.CloudConfigFile, "cloud-config", f.CloudConfigFile, "The path to the cloud provider configuration file. Empty string for no configuration file.")
-	fs.MarkDeprecated("cloud-config", "will be removed in 1.25 or later, in favor of removing cloud provider code from Kubelet.")
 	fs.BoolVar(&f.ExperimentalNodeAllocatableIgnoreEvictionThreshold, "experimental-allocatable-ignore-eviction", f.ExperimentalNodeAllocatableIgnoreEvictionThreshold, "When set to 'true', Hard Eviction Thresholds will be ignored while calculating Node Allocatable. See https://kubernetes.io/docs/tasks/administer-cluster/reserve-compute-resources/ for more details. [default=false]")
 	fs.MarkDeprecated("experimental-allocatable-ignore-eviction", "will be removed in 1.25 or later.")
 }
diff --git a/cmd/kubelet/app/server.go b/cmd/kubelet/app/server.go
index 8121eca8374fa..bb8898c6c4f72 100644
--- a/cmd/kubelet/app/server.go
+++ b/cmd/kubelet/app/server.go
@@ -75,7 +75,6 @@ import (
 	"k8s.io/client-go/util/certificate"
 	"k8s.io/client-go/util/connrotation"
 	"k8s.io/client-go/util/keyutil"
-	cloudprovider "k8s.io/cloud-provider"
 	cliflag "k8s.io/component-base/cli/flag"
 	"k8s.io/component-base/configz"
 	"k8s.io/component-base/featuregate"
@@ -505,7 +504,6 @@ func UnsecuredDependencies(s *options.KubeletServer, featureGate featuregate.Fea
 	return &kubelet.Dependencies{
 		Auth:                nil, // default does not enforce auth[nz]
 		CAdvisorInterface:   nil, // cadvisor.New launches background processes (bg http.ListenAndServe, and some bg cleaners), not set here
-		Cloud:               nil, // cloud provider might start background processes
 		ContainerManager:    nil,
 		KubeClient:          nil,
 		HeartbeatClient:     nil,
@@ -661,22 +659,11 @@ func run(ctx context.Context, s *options.KubeletServer, kubeDeps *kubelet.Depend
 		}
 	}
 
-	if kubeDeps.Cloud == nil {
-		if !cloudprovider.IsExternal(s.CloudProvider) && len(s.CloudProvider) != 0 {
-			// internal cloud provider loops are disabled
-			cloudprovider.DisableWarningForProvider(s.CloudProvider)
-			return cloudprovider.ErrorForDisabledProvider(s.CloudProvider)
-		}
-	}
-
 	hostName, err := nodeutil.GetHostname(s.HostnameOverride)
 	if err != nil {
 		return err
 	}
-	nodeName, err := getNodeName(kubeDeps.Cloud, hostName)
-	if err != nil {
-		return err
-	}
+	nodeName := types.NodeName(hostName)
 
 	// if in standalone mode, indicate as much by setting all clients to nil
 	switch {
@@ -1112,28 +1099,6 @@ func kubeClientConfigOverrides(s *options.KubeletServer, clientConfig *restclien
 	clientConfig.Burst = int(s.KubeAPIBurst)
 }
 
-// getNodeName returns the node name according to the cloud provider
-// if cloud provider is specified. Otherwise, returns the hostname of the node.
-func getNodeName(cloud cloudprovider.Interface, hostname string) (types.NodeName, error) {
-	if cloud == nil {
-		return types.NodeName(hostname), nil
-	}
-
-	instances, ok := cloud.Instances()
-	if !ok {
-		return "", fmt.Errorf("failed to get instances from cloud provider")
-	}
-
-	nodeName, err := instances.CurrentNodeName(context.TODO(), hostname)
-	if err != nil {
-		return "", fmt.Errorf("error fetching current node name from cloud provider: %w", err)
-	}
-
-	klog.V(2).InfoS("Cloud provider determined current node", "nodeName", klog.KRef("", string(nodeName)))
-
-	return nodeName, nil
-}
-
 // InitializeTLS checks for a configured TLSCertFile and TLSPrivateKeyFile: if unspecified a new self-signed
 // certificate and key file are generated. Returns a configured server.TLSOptions object.
 func InitializeTLS(kf *options.KubeletFlags, kc *kubeletconfiginternal.KubeletConfiguration) (*server.TLSOptions, error) {
@@ -1244,12 +1209,7 @@ func RunKubelet(ctx context.Context, kubeServer *options.KubeletServer, kubeDeps
 	if err != nil {
 		return err
 	}
-	// Query the cloud provider for our node name, default to hostname if kubeDeps.Cloud == nil
-	nodeName, err := getNodeName(kubeDeps.Cloud, hostname)
-	if err != nil {
-		return err
-	}
-	hostnameOverridden := len(kubeServer.HostnameOverride) > 0
+	nodeName := types.NodeName(hostname)
 	// Setup event recorder if required.
 	makeEventRecorder(ctx, kubeDeps, nodeName)
 
@@ -1275,7 +1235,6 @@ func RunKubelet(ctx context.Context, kubeServer *options.KubeletServer, kubeDeps
 	k, err := createAndInitKubelet(kubeServer,
 		kubeDeps,
 		hostname,
-		hostnameOverridden,
 		nodeName,
 		nodeIPs)
 	if err != nil {
@@ -1316,7 +1275,6 @@ func startKubelet(k kubelet.Bootstrap, podCfg *config.PodConfig, kubeCfg *kubele
 func createAndInitKubelet(kubeServer *options.KubeletServer,
 	kubeDeps *kubelet.Dependencies,
 	hostname string,
-	hostnameOverridden bool,
 	nodeName types.NodeName,
 	nodeIPs []net.IP) (k kubelet.Bootstrap, err error) {
 	// TODO: block until all sources have delivered at least one update to the channel, or break the sync loop
@@ -1326,7 +1284,6 @@ func createAndInitKubelet(kubeServer *options.KubeletServer,
 		kubeDeps,
 		&kubeServer.ContainerRuntimeOptions,
 		hostname,
-		hostnameOverridden,
 		nodeName,
 		nodeIPs,
 		kubeServer.ProviderID,
diff --git a/pkg/kubelet/cloudresource/cloud_request_manager.go b/pkg/kubelet/cloudresource/cloud_request_manager.go
deleted file mode 100644
index fafec971f9c2e..0000000000000
--- a/pkg/kubelet/cloudresource/cloud_request_manager.go
+++ /dev/null
@@ -1,135 +0,0 @@
-/*
-Copyright 2018 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 cloudresource
-
-import (
-	"context"
-	"fmt"
-	"sync"
-	"time"
-
-	"k8s.io/api/core/v1"
-	"k8s.io/apimachinery/pkg/types"
-	"k8s.io/apimachinery/pkg/util/wait"
-	cloudprovider "k8s.io/cloud-provider"
-
-	"k8s.io/klog/v2"
-)
-
-// SyncManager is an interface for making requests to a cloud provider
-type SyncManager interface {
-	Run(stopCh <-chan struct{})
-	NodeAddresses() ([]v1.NodeAddress, error)
-}
-
-var _ SyncManager = &cloudResourceSyncManager{}
-
-type cloudResourceSyncManager struct {
-	// Cloud provider interface.
-	cloud cloudprovider.Interface
-	// Sync period
-	syncPeriod time.Duration
-
-	nodeAddressesMonitor *sync.Cond
-	nodeAddressesErr     error
-	nodeAddresses        []v1.NodeAddress
-
-	nodeName types.NodeName
-}
-
-// NewSyncManager creates a manager responsible for collecting resources from a
-// cloud provider through requests that are sensitive to timeouts and hanging
-func NewSyncManager(cloud cloudprovider.Interface, nodeName types.NodeName, syncPeriod time.Duration) SyncManager {
-	return &cloudResourceSyncManager{
-		cloud:      cloud,
-		syncPeriod: syncPeriod,
-		nodeName:   nodeName,
-		// nodeAddressesMonitor is a monitor that guards a result (nodeAddresses,
-		// nodeAddressesErr) of the sync loop under the condition that a result has
-		// been saved at least once. The semantics here are:
-		//
-		// * Readers of the result will wait on the monitor until the first result
-		//   has been saved.
-		// * The sync loop (i.e. the only writer), will signal all waiters every
-		//   time it updates the result.
-		nodeAddressesMonitor: sync.NewCond(&sync.Mutex{}),
-	}
-}
-
-// NodeAddresses waits for the first sync loop to run. If no successful syncs
-// have run, it will return the most recent error. If node addresses have been
-// synced successfully, it will return the list of node addresses from the most
-// recent successful sync.
-func (m *cloudResourceSyncManager) NodeAddresses() ([]v1.NodeAddress, error) {
-	m.nodeAddressesMonitor.L.Lock()
-	defer m.nodeAddressesMonitor.L.Unlock()
-	// wait until there is something
-	for {
-		if addrs, err := m.nodeAddresses, m.nodeAddressesErr; len(addrs) > 0 || err != nil {
-			return addrs, err
-		}
-		klog.V(5).InfoS("Waiting for cloud provider to provide node addresses")
-		m.nodeAddressesMonitor.Wait()
-	}
-}
-
-// getNodeAddresses calls the cloud provider to get a current list of node addresses.
-func (m *cloudResourceSyncManager) getNodeAddresses() ([]v1.NodeAddress, error) {
-	// TODO(roberthbailey): Can we do this without having credentials to talk to
-	// the cloud provider?
-	// TODO(justinsb): We can if CurrentNodeName() was actually CurrentNode() and
-	// returned an interface.
-	// TODO: If IP addresses couldn't be fetched from the cloud provider, should
-	// kubelet fallback on the other methods for getting the IP below?
-	instances, ok := m.cloud.Instances()
-	if !ok {
-		return nil, fmt.Errorf("failed to get instances from cloud provider")
-	}
-	return instances.NodeAddresses(context.TODO(), m.nodeName)
-}
-
-func (m *cloudResourceSyncManager) syncNodeAddresses() {
-	klog.V(5).InfoS("Requesting node addresses from cloud provider for node", "nodeName", m.nodeName)
-
-	addrs, err := m.getNodeAddresses()
-
-	m.nodeAddressesMonitor.L.Lock()
-	defer m.nodeAddressesMonitor.L.Unlock()
-	defer m.nodeAddressesMonitor.Broadcast()
-
-	if err != nil {
-		klog.V(2).InfoS("Node addresses from cloud provider for node not collected", "nodeName", m.nodeName, "err", err)
-
-		if len(m.nodeAddresses) > 0 {
-			// in the event that a sync loop fails when a previous sync had
-			// succeeded, continue to use the old addresses.
-			return
-		}
-
-		m.nodeAddressesErr = fmt.Errorf("failed to get node address from cloud provider: %v", err)
-		return
-	}
-
-	klog.V(5).InfoS("Node addresses from cloud provider for node collected", "nodeName", m.nodeName)
-	m.nodeAddressesErr = nil
-	m.nodeAddresses = addrs
-}
-
-// Run starts the cloud resource sync manager's sync loop.
-func (m *cloudResourceSyncManager) Run(stopCh <-chan struct{}) {
-	wait.Until(m.syncNodeAddresses, m.syncPeriod, stopCh)
-}
diff --git a/pkg/kubelet/cloudresource/cloud_request_manager_test.go b/pkg/kubelet/cloudresource/cloud_request_manager_test.go
deleted file mode 100644
index f98793380c2cf..0000000000000
--- a/pkg/kubelet/cloudresource/cloud_request_manager_test.go
+++ /dev/null
@@ -1,147 +0,0 @@
-/*
-Copyright 2018 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 cloudresource
-
-import (
-	"errors"
-	"reflect"
-	"testing"
-	"time"
-
-	"github.com/google/go-cmp/cmp"
-	v1 "k8s.io/api/core/v1"
-	"k8s.io/cloud-provider/fake"
-)
-
-func createNodeInternalIPAddress(address string) []v1.NodeAddress {
-	return []v1.NodeAddress{
-		{
-			Type:    v1.NodeInternalIP,
-			Address: address,
-		},
-	}
-}
-
-func TestNodeAddressesDelay(t *testing.T) {
-	syncPeriod := 100 * time.Millisecond
-	cloud := &fake.Cloud{
-		Addresses: createNodeInternalIPAddress("10.0.1.12"),
-		// Set the request delay so the manager timeouts and collects the node addresses later
-		RequestDelay: 200 * time.Millisecond,
-	}
-	stopCh := make(chan struct{})
-	defer close(stopCh)
-
-	manager := NewSyncManager(cloud, "defaultNode", syncPeriod).(*cloudResourceSyncManager)
-	go manager.Run(stopCh)
-
-	nodeAddresses, err := manager.NodeAddresses()
-	if err != nil {
-		t.Errorf("Unexpected err: %q\n", err)
-	}
-	if !reflect.DeepEqual(nodeAddresses, cloud.Addresses) {
-		t.Errorf("Unexpected diff of node addresses: %v", cmp.Diff(nodeAddresses, cloud.Addresses))
-	}
-
-	// Change the IP address
-	cloud.SetNodeAddresses(createNodeInternalIPAddress("10.0.1.13"))
-
-	// Wait until the IP address changes
-	maxRetry := 5
-	for i := 0; i < maxRetry; i++ {
-		nodeAddresses, err := manager.NodeAddresses()
-		t.Logf("nodeAddresses: %#v, err: %v", nodeAddresses, err)
-		if err != nil {
-			t.Errorf("Unexpected err: %q\n", err)
-		}
-		// It is safe to read cloud.Addresses since no routine is changing the value at the same time
-		if err == nil && nodeAddresses[0].Address != cloud.Addresses[0].Address {
-			time.Sleep(syncPeriod)
-			continue
-		}
-		if err != nil {
-			t.Errorf("Unexpected err: %q\n", err)
-		}
-		return
-	}
-	t.Errorf("Timeout waiting for %q address to appear", cloud.Addresses[0].Address)
-}
-
-func TestNodeAddressesUsesLastSuccess(t *testing.T) {
-	cloud := &fake.Cloud{}
-	manager := NewSyncManager(cloud, "defaultNode", 0).(*cloudResourceSyncManager)
-
-	// These tests are stateful and order dependent.
-	tests := []struct {
-		name                   string
-		addrs                  []v1.NodeAddress
-		err                    error
-		wantAddrs              []v1.NodeAddress
-		wantErr                bool
-		shouldDisableInstances bool
-	}{
-		{
-			name:    "first sync loop encounters an error",
-			err:     errors.New("bad"),
-			wantErr: true,
-		},
-		{
-			name:                   "failed to get instances from cloud provider",
-			err:                    errors.New("failed to get instances from cloud provider"),
-			wantErr:                true,
-			shouldDisableInstances: true,
-		},
-		{
-			name:      "subsequent sync loop succeeds",
-			addrs:     createNodeInternalIPAddress("10.0.1.12"),
-			wantAddrs: createNodeInternalIPAddress("10.0.1.12"),
-		},
-		{
-			name:      "subsequent sync loop encounters an error, last addresses returned",
-			err:       errors.New("bad"),
-			wantAddrs: createNodeInternalIPAddress("10.0.1.12"),
-		},
-		{
-			name:      "subsequent sync loop succeeds changing addresses",
-			addrs:     createNodeInternalIPAddress("10.0.1.13"),
-			wantAddrs: createNodeInternalIPAddress("10.0.1.13"),
-		},
-	}
-
-	for _, test := range tests {
-		t.Run(test.name, func(t *testing.T) {
-			cloud.Addresses = test.addrs
-			cloud.Err = test.err
-
-			if test.shouldDisableInstances {
-				cloud.DisableInstances = true
-				defer func() {
-					cloud.DisableInstances = false
-				}()
-			}
-
-			manager.syncNodeAddresses()
-			nodeAddresses, err := manager.NodeAddresses()
-			if (err != nil) != test.wantErr {
-				t.Errorf("unexpected err: %v", err)
-			}
-			if got, want := nodeAddresses, test.wantAddrs; !reflect.DeepEqual(got, want) {
-				t.Errorf("Unexpected diff of node addresses: %v", cmp.Diff(got, want))
-			}
-		})
-	}
-}
diff --git a/pkg/kubelet/kubelet.go b/pkg/kubelet/kubelet.go
index ced300f6432bc..6dbbf79a9bb1c 100644
--- a/pkg/kubelet/kubelet.go
+++ b/pkg/kubelet/kubelet.go
@@ -85,7 +85,6 @@ import (
 	"k8s.io/kubernetes/pkg/kubelet/apis/podresources"
 	"k8s.io/kubernetes/pkg/kubelet/cadvisor"
 	kubeletcertificate "k8s.io/kubernetes/pkg/kubelet/certificate"
-	"k8s.io/kubernetes/pkg/kubelet/cloudresource"
 	"k8s.io/kubernetes/pkg/kubelet/clustertrustbundle"
 	"k8s.io/kubernetes/pkg/kubelet/cm"
 	"k8s.io/kubernetes/pkg/kubelet/cm/topologymanager"
@@ -304,7 +303,6 @@ type Dependencies struct {
 	Flagz                     flagz.Reader
 	Auth                      server.AuthInterface
 	CAdvisorInterface         cadvisor.Interface
-	Cloud                     cloudprovider.Interface
 	ContainerManager          cm.ContainerManager
 	EventClient               v1core.EventsGetter
 	HeartbeatClient           clientset.Interface
@@ -420,7 +418,6 @@ func NewMainKubelet(kubeCfg *kubeletconfiginternal.KubeletConfiguration,
 	kubeDeps *Dependencies,
 	crOptions *config.ContainerRuntimeOptions,
 	hostname string,
-	hostnameOverridden bool,
 	nodeName types.NodeName,
 	nodeIPs []net.IP,
 	providerID string,
@@ -459,7 +456,7 @@ func NewMainKubelet(kubeCfg *kubeletconfiginternal.KubeletConfiguration,
 
 	if !cloudprovider.IsExternal(cloudProvider) && len(cloudProvider) != 0 {
 		cloudprovider.DisableWarningForProvider(cloudProvider)
-		return nil, fmt.Errorf("cloud provider %q was specified, but built-in cloud providers are disabled. Please set --cloud-provider=external and migrate to an external cloud provider", cloudProvider)
+		return nil, cloudprovider.ErrorForDisabledProvider(cloudProvider)
 	}
 
 	var nodeHasSynced cache.InformerSynced
@@ -600,7 +597,6 @@ func NewMainKubelet(kubeCfg *kubeletconfiginternal.KubeletConfiguration,
 
 	klet := &Kubelet{
 		hostname:                       hostname,
-		hostnameOverridden:             hostnameOverridden,
 		nodeName:                       nodeName,
 		kubeClient:                     kubeDeps.KubeClient,
 		heartbeatClient:                kubeDeps.HeartbeatClient,
@@ -620,7 +616,6 @@ func NewMainKubelet(kubeCfg *kubeletconfiginternal.KubeletConfiguration,
 		streamingConnectionIdleTimeout: kubeCfg.StreamingConnectionIdleTimeout.Duration,
 		recorder:                       kubeDeps.Recorder,
 		cadvisor:                       kubeDeps.CAdvisorInterface,
-		cloud:                          kubeDeps.Cloud,
 		externalCloudProvider:          cloudprovider.IsExternal(cloudProvider),
 		providerID:                     providerID,
 		nodeRef:                        nodeRef,
@@ -650,10 +645,6 @@ func NewMainKubelet(kubeCfg *kubeletconfiginternal.KubeletConfiguration,
 		flagz:                          kubeDeps.Flagz,
 	}
 
-	if klet.cloud != nil {
-		klet.cloudResourceSyncManager = cloudresource.NewSyncManager(klet.cloud, nodeName, klet.nodeStatusUpdateFrequency)
-	}
-
 	var secretManager secret.Manager
 	var configMapManager configmap.Manager
 	if klet.kubeClient != nil {
@@ -1081,8 +1072,6 @@ type Kubelet struct {
 
 	// hostname is the hostname the kubelet detected or was given via flag/config
 	hostname string
-	// hostnameOverridden indicates the hostname was overridden via flag/config
-	hostnameOverridden bool
 
 	nodeName        types.NodeName
 	runtimeCache    kubecontainer.RuntimeCache
@@ -1263,11 +1252,6 @@ type Kubelet struct {
 	// Handles certificate rotations.
 	serverCertificateManager certificate.Manager
 
-	// Cloud provider interface.
-	cloud cloudprovider.Interface
-	// Handles requests to cloud provider with timeout
-	cloudResourceSyncManager cloudresource.SyncManager
-
 	// Indicates that the node initialization happens in an external cloud controller
 	externalCloudProvider bool
 	// Reference to this node.
@@ -1754,11 +1738,6 @@ func (kl *Kubelet) Run(updates <-chan kubetypes.PodUpdate) {
 		klog.InfoS("No API server defined - no node status update will be sent")
 	}
 
-	// Start the cloud provider sync manager
-	if kl.cloudResourceSyncManager != nil {
-		go kl.cloudResourceSyncManager.Run(wait.NeverStop)
-	}
-
 	if err := kl.initializeModules(ctx); err != nil {
 		kl.recorder.Eventf(kl.nodeRef, v1.EventTypeWarning, events.KubeletSetupFailed, err.Error())
 		klog.ErrorS(err, "Failed to initialize internal modules")
diff --git a/pkg/kubelet/kubelet_network.go b/pkg/kubelet/kubelet_network.go
index 4943a53f32441..c182a47421d1b 100644
--- a/pkg/kubelet/kubelet_network.go
+++ b/pkg/kubelet/kubelet_network.go
@@ -25,20 +25,6 @@ import (
 	"k8s.io/klog/v2"
 )
 
-// providerRequiresNetworkingConfiguration returns whether the cloud provider
-// requires special networking configuration.
-func (kl *Kubelet) providerRequiresNetworkingConfiguration() bool {
-	// TODO: We should have a mechanism to say whether native cloud provider
-	// is used or whether we are using overlay networking. We should return
-	// true for cloud providers if they implement Routes() interface and
-	// we are not using overlay networking.
-	if kl.cloud == nil || kl.cloud.ProviderName() != "gce" {
-		return false
-	}
-	_, supported := kl.cloud.Routes()
-	return supported
-}
-
 // updatePodCIDR updates the pod CIDR in the runtime state if it is different
 // from the current CIDR. Return true if pod CIDR is actually changed.
 func (kl *Kubelet) updatePodCIDR(ctx context.Context, cidr string) (bool, error) {
diff --git a/pkg/kubelet/kubelet_node_status.go b/pkg/kubelet/kubelet_node_status.go
index ebe36617f05b9..f2acc9d542150 100644
--- a/pkg/kubelet/kubelet_node_status.go
+++ b/pkg/kubelet/kubelet_node_status.go
@@ -34,7 +34,6 @@ import (
 	utilnet "k8s.io/apimachinery/pkg/util/net"
 	"k8s.io/apimachinery/pkg/util/sets"
 	utilfeature "k8s.io/apiserver/pkg/util/feature"
-	cloudprovider "k8s.io/cloud-provider"
 	cloudproviderapi "k8s.io/cloud-provider/api"
 	nodeutil "k8s.io/component-helpers/node/util"
 	"k8s.io/klog/v2"
@@ -349,16 +348,6 @@ func (kl *Kubelet) initialNode(ctx context.Context) (*v1.Node, error) {
 	if len(nodeTaints) > 0 {
 		node.Spec.Taints = nodeTaints
 	}
-	// Initially, set NodeNetworkUnavailable to true.
-	if kl.providerRequiresNetworkingConfiguration() {
-		node.Status.Conditions = append(node.Status.Conditions, v1.NodeCondition{
-			Type:               v1.NodeNetworkUnavailable,
-			Status:             v1.ConditionTrue,
-			Reason:             "NoRouteCreated",
-			Message:            "Node created without a route",
-			LastTransitionTime: metav1.NewTime(kl.clock.Now()),
-		})
-	}
 
 	if kl.enableControllerAttachDetach {
 		if node.Annotations == nil {
@@ -383,55 +372,6 @@ func (kl *Kubelet) initialNode(ctx context.Context) (*v1.Node, error) {
 		node.Spec.ProviderID = kl.providerID
 	}
 
-	if kl.cloud != nil {
-		instances, ok := kl.cloud.Instances()
-		if !ok {
-			return nil, fmt.Errorf("failed to get instances from cloud provider")
-		}
-
-		// TODO: We can't assume that the node has credentials to talk to the
-		// cloudprovider from arbitrary nodes. At most, we should talk to a
-		// local metadata server here.
-		var err error
-		if node.Spec.ProviderID == "" {
-			node.Spec.ProviderID, err = cloudprovider.GetInstanceProviderID(ctx, kl.cloud, kl.nodeName)
-			if err != nil {
-				return nil, err
-			}
-		}
-
-		instanceType, err := instances.InstanceType(ctx, kl.nodeName)
-		if err != nil {
-			return nil, err
-		}
-		if instanceType != "" {
-			klog.InfoS("Adding label from cloud provider", "labelKey", v1.LabelInstanceType, "labelValue", instanceType)
-			node.ObjectMeta.Labels[v1.LabelInstanceType] = instanceType
-			klog.InfoS("Adding node label from cloud provider", "labelKey", v1.LabelInstanceTypeStable, "labelValue", instanceType)
-			node.ObjectMeta.Labels[v1.LabelInstanceTypeStable] = instanceType
-		}
-		// If the cloud has zone information, label the node with the zone information
-		zones, ok := kl.cloud.Zones()
-		if ok {
-			zone, err := zones.GetZone(ctx)
-			if err != nil {
-				return nil, fmt.Errorf("failed to get zone from cloud provider: %v", err)
-			}
-			if zone.FailureDomain != "" {
-				klog.InfoS("Adding node label from cloud provider", "labelKey", v1.LabelFailureDomainBetaZone, "labelValue", zone.FailureDomain)
-				node.ObjectMeta.Labels[v1.LabelFailureDomainBetaZone] = zone.FailureDomain
-				klog.InfoS("Adding node label from cloud provider", "labelKey", v1.LabelTopologyZone, "labelValue", zone.FailureDomain)
-				node.ObjectMeta.Labels[v1.LabelTopologyZone] = zone.FailureDomain
-			}
-			if zone.Region != "" {
-				klog.InfoS("Adding node label from cloud provider", "labelKey", v1.LabelFailureDomainBetaRegion, "labelValue", zone.Region)
-				node.ObjectMeta.Labels[v1.LabelFailureDomainBetaRegion] = zone.Region
-				klog.InfoS("Adding node label from cloud provider", "labelKey", v1.LabelTopologyRegion, "labelValue", zone.Region)
-				node.ObjectMeta.Labels[v1.LabelTopologyRegion] = zone.Region
-			}
-		}
-	}
-
 	kl.setNodeStatus(ctx, node)
 
 	return node, nil
@@ -735,14 +675,9 @@ func (kl *Kubelet) getLastObservedNodeAddresses() []v1.NodeAddress {
 // defaultNodeStatusFuncs is a factory that generates the default set of
 // setNodeStatus funcs
 func (kl *Kubelet) defaultNodeStatusFuncs() []func(context.Context, *v1.Node) error {
-	// if cloud is not nil, we expect the cloud resource sync manager to exist
-	var nodeAddressesFunc func() ([]v1.NodeAddress, error)
-	if kl.cloud != nil {
-		nodeAddressesFunc = kl.cloudResourceSyncManager.NodeAddresses
-	}
 	var setters []func(ctx context.Context, n *v1.Node) error
 	setters = append(setters,
-		nodestatus.NodeAddress(kl.nodeIPs, kl.nodeIPValidator, kl.hostname, kl.hostnameOverridden, kl.externalCloudProvider, kl.cloud, nodeAddressesFunc, utilnet.ResolveBindAddress),
+		nodestatus.NodeAddress(kl.nodeIPs, kl.nodeIPValidator, kl.hostname, kl.externalCloudProvider, utilnet.ResolveBindAddress),
 		nodestatus.MachineInfo(string(kl.nodeName), kl.maxPods, kl.podsPerCore, kl.GetCachedMachineInfo, kl.containerManager.GetCapacity,
 			kl.containerManager.GetDevicePluginResourceCapacity, kl.containerManager.GetNodeAllocatableReservation, kl.recordEvent, kl.supportLocalStorageCapacityIsolation()),
 		nodestatus.VersionInfo(kl.cadvisor.VersionInfo, kl.containerRuntime.Type, kl.containerRuntime.Version),
diff --git a/pkg/kubelet/kubelet_test.go b/pkg/kubelet/kubelet_test.go
index c8e3500d6d6a4..03d542923475c 100644
--- a/pkg/kubelet/kubelet_test.go
+++ b/pkg/kubelet/kubelet_test.go
@@ -3393,7 +3393,6 @@ func TestNewMainKubeletStandAlone(t *testing.T) {
 	kubeDep := &Dependencies{
 		Auth:                 nil,
 		CAdvisorInterface:    cadvisor,
-		Cloud:                nil,
 		ContainerManager:     cm.NewStubContainerManager(),
 		KubeClient:           nil, // standalone mode
 		HeartbeatClient:      nil,
@@ -3417,7 +3416,6 @@ func TestNewMainKubeletStandAlone(t *testing.T) {
 		kubeDep,
 		crOptions,
 		"hostname",
-		false,
 		"hostname",
 		[]net.IP{},
 		"",
diff --git a/pkg/kubelet/nodestatus/setters.go b/pkg/kubelet/nodestatus/setters.go
index aa0c17b86ca6c..24728267a302d 100644
--- a/pkg/kubelet/nodestatus/setters.go
+++ b/pkg/kubelet/nodestatus/setters.go
@@ -33,9 +33,7 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/util/errors"
 	utilfeature "k8s.io/apiserver/pkg/util/feature"
-	cloudprovider "k8s.io/cloud-provider"
 	cloudproviderapi "k8s.io/cloud-provider/api"
-	cloudprovidernodeutil "k8s.io/cloud-provider/node/helpers"
 	"k8s.io/component-base/version"
 	v1helper "k8s.io/kubernetes/pkg/apis/core/v1/helper"
 	"k8s.io/kubernetes/pkg/features"
@@ -66,10 +64,7 @@ var rebootEvent sync.Once
 func NodeAddress(nodeIPs []net.IP, // typically Kubelet.nodeIPs
 	validateNodeIPFunc func(net.IP) error, // typically Kubelet.nodeIPValidator
 	hostname string, // typically Kubelet.hostname
-	hostnameOverridden bool, // was the hostname force set?
 	externalCloudProvider bool, // typically Kubelet.externalCloudProvider
-	cloud cloudprovider.Interface, // typically Kubelet.cloud
-	nodeAddressesFunc func() ([]v1.NodeAddress, error), // typically Kubelet.cloudResourceSyncManager.NodeAddresses
 	resolveAddressFunc func(net.IP) (net.IP, error), // typically k8s.io/apimachinery/pkg/util/net.ResolveBindAddress
 ) Setter {
 	var nodeIP, secondaryNodeIP net.IP
@@ -99,16 +94,9 @@ func NodeAddress(nodeIPs []net.IP, // typically Kubelet.nodeIPs
 			klog.V(4).InfoS("Using secondary node IP", "IP", secondaryNodeIP.String())
 		}
 
-		if (externalCloudProvider || cloud != nil) && nodeIPSpecified {
+		if externalCloudProvider && nodeIPSpecified {
 			// Annotate the Node object with nodeIP for external cloud provider.
 			//
-			// We do this even when external CCM is not configured to cover a situation
-			// during migration from legacy to external CCM: when CCM is running the
-			// node controller in the cluster but kubelet is still running the in-tree
-			// provider. Adding this annotation in all cases ensures that while
-			// Addresses flap between the competing controllers, they at least flap
-			// consistently.
-			//
 			// We do not add the annotation in the case where there is no cloud
 			// controller at all, as we don't expect to migrate these clusters to use an
 			// external CCM.
@@ -149,52 +137,7 @@ func NodeAddress(nodeIPs []net.IP, // typically Kubelet.nodeIPs
 				return nil
 			}
 		}
-		if cloud != nil {
-			cloudNodeAddresses, err := nodeAddressesFunc()
-			if err != nil {
-				return err
-			}
-
-			nodeAddresses, err := cloudprovidernodeutil.GetNodeAddressesFromNodeIPLegacy(nodeIP, cloudNodeAddresses)
-			if err != nil {
-				return err
-			}
-
-			switch {
-			case len(cloudNodeAddresses) == 0:
-				// the cloud provider didn't specify any addresses
-				nodeAddresses = append(nodeAddresses, v1.NodeAddress{Type: v1.NodeHostName, Address: hostname})
-
-			case !hasAddressType(cloudNodeAddresses, v1.NodeHostName) && hasAddressValue(cloudNodeAddresses, hostname):
-				// the cloud provider didn't specify an address of type Hostname,
-				// but the auto-detected hostname matched an address reported by the cloud provider,
-				// so we can add it and count on the value being verifiable via cloud provider metadata
-				nodeAddresses = append(nodeAddresses, v1.NodeAddress{Type: v1.NodeHostName, Address: hostname})
-
-			case hostnameOverridden:
-				// the hostname was force-set via flag/config.
-				// this means the hostname might not be able to be validated via cloud provider metadata,
-				// but was a choice by the kubelet deployer we should honor
-				var existingHostnameAddress *v1.NodeAddress
-				for i := range nodeAddresses {
-					if nodeAddresses[i].Type == v1.NodeHostName {
-						existingHostnameAddress = &nodeAddresses[i]
-						break
-					}
-				}
-
-				if existingHostnameAddress == nil {
-					// no existing Hostname address found, add it
-					klog.InfoS("Adding overridden hostname to cloudprovider-reported addresses", "hostname", hostname)
-					nodeAddresses = append(nodeAddresses, v1.NodeAddress{Type: v1.NodeHostName, Address: hostname})
-				} else if existingHostnameAddress.Address != hostname {
-					// override the Hostname address reported by the cloud provider
-					klog.InfoS("Replacing cloudprovider-reported hostname with overridden hostname", "cloudProviderHostname", existingHostnameAddress.Address, "overriddenHostname", hostname)
-					existingHostnameAddress.Address = hostname
-				}
-			}
-			node.Status.Addresses = nodeAddresses
-		} else if nodeIPSpecified && secondaryNodeIPSpecified {
+		if nodeIPSpecified && secondaryNodeIPSpecified {
 			node.Status.Addresses = []v1.NodeAddress{
 				{Type: v1.NodeInternalIP, Address: nodeIP.String()},
 				{Type: v1.NodeInternalIP, Address: secondaryNodeIP.String()},
@@ -247,24 +190,6 @@ func NodeAddress(nodeIPs []net.IP, // typically Kubelet.nodeIPs
 	}
 }
 
-func hasAddressType(addresses []v1.NodeAddress, addressType v1.NodeAddressType) bool {
-	for _, address := range addresses {
-		if address.Type == addressType {
-			return true
-		}
-	}
-	return false
-}
-
-func hasAddressValue(addresses []v1.NodeAddress, addressValue string) bool {
-	for _, address := range addresses {
-		if address.Address == addressValue {
-			return true
-		}
-	}
-	return false
-}
-
 // MachineInfo returns a Setter that updates machine-related information on the node.
 func MachineInfo(nodeName string,
 	maxPods int,
diff --git a/pkg/kubelet/nodestatus/setters_test.go b/pkg/kubelet/nodestatus/setters_test.go
index 53d22b1adfb38..6e5971ed9afa6 100644
--- a/pkg/kubelet/nodestatus/setters_test.go
+++ b/pkg/kubelet/nodestatus/setters_test.go
@@ -38,8 +38,6 @@ import (
 	"k8s.io/apimachinery/pkg/util/rand"
 	"k8s.io/apimachinery/pkg/util/uuid"
 	utilfeature "k8s.io/apiserver/pkg/util/feature"
-	cloudprovider "k8s.io/cloud-provider"
-	fakecloud "k8s.io/cloud-provider/fake"
 	"k8s.io/component-base/featuregate"
 	featuregatetesting "k8s.io/component-base/featuregate/testing"
 	"k8s.io/component-base/version"
@@ -59,22 +57,13 @@ const (
 
 // TODO(mtaufen): below is ported from the old kubelet_node_status_test.go code, potentially add more test coverage for NodeAddress setter in future
 func TestNodeAddress(t *testing.T) {
-	type cloudProviderType int
-	const (
-		cloudProviderLegacy cloudProviderType = iota
-		cloudProviderExternal
-		cloudProviderNone
-	)
-
 	existingNodeAddress := v1.NodeAddress{Address: "10.1.1.2"}
 	cases := []struct {
 		name                           string
-		hostnameOverride               bool
 		nodeIP                         net.IP
 		secondaryNodeIP                net.IP
 		resolvedIP                     net.IP
-		cloudProviderType              cloudProviderType
-		nodeAddresses                  []v1.NodeAddress
+		cloudProvider                  bool
 		expectedAddresses              []v1.NodeAddress
 		existingAnnotations            map[string]string
 		expectedAnnotations            map[string]string
@@ -82,155 +71,9 @@ func TestNodeAddress(t *testing.T) {
 		shouldSetNodeAddressBeforeTest bool
 	}{
 		{
-			name:   "A single InternalIP",
-			nodeIP: netutils.ParseIPSloppy("10.1.1.1"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			shouldError: false,
-		},
-		{
-			name:   "NodeIP is external",
-			nodeIP: netutils.ParseIPSloppy("55.55.55.55"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			shouldError: false,
-		},
-		{
-			// Accommodating #45201 and #49202
-			name:   "InternalIP and ExternalIP are the same",
-			nodeIP: netutils.ParseIPSloppy("55.55.55.55"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "44.44.44.44"},
-				{Type: v1.NodeExternalIP, Address: "44.44.44.44"},
-				{Type: v1.NodeInternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			shouldError: false,
-		},
-		{
-			name:   "An Internal/ExternalIP, an Internal/ExternalDNS",
-			nodeIP: netutils.ParseIPSloppy("10.1.1.1"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeInternalDNS, Address: "ip-10-1-1-1.us-west-2.compute.internal"},
-				{Type: v1.NodeExternalDNS, Address: "ec2-55-55-55-55.us-west-2.compute.amazonaws.com"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeInternalDNS, Address: "ip-10-1-1-1.us-west-2.compute.internal"},
-				{Type: v1.NodeExternalDNS, Address: "ec2-55-55-55-55.us-west-2.compute.amazonaws.com"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			shouldError: false,
-		},
-		{
-			name:   "An Internal with multiple internal IPs",
-			nodeIP: netutils.ParseIPSloppy("10.1.1.1"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeInternalIP, Address: "10.2.2.2"},
-				{Type: v1.NodeInternalIP, Address: "10.3.3.3"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			shouldError: false,
-		},
-		{
-			name:   "An InternalIP that isn't valid: should error",
-			nodeIP: netutils.ParseIPSloppy("10.2.2.2"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: nil,
-			shouldError:       true,
-		},
-		{
-			name:          "no cloud reported hostnames",
-			nodeAddresses: []v1.NodeAddress{},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeHostName, Address: testKubeletHostname}, // detected hostname is auto-added in the absence of cloud-reported hostnames
-			},
-			shouldError: false,
-		},
-		{
-			name: "cloud reports hostname, no override",
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeHostName, Address: "cloud-host"},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeHostName, Address: "cloud-host"}, // cloud-reported hostname wins over detected hostname
-			},
-			shouldError: false,
-		},
-		{
-			name:   "cloud reports hostname, nodeIP is set, no override",
-			nodeIP: netutils.ParseIPSloppy("10.1.1.1"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeHostName, Address: "cloud-host"},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeHostName, Address: "cloud-host"}, // cloud-reported hostname wins over detected hostname
-			},
-			shouldError: false,
-		},
-		{
-			name: "cloud reports hostname, overridden",
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: "cloud-host"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname}, // hostname-override wins over cloud-reported hostname
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-			},
-			hostnameOverride: true,
-			shouldError:      false,
-		},
-		{
-			name:              "cloud provider is external and nodeIP specified",
-			nodeIP:            netutils.ParseIPSloppy("10.0.0.1"),
-			nodeAddresses:     []v1.NodeAddress{},
-			cloudProviderType: cloudProviderExternal,
+			name:          "using cloud provider and nodeIP specified",
+			nodeIP:        netutils.ParseIPSloppy("10.0.0.1"),
+			cloudProvider: true,
 			expectedAddresses: []v1.NodeAddress{
 				{Type: v1.NodeInternalIP, Address: "10.0.0.1"},
 				{Type: v1.NodeHostName, Address: testKubeletHostname},
@@ -238,11 +81,10 @@ func TestNodeAddress(t *testing.T) {
 			shouldError: false,
 		},
 		{
-			name:              "no cloud provider and nodeIP IPv4 unspecified",
-			nodeIP:            netutils.ParseIPSloppy("0.0.0.0"),
-			resolvedIP:        netutils.ParseIPSloppy("10.0.0.2"),
-			nodeAddresses:     []v1.NodeAddress{},
-			cloudProviderType: cloudProviderNone,
+			name:          "no cloud provider and nodeIP IPv4 unspecified",
+			nodeIP:        netutils.ParseIPSloppy("0.0.0.0"),
+			resolvedIP:    netutils.ParseIPSloppy("10.0.0.2"),
+			cloudProvider: false,
 			expectedAddresses: []v1.NodeAddress{
 				{Type: v1.NodeInternalIP, Address: "10.0.0.2"},
 				{Type: v1.NodeHostName, Address: testKubeletHostname},
@@ -250,11 +92,10 @@ func TestNodeAddress(t *testing.T) {
 			shouldError: false,
 		},
 		{
-			name:              "no cloud provider and nodeIP IPv6 unspecified",
-			nodeIP:            netutils.ParseIPSloppy("::"),
-			resolvedIP:        netutils.ParseIPSloppy("2001:db2::2"),
-			nodeAddresses:     []v1.NodeAddress{},
-			cloudProviderType: cloudProviderNone,
+			name:          "no cloud provider and nodeIP IPv6 unspecified",
+			nodeIP:        netutils.ParseIPSloppy("::"),
+			resolvedIP:    netutils.ParseIPSloppy("2001:db2::2"),
+			cloudProvider: false,
 			expectedAddresses: []v1.NodeAddress{
 				{Type: v1.NodeInternalIP, Address: "2001:db2::2"},
 				{Type: v1.NodeHostName, Address: testKubeletHostname},
@@ -262,33 +103,10 @@ func TestNodeAddress(t *testing.T) {
 			shouldError: false,
 		},
 		{
-			name:              "legacy cloud provider and nodeIP IPv4 unspecified",
-			nodeIP:            netutils.ParseIPSloppy("0.0.0.0"),
-			resolvedIP:        netutils.ParseIPSloppy("10.0.0.2"),
-			nodeAddresses:     []v1.NodeAddress{},
-			cloudProviderType: cloudProviderLegacy,
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			shouldError: true,
-		},
-		{
-			name:              "legacy cloud provider and nodeIP IPv6 unspecified",
-			nodeIP:            netutils.ParseIPSloppy("::"),
-			resolvedIP:        netutils.ParseIPSloppy("2001:db2::2"),
-			nodeAddresses:     []v1.NodeAddress{},
-			cloudProviderType: cloudProviderLegacy,
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			shouldError: true,
-		},
-		{
-			name:              "cloud provider is external and nodeIP IPv4 unspecified",
-			nodeIP:            netutils.ParseIPSloppy("0.0.0.0"),
-			resolvedIP:        netutils.ParseIPSloppy("10.0.0.2"),
-			nodeAddresses:     []v1.NodeAddress{},
-			cloudProviderType: cloudProviderExternal,
+			name:          "using cloud provider and nodeIP IPv4 unspecified",
+			nodeIP:        netutils.ParseIPSloppy("0.0.0.0"),
+			resolvedIP:    netutils.ParseIPSloppy("10.0.0.2"),
+			cloudProvider: true,
 			expectedAddresses: []v1.NodeAddress{
 				{Type: v1.NodeInternalIP, Address: "10.0.0.2"},
 				{Type: v1.NodeHostName, Address: testKubeletHostname},
@@ -296,11 +114,10 @@ func TestNodeAddress(t *testing.T) {
 			shouldError: false,
 		},
 		{
-			name:              "cloud provider is external and nodeIP IPv6 unspecified",
-			nodeIP:            netutils.ParseIPSloppy("::"),
-			resolvedIP:        netutils.ParseIPSloppy("2001:db2::2"),
-			nodeAddresses:     []v1.NodeAddress{},
-			cloudProviderType: cloudProviderExternal,
+			name:          "using cloud provider and nodeIP IPv6 unspecified",
+			nodeIP:        netutils.ParseIPSloppy("::"),
+			resolvedIP:    netutils.ParseIPSloppy("2001:db2::2"),
+			cloudProvider: true,
 			expectedAddresses: []v1.NodeAddress{
 				{Type: v1.NodeInternalIP, Address: "2001:db2::2"},
 				{Type: v1.NodeHostName, Address: testKubeletHostname},
@@ -308,10 +125,9 @@ func TestNodeAddress(t *testing.T) {
 			shouldError: false,
 		},
 		{
-			name:              "no cloud provider and no nodeIP resolve IPv4",
-			resolvedIP:        netutils.ParseIPSloppy("10.0.0.2"),
-			nodeAddresses:     []v1.NodeAddress{},
-			cloudProviderType: cloudProviderNone,
+			name:          "no cloud provider and no nodeIP resolve IPv4",
+			resolvedIP:    netutils.ParseIPSloppy("10.0.0.2"),
+			cloudProvider: false,
 			expectedAddresses: []v1.NodeAddress{
 				{Type: v1.NodeInternalIP, Address: "10.0.0.2"},
 				{Type: v1.NodeHostName, Address: testKubeletHostname},
@@ -319,10 +135,9 @@ func TestNodeAddress(t *testing.T) {
 			shouldError: false,
 		},
 		{
-			name:              "no cloud provider and no nodeIP resolve IPv6",
-			resolvedIP:        netutils.ParseIPSloppy("2001:db2::2"),
-			nodeAddresses:     []v1.NodeAddress{},
-			cloudProviderType: cloudProviderNone,
+			name:          "no cloud provider and no nodeIP resolve IPv6",
+			resolvedIP:    netutils.ParseIPSloppy("2001:db2::2"),
+			cloudProvider: false,
 			expectedAddresses: []v1.NodeAddress{
 				{Type: v1.NodeInternalIP, Address: "2001:db2::2"},
 				{Type: v1.NodeHostName, Address: testKubeletHostname},
@@ -330,235 +145,27 @@ func TestNodeAddress(t *testing.T) {
 			shouldError: false,
 		},
 		{
-			name:              "legacy cloud provider and no nodeIP",
-			resolvedIP:        netutils.ParseIPSloppy("10.0.0.2"),
-			nodeAddresses:     []v1.NodeAddress{},
-			cloudProviderType: cloudProviderLegacy,
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			shouldError: true,
-		},
-		{
-			name:              "cloud provider is external and no nodeIP resolve IPv4",
-			resolvedIP:        netutils.ParseIPSloppy("10.0.0.2"),
-			nodeAddresses:     []v1.NodeAddress{},
-			cloudProviderType: cloudProviderExternal,
+			name:          "using cloud provider and no nodeIP resolve IPv4",
+			resolvedIP:    netutils.ParseIPSloppy("10.0.0.2"),
+			cloudProvider: true,
 			expectedAddresses: []v1.NodeAddress{
 				{Type: v1.NodeHostName, Address: testKubeletHostname},
 			},
 			shouldError: false,
 		},
 		{
-			name:              "cloud provider is external and no nodeIP resolve IPv6",
-			resolvedIP:        netutils.ParseIPSloppy("2001:db2::2"),
-			nodeAddresses:     []v1.NodeAddress{},
-			cloudProviderType: cloudProviderExternal,
+			name:          "using cloud provider and no nodeIP resolve IPv6",
+			resolvedIP:    netutils.ParseIPSloppy("2001:db2::2"),
+			cloudProvider: true,
 			expectedAddresses: []v1.NodeAddress{
 				{Type: v1.NodeHostName, Address: testKubeletHostname},
 			},
 			shouldError: false,
 		},
 		{
-			name: "cloud doesn't report hostname, no override, detected hostname mismatch",
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				// detected hostname is not auto-added if it doesn't match any cloud-reported addresses
-			},
-			shouldError: false,
-		},
-		{
-			name: "cloud doesn't report hostname, no override, detected hostname match",
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeExternalDNS, Address: testKubeletHostname}, // cloud-reported address value matches detected hostname
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeExternalDNS, Address: testKubeletHostname},
-				{Type: v1.NodeHostName, Address: testKubeletHostname}, // detected hostname gets auto-added
-			},
-			shouldError: false,
-		},
-		{
-			name:   "cloud doesn't report hostname, nodeIP is set, no override, detected hostname match",
-			nodeIP: netutils.ParseIPSloppy("10.1.1.1"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeExternalDNS, Address: testKubeletHostname}, // cloud-reported address value matches detected hostname
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeExternalDNS, Address: testKubeletHostname},
-				{Type: v1.NodeHostName, Address: testKubeletHostname}, // detected hostname gets auto-added
-			},
-			shouldError: false,
-		},
-		{
-			name:   "cloud doesn't report hostname, nodeIP is set, no override, detected hostname match with same type as nodeIP",
-			nodeIP: netutils.ParseIPSloppy("10.1.1.1"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeInternalIP, Address: testKubeletHostname}, // cloud-reported address value matches detected hostname
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname}, // detected hostname gets auto-added
-			},
-			shouldError: false,
-		},
-		{
-			name: "cloud doesn't report hostname, hostname override, hostname mismatch",
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname}, // overridden hostname gets auto-added
-			},
-			hostnameOverride: true,
-			shouldError:      false,
-		},
-		{
-			name:   "Dual-stack cloud, with nodeIP, different IPv6 formats",
-			nodeIP: netutils.ParseIPSloppy("2600:1f14:1d4:d101::ba3d"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeInternalIP, Address: "2600:1f14:1d4:d101:0:0:0:ba3d"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "2600:1f14:1d4:d101:0:0:0:ba3d"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			shouldError: false,
-		},
-		{
-			name: "Dual-stack cloud, IPv4 first, no nodeIP",
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeInternalIP, Address: "fc01:1234::5678"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeInternalIP, Address: "fc01:1234::5678"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			shouldError: false,
-		},
-		{
-			name: "Dual-stack cloud, IPv6 first, no nodeIP",
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "fc01:1234::5678"},
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "fc01:1234::5678"},
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			shouldError: false,
-		},
-		{
-			name:   "Dual-stack cloud, IPv4 first, request IPv4",
-			nodeIP: netutils.ParseIPSloppy("0.0.0.0"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeInternalIP, Address: "fc01:1234::5678"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-				{Type: v1.NodeInternalIP, Address: "fc01:1234::5678"},
-			},
-			shouldError: false,
-		},
-		{
-			name:   "Dual-stack cloud, IPv6 first, request IPv4",
-			nodeIP: netutils.ParseIPSloppy("0.0.0.0"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "fc01:1234::5678"},
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-				{Type: v1.NodeInternalIP, Address: "fc01:1234::5678"},
-			},
-			shouldError: false,
-		},
-		{
-			name:   "Dual-stack cloud, IPv4 first, request IPv6",
-			nodeIP: netutils.ParseIPSloppy("::"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeInternalIP, Address: "fc01:1234::5678"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "fc01:1234::5678"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-			},
-			shouldError: false,
-		},
-		{
-			name:   "Dual-stack cloud, IPv6 first, request IPv6",
-			nodeIP: netutils.ParseIPSloppy("::"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "fc01:1234::5678"},
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "fc01:1234::5678"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-			},
-			shouldError: false,
-		},
-		{
-			name:              "Legacy cloud provider gets nodeIP annotation",
-			nodeIP:            netutils.ParseIPSloppy("10.1.1.1"),
-			cloudProviderType: cloudProviderLegacy,
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAnnotations: map[string]string{
-				"alpha.kubernetes.io/provided-node-ip": "10.1.1.1",
-			},
-			shouldError: false,
-		},
-		{
-			name:              "External cloud provider gets nodeIP annotation",
-			nodeIP:            netutils.ParseIPSloppy("10.1.1.1"),
-			cloudProviderType: cloudProviderExternal,
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
+			name:          "cloud provider gets nodeIP annotation",
+			nodeIP:        netutils.ParseIPSloppy("10.1.1.1"),
+			cloudProvider: true,
 			expectedAddresses: []v1.NodeAddress{
 				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
 				{Type: v1.NodeHostName, Address: testKubeletHostname},
@@ -569,22 +176,17 @@ func TestNodeAddress(t *testing.T) {
 			shouldError: false,
 		},
 		{
-			name:                           "External cloud provider, node address is already set",
+			name:                           "using cloud provider and node address is already set",
 			nodeIP:                         netutils.ParseIPSloppy("10.1.1.1"),
-			cloudProviderType:              cloudProviderExternal,
-			nodeAddresses:                  []v1.NodeAddress{existingNodeAddress},
+			cloudProvider:                  true,
 			expectedAddresses:              []v1.NodeAddress{existingNodeAddress},
 			shouldError:                    true,
 			shouldSetNodeAddressBeforeTest: true,
 		},
 		{
-			name:              "No cloud provider does not get nodeIP annotation",
-			nodeIP:            netutils.ParseIPSloppy("10.1.1.1"),
-			cloudProviderType: cloudProviderNone,
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
+			name:          "No cloud provider does not get nodeIP annotation",
+			nodeIP:        netutils.ParseIPSloppy("10.1.1.1"),
+			cloudProvider: false,
 			expectedAddresses: []v1.NodeAddress{
 				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
 				{Type: v1.NodeHostName, Address: testKubeletHostname},
@@ -593,13 +195,9 @@ func TestNodeAddress(t *testing.T) {
 			shouldError:         false,
 		},
 		{
-			name:              "Stale nodeIP annotation is removed when not using cloud provider",
-			nodeIP:            netutils.ParseIPSloppy("10.1.1.1"),
-			cloudProviderType: cloudProviderNone,
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
+			name:          "Stale nodeIP annotation is removed when not using cloud provider",
+			nodeIP:        netutils.ParseIPSloppy("10.1.1.1"),
+			cloudProvider: false,
 			expectedAddresses: []v1.NodeAddress{
 				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
 				{Type: v1.NodeHostName, Address: testKubeletHostname},
@@ -611,31 +209,9 @@ func TestNodeAddress(t *testing.T) {
 			shouldError:         false,
 		},
 		{
-			name:              "Stale nodeIP annotation is removed when using cloud provider but no --node-ip",
-			nodeIP:            nil,
-			cloudProviderType: cloudProviderLegacy,
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			existingAnnotations: map[string]string{
-				"alpha.kubernetes.io/provided-node-ip": "10.1.1.1",
-			},
-			expectedAnnotations: map[string]string{},
-			shouldError:         false,
-		},
-		{
-			name:              "Incorrect nodeIP annotation is fixed",
-			nodeIP:            netutils.ParseIPSloppy("10.1.1.1"),
-			cloudProviderType: cloudProviderExternal,
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
+			name:          "Incorrect nodeIP annotation is fixed",
+			nodeIP:        netutils.ParseIPSloppy("10.1.1.1"),
+			cloudProvider: true,
 			expectedAddresses: []v1.NodeAddress{
 				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
 				{Type: v1.NodeHostName, Address: testKubeletHostname},
@@ -652,16 +228,10 @@ func TestNodeAddress(t *testing.T) {
 			// We don't have to test "legacy cloud provider with dual-stack
 			// IPs" etc because we won't have gotten this far with an invalid
 			// config like that.
-			name:              "Dual-stack cloud, with dual-stack nodeIPs",
-			nodeIP:            netutils.ParseIPSloppy("2600:1f14:1d4:d101::ba3d"),
-			secondaryNodeIP:   netutils.ParseIPSloppy("10.1.1.2"),
-			cloudProviderType: cloudProviderExternal,
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeInternalIP, Address: "10.1.1.2"},
-				{Type: v1.NodeInternalIP, Address: "2600:1f14:1d4:d101::ba3d"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
+			name:            "Dual-stack cloud, with dual-stack nodeIPs",
+			nodeIP:          netutils.ParseIPSloppy("2600:1f14:1d4:d101::ba3d"),
+			secondaryNodeIP: netutils.ParseIPSloppy("10.1.1.2"),
+			cloudProvider:   true,
 			expectedAddresses: []v1.NodeAddress{
 				{Type: v1.NodeInternalIP, Address: "2600:1f14:1d4:d101::ba3d"},
 				{Type: v1.NodeInternalIP, Address: "10.1.1.2"},
@@ -673,15 +243,10 @@ func TestNodeAddress(t *testing.T) {
 			shouldError: false,
 		},
 		{
-			name:              "Upgrade to cloud dual-stack nodeIPs",
-			nodeIP:            netutils.ParseIPSloppy("10.1.1.1"),
-			secondaryNodeIP:   netutils.ParseIPSloppy("2600:1f14:1d4:d101::ba3d"),
-			cloudProviderType: cloudProviderExternal,
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeInternalIP, Address: "2600:1f14:1d4:d101::ba3d"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
+			name:            "Upgrade to cloud dual-stack nodeIPs",
+			nodeIP:          netutils.ParseIPSloppy("10.1.1.1"),
+			secondaryNodeIP: netutils.ParseIPSloppy("2600:1f14:1d4:d101::ba3d"),
+			cloudProvider:   true,
 			expectedAddresses: []v1.NodeAddress{
 				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
 				{Type: v1.NodeInternalIP, Address: "2600:1f14:1d4:d101::ba3d"},
@@ -696,14 +261,9 @@ func TestNodeAddress(t *testing.T) {
 			shouldError: false,
 		},
 		{
-			name:              "Downgrade from cloud dual-stack nodeIPs",
-			nodeIP:            netutils.ParseIPSloppy("10.1.1.1"),
-			cloudProviderType: cloudProviderExternal,
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeInternalIP, Address: "2600:1f14:1d4:d101::ba3d"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
+			name:          "Downgrade from cloud dual-stack nodeIPs",
+			nodeIP:        netutils.ParseIPSloppy("10.1.1.1"),
+			cloudProvider: true,
 			expectedAddresses: []v1.NodeAddress{
 				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
 				{Type: v1.NodeHostName, Address: testKubeletHostname},
@@ -741,10 +301,6 @@ func TestNodeAddress(t *testing.T) {
 			}
 			hostname := testKubeletHostname
 
-			nodeAddressesFunc := func() ([]v1.NodeAddress, error) {
-				return testCase.nodeAddresses, nil
-			}
-
 			net.DefaultResolver = &net.Resolver{
 				PreferGo: true,
 				Dial: func(ctx context.Context, network string, address string) (net.Conn, error) {
@@ -759,15 +315,6 @@ func TestNodeAddress(t *testing.T) {
 				return testCase.resolvedIP, nil
 			}
 
-			// cloud provider is expected to be nil if external provider is set or there is no cloud provider
-			var cloud cloudprovider.Interface
-			if testCase.cloudProviderType == cloudProviderLegacy {
-				cloud = &fakecloud.Cloud{
-					Addresses: testCase.nodeAddresses,
-					Err:       nil,
-				}
-			}
-
 			nodeIPs := []net.IP{testCase.nodeIP}
 			if testCase.secondaryNodeIP != nil {
 				nodeIPs = append(nodeIPs, testCase.secondaryNodeIP)
@@ -777,10 +324,7 @@ func TestNodeAddress(t *testing.T) {
 			setter := NodeAddress(nodeIPs,
 				nodeIPValidator,
 				hostname,
-				testCase.hostnameOverride,
-				testCase.cloudProviderType == cloudProviderExternal,
-				cloud,
-				nodeAddressesFunc,
+				testCase.cloudProvider,
 				resolveAddressFunc,
 			)
 
@@ -859,9 +403,6 @@ func TestNodeAddress_NoCloudProvider(t *testing.T) {
 				}
 				return nil
 			}
-			nodeAddressesFunc := func() ([]v1.NodeAddress, error) {
-				return nil, fmt.Errorf("not reached")
-			}
 			resolvedAddressesFunc := func(net.IP) (net.IP, error) {
 				return nil, fmt.Errorf("not reached")
 			}
@@ -870,10 +411,7 @@ func TestNodeAddress_NoCloudProvider(t *testing.T) {
 			setter := NodeAddress(testCase.nodeIPs,
 				nodeIPValidator,
 				testKubeletHostname,
-				false, // hostnameOverridden
 				false, // externalCloudProvider
-				nil,   // cloud
-				nodeAddressesFunc,
 				resolvedAddressesFunc)
 
 			// call setter on existing node
diff --git a/pkg/kubemark/hollow_kubelet.go b/pkg/kubemark/hollow_kubelet.go
index 523b6fcd65f42..661ac5440ad93 100644
--- a/pkg/kubemark/hollow_kubelet.go
+++ b/pkg/kubemark/hollow_kubelet.go
@@ -100,7 +100,6 @@ func NewHollowKubelet(
 		RemoteRuntimeService:      runtimeService,
 		RemoteImageService:        imageService,
 		CAdvisorInterface:         cadvisorInterface,
-		Cloud:                     nil,
 		OSInterface:               &containertest.FakeOS{},
 		ContainerManager:          containerManager,
 		VolumePlugins:             volumePlugins(),
diff --git a/staging/src/k8s.io/cloud-provider/node/helpers/address.go b/staging/src/k8s.io/cloud-provider/node/helpers/address.go
index 2bed19842671d..135adb956a12a 100644
--- a/staging/src/k8s.io/cloud-provider/node/helpers/address.go
+++ b/staging/src/k8s.io/cloud-provider/node/helpers/address.go
@@ -18,9 +18,8 @@ package helpers
 
 import (
 	"fmt"
-	"net"
 
-	"k8s.io/api/core/v1"
+	v1 "k8s.io/api/core/v1"
 	nodeutil "k8s.io/component-helpers/node/util"
 	netutils "k8s.io/utils/net"
 )
@@ -42,52 +41,6 @@ func AddToNodeAddresses(addresses *[]v1.NodeAddress, addAddresses ...v1.NodeAddr
 	}
 }
 
-// GetNodeAddressesFromNodeIPLegacy filters node addresses to prefer a specific node IP or
-// address family. This function is used only with legacy cloud providers.
-//
-// If nodeIP is either '0.0.0.0' or '::' it is taken to represent any address of
-// that address family: IPv4 or IPv6. i.e. if nodeIP is '0.0.0.0' we will return
-// node addresses sorted such that all IPv4 addresses are listed before IPv6
-// addresses.
-//
-// If nodeIP is a specific IP, either IPv4 or IPv6, we will return node
-// addresses filtered such that:
-//   - Any address matching nodeIP will be listed first.
-//   - If nodeIP matches an address of a particular type (internal or external),
-//     that will be the *only* address of that type returned.
-//   - All remaining addresses are listed after.
-func GetNodeAddressesFromNodeIPLegacy(nodeIP net.IP, cloudNodeAddresses []v1.NodeAddress) ([]v1.NodeAddress, error) {
-	// If nodeIP is unset, just use the addresses provided by the cloud provider as-is
-	if nodeIP == nil {
-		return cloudNodeAddresses, nil
-	}
-
-	// nodeIP is "0.0.0.0" or "::"; sort cloudNodeAddresses to
-	// prefer addresses of the matching family
-	if nodeIP.IsUnspecified() {
-		preferIPv4 := nodeIP.To4() != nil
-		isPreferredIPFamily := func(ip net.IP) bool { return (ip.To4() != nil) == preferIPv4 }
-
-		sortedAddresses := make([]v1.NodeAddress, 0, len(cloudNodeAddresses))
-		for _, nodeAddress := range cloudNodeAddresses {
-			ip := netutils.ParseIPSloppy(nodeAddress.Address)
-			if ip == nil || isPreferredIPFamily(ip) {
-				sortedAddresses = append(sortedAddresses, nodeAddress)
-			}
-		}
-		for _, nodeAddress := range cloudNodeAddresses {
-			ip := netutils.ParseIPSloppy(nodeAddress.Address)
-			if ip != nil && !isPreferredIPFamily(ip) {
-				sortedAddresses = append(sortedAddresses, nodeAddress)
-			}
-		}
-		return sortedAddresses, nil
-	}
-
-	// Otherwise the result is the same as for GetNodeAddressesFromNodeIP
-	return GetNodeAddressesFromNodeIP(nodeIP.String(), cloudNodeAddresses)
-}
-
 // GetNodeAddressesFromNodeIP filters the provided list of nodeAddresses to match the
 // providedNodeIP from the Node annotation (which is assumed to be non-empty). This is
 // used for external cloud providers.
@@ -97,11 +50,6 @@ func GetNodeAddressesFromNodeIPLegacy(nodeIP net.IP, cloudNodeAddresses []v1.Nod
 //   - If nodeIP matches an address of a particular type (internal or external),
 //     that will be the *only* address of that type returned.
 //   - All remaining addresses are listed after.
-//
-// (This does not have the same behavior with `0.0.0.0` and `::` as
-// GetNodeAddressesFromNodeIPLegacy, because that case never occurs for external cloud
-// providers, because kubelet does not set the `provided-node-ip` annotation in that
-// case.)
 func GetNodeAddressesFromNodeIP(providedNodeIP string, cloudNodeAddresses []v1.NodeAddress) ([]v1.NodeAddress, error) {
 	nodeIPs, err := nodeutil.ParseNodeIPAnnotation(providedNodeIP)
 	if err != nil {
diff --git a/staging/src/k8s.io/cloud-provider/node/helpers/address_test.go b/staging/src/k8s.io/cloud-provider/node/helpers/address_test.go
index 01208c6a06a9d..828a57ffef874 100644
--- a/staging/src/k8s.io/cloud-provider/node/helpers/address_test.go
+++ b/staging/src/k8s.io/cloud-provider/node/helpers/address_test.go
@@ -17,13 +17,11 @@ limitations under the License.
 package helpers
 
 import (
-	"net"
 	"reflect"
 	"testing"
 
 	v1 "k8s.io/api/core/v1"
 	apiequality "k8s.io/apimachinery/pkg/api/equality"
-	netutils "k8s.io/utils/net"
 )
 
 const (
@@ -94,225 +92,6 @@ func TestAddToNodeAddresses(t *testing.T) {
 	}
 }
 
-func TestGetNodeAddressesFromNodeIPLegacy(t *testing.T) {
-	cases := []struct {
-		name              string
-		nodeIP            net.IP
-		nodeAddresses     []v1.NodeAddress
-		expectedAddresses []v1.NodeAddress
-		shouldError       bool
-	}{
-		{
-			name:   "A single InternalIP",
-			nodeIP: netutils.ParseIPSloppy("10.1.1.1"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			shouldError: false,
-		},
-		{
-			name:   "NodeIP is external",
-			nodeIP: netutils.ParseIPSloppy("55.55.55.55"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			shouldError: false,
-		},
-		{
-			// Accommodating #45201 and #49202
-			name:   "InternalIP and ExternalIP are the same",
-			nodeIP: netutils.ParseIPSloppy("55.55.55.55"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "44.44.44.44"},
-				{Type: v1.NodeExternalIP, Address: "44.44.44.44"},
-				{Type: v1.NodeInternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			shouldError: false,
-		},
-		{
-			name:   "An Internal/ExternalIP, an Internal/ExternalDNS",
-			nodeIP: netutils.ParseIPSloppy("10.1.1.1"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeInternalDNS, Address: "ip-10-1-1-1.us-west-2.compute.internal"},
-				{Type: v1.NodeExternalDNS, Address: "ec2-55-55-55-55.us-west-2.compute.amazonaws.com"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeInternalDNS, Address: "ip-10-1-1-1.us-west-2.compute.internal"},
-				{Type: v1.NodeExternalDNS, Address: "ec2-55-55-55-55.us-west-2.compute.amazonaws.com"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			shouldError: false,
-		},
-		{
-			name:   "An Internal with multiple internal IPs",
-			nodeIP: netutils.ParseIPSloppy("10.1.1.1"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeInternalIP, Address: "10.2.2.2"},
-				{Type: v1.NodeInternalIP, Address: "10.3.3.3"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			shouldError: false,
-		},
-		{
-			name:   "An InternalIP that isn't valid: should error",
-			nodeIP: netutils.ParseIPSloppy("10.2.2.2"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: nil,
-			shouldError:       true,
-		},
-		{
-			name:   "Dual-stack cloud, with nodeIP, different IPv6 formats",
-			nodeIP: netutils.ParseIPSloppy("2600:1f14:1d4:d101::ba3d"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeInternalIP, Address: "2600:1f14:1d4:d101:0:0:0:ba3d"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "2600:1f14:1d4:d101:0:0:0:ba3d"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			shouldError: false,
-		},
-		{
-			name: "Dual-stack cloud, IPv4 first, no nodeIP",
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeInternalIP, Address: "fc01:1234::5678"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeInternalIP, Address: "fc01:1234::5678"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			shouldError: false,
-		},
-		{
-			name: "Dual-stack cloud, IPv6 first, no nodeIP",
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "fc01:1234::5678"},
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "fc01:1234::5678"},
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			shouldError: false,
-		},
-		{
-			name:   "Dual-stack cloud, IPv4 first, request IPv4",
-			nodeIP: netutils.ParseIPSloppy("0.0.0.0"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeInternalIP, Address: "fc01:1234::5678"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-				{Type: v1.NodeInternalIP, Address: "fc01:1234::5678"},
-			},
-			shouldError: false,
-		},
-		{
-			name:   "Dual-stack cloud, IPv6 first, request IPv4",
-			nodeIP: netutils.ParseIPSloppy("0.0.0.0"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "fc01:1234::5678"},
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-				{Type: v1.NodeInternalIP, Address: "fc01:1234::5678"},
-			},
-			shouldError: false,
-		},
-		{
-			name:   "Dual-stack cloud, IPv4 first, request IPv6",
-			nodeIP: netutils.ParseIPSloppy("::"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeInternalIP, Address: "fc01:1234::5678"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "fc01:1234::5678"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-			},
-			shouldError: false,
-		},
-		{
-			name:   "Dual-stack cloud, IPv6 first, request IPv6",
-			nodeIP: netutils.ParseIPSloppy("::"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "fc01:1234::5678"},
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "fc01:1234::5678"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-			},
-			shouldError: false,
-		},
-	}
-
-	for _, tt := range cases {
-		t.Run(tt.name, func(t *testing.T) {
-			got, err := GetNodeAddressesFromNodeIPLegacy(tt.nodeIP, tt.nodeAddresses)
-			if (err != nil) != tt.shouldError {
-				t.Errorf("GetNodeAddressesFromNodeIPLegacy() error = %v, wantErr %v", err, tt.shouldError)
-				return
-			}
-			if !reflect.DeepEqual(got, tt.expectedAddresses) {
-				t.Errorf("GetNodeAddressesFromNodeIPLegacy() = %v, want %v", got, tt.expectedAddresses)
-			}
-		})
-	}
-}
-
 func TestGetNodeAddressesFromNodeIP(t *testing.T) {
 	cases := []struct {
 		name              string


Reviews:
user: login: hashim21223445
state: APPROVED
author_association: NONE
submitted_at: 2025-02-14T10:47:50Z
user: login: elmiko
body: it looks like this is removing the `--cloud-provider` flag, how will we know to set the kubelet into external provider mode?
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-02-26T14:46:17Z
user: login: elmiko
body: i think this is making more sense to me now, i would like to have someone with more experience on the network parts review as well.

also, i have one minor suggestion for the updated flag help text.
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-02-27T17:41:34Z
user: login: carlory
state: COMMENTED
author_association: MEMBER
submitted_at: 2025-02-28T06:15:12Z
user: login: carlory
state: COMMENTED
author_association: MEMBER
submitted_at: 2025-02-28T06:35:30Z
user: login: elmiko
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-02-28T14:14:50Z
user: login: elmiko
body: /lgtm

would like to get another review, especially for the networking related changes.
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-02-28T14:19:49Z
user: login: aojea
state: COMMENTED
author_association: MEMBER
submitted_at: 2025-02-28T23:07:54Z
user: login: aojea
state: COMMENTED
author_association: MEMBER
submitted_at: 2025-02-28T23:14:00Z
user: login: aojea
state: COMMENTED
author_association: MEMBER
submitted_at: 2025-02-28T23:14:14Z
user: login: carlory
state: COMMENTED
author_association: MEMBER
submitted_at: 2025-03-03T06:21:22Z
user: login: aojea
state: COMMENTED
author_association: MEMBER
submitted_at: 2025-03-03T09:45:02Z
user: login: aojea
state: COMMENTED
author_association: MEMBER
submitted_at: 2025-03-19T06:59:35Z
user: login: hashim21223445
state: APPROVED
author_association: NONE
submitted_at: 2025-04-24T11:00:43Z
user: login: danwinship
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-04-25T00:04:27Z
user: login: elmiko
body: /lgtm
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-13T19:04:31Z
user: login: SergeyKanzhelev
body: /lgtm
/approve
state: APPROVED
author_association: MEMBER
submitted_at: 2025-05-16T20:51:21Z
user: login: pohly
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-19T07:16:15Z
user: login: pohly
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-05-19T07:22:42Z
user: login: carlory
state: COMMENTED
author_association: MEMBER
submitted_at: 2025-05-19T08:03:52Z

Review comments:
diff_hunk: @@ -290,14 +290,14 @@ func (f *KubeletFlags) AddFlags(mainfs *pflag.FlagSet) {
 		"On success, a kubeconfig file referencing the generated client certificate and key is written to the path specified by --kubeconfig. "+
 		"The client certificate and key file will be stored in the directory pointed by --cert-dir.")
 
-	fs.StringVar(&f.HostnameOverride, "hostname-override", f.HostnameOverride, "If non-empty, will use this string as identification instead of the actual hostname. If --cloud-provider is set, the cloud provider determines the name of the node (consult cloud provider documentation to determine if and how the hostname is used).")
+	fs.StringVar(&f.HostnameOverride, "hostname-override", f.HostnameOverride, "If non-empty, will use this string as identification instead of the actual hostname.")
path: cmd/kubelet/app/options/options.go
user: login: elmiko
body: i think removing the mention of the `--cloud-provider` flag is good, should we maybe mention that running with an external cloud controller will cause the hostname to be provided by the ccm?
created_at: 2025-02-27T17:39:18Z
author_association: CONTRIBUTOR
diff_hunk: @@ -290,14 +290,14 @@ func (f *KubeletFlags) AddFlags(mainfs *pflag.FlagSet) {
 		"On success, a kubeconfig file referencing the generated client certificate and key is written to the path specified by --kubeconfig. "+
 		"The client certificate and key file will be stored in the directory pointed by --cert-dir.")
 
-	fs.StringVar(&f.HostnameOverride, "hostname-override", f.HostnameOverride, "If non-empty, will use this string as identification instead of the actual hostname. If --cloud-provider is set, the cloud provider determines the name of the node (consult cloud provider documentation to determine if and how the hostname is used).")
+	fs.StringVar(&f.HostnameOverride, "hostname-override", f.HostnameOverride, "If non-empty, will use this string as identification instead of the actual hostname.")
path: cmd/kubelet/app/options/options.go
user: login: carlory
body: Whatever the value of `--cloud-provider` is, the node name always takes the value of `os.Hostname()` or overridden with `--hostname-override`. 

There is no difference. 
- https://github.com/carlory/kubernetes/blob/e62734ca2e3e050d1e54524a94257c5a2d4f0b3f/pkg/kubelet/nodestatus/setters.go#L141
- https://github.com/carlory/kubernetes/blob/kep-2395-kubelet-cleanup/pkg/kubelet/nodestatus/setters.go#L151
- https://github.com/carlory/kubernetes/blob/kep-2395-kubelet-cleanup/pkg/kubelet/nodestatus/setters.go#L192
created_at: 2025-02-28T06:15:11Z
author_association: MEMBER
diff_hunk: @@ -290,14 +290,14 @@ func (f *KubeletFlags) AddFlags(mainfs *pflag.FlagSet) {
 		"On success, a kubeconfig file referencing the generated client certificate and key is written to the path specified by --kubeconfig. "+
 		"The client certificate and key file will be stored in the directory pointed by --cert-dir.")
 
-	fs.StringVar(&f.HostnameOverride, "hostname-override", f.HostnameOverride, "If non-empty, will use this string as identification instead of the actual hostname. If --cloud-provider is set, the cloud provider determines the name of the node (consult cloud provider documentation to determine if and how the hostname is used).")
+	fs.StringVar(&f.HostnameOverride, "hostname-override", f.HostnameOverride, "If non-empty, will use this string as identification instead of the actual hostname.")
path: cmd/kubelet/app/options/options.go
user: login: carlory
body: I pushed new changes to remove unnecessary code which I forgot to remove in the previous commit. please review it again. thank you.
created_at: 2025-02-28T06:35:30Z
author_association: MEMBER
diff_hunk: @@ -290,14 +290,14 @@ func (f *KubeletFlags) AddFlags(mainfs *pflag.FlagSet) {
 		"On success, a kubeconfig file referencing the generated client certificate and key is written to the path specified by --kubeconfig. "+
 		"The client certificate and key file will be stored in the directory pointed by --cert-dir.")
 
-	fs.StringVar(&f.HostnameOverride, "hostname-override", f.HostnameOverride, "If non-empty, will use this string as identification instead of the actual hostname. If --cloud-provider is set, the cloud provider determines the name of the node (consult cloud provider documentation to determine if and how the hostname is used).")
+	fs.StringVar(&f.HostnameOverride, "hostname-override", f.HostnameOverride, "If non-empty, will use this string as identification instead of the actual hostname.")
path: cmd/kubelet/app/options/options.go
user: login: elmiko
body: thanks!
created_at: 2025-02-28T14:14:50Z
author_association: CONTRIBUTOR
diff_hunk: @@ -320,8 +320,6 @@ func (f *KubeletFlags) AddFlags(mainfs *pflag.FlagSet) {
 	fs.MarkDeprecated("register-schedulable", "will be removed in a future version")
 	fs.StringVar(&f.ExperimentalMounterPath, "experimental-mounter-path", f.ExperimentalMounterPath, "[Experimental] Path of mounter binary. Leave empty to use the default mount.")
 	fs.MarkDeprecated("experimental-mounter-path", "will be removed in 1.25 or later. in favor of using CSI.")
-	fs.StringVar(&f.CloudConfigFile, "cloud-config", f.CloudConfigFile, "The path to the cloud provider configuration file. Empty string for no configuration file.")
path: cmd/kubelet/app/options/options.go
user: login: aojea
body: removing flags cause new kubelets that had they configured to fail, so we need to warn about this on the release notes
created_at: 2025-02-28T23:07:53Z
author_association: MEMBER
diff_hunk: @@ -25,20 +25,6 @@ import (
 	"k8s.io/klog/v2"
 )
 
-// providerRequiresNetworkingConfiguration returns whether the cloud provider
-// requires special networking configuration.
-func (kl *Kubelet) providerRequiresNetworkingConfiguration() bool {
path: pkg/kubelet/kubelet_network.go
user: login: aojea
body: +1
created_at: 2025-02-28T23:14:00Z
author_association: MEMBER
diff_hunk: @@ -350,16 +349,6 @@ func (kl *Kubelet) initialNode(ctx context.Context) (*v1.Node, error) {
 	if len(nodeTaints) > 0 {
 		node.Spec.Taints = nodeTaints
 	}
-	// Initially, set NodeNetworkUnavailable to true.
path: pkg/kubelet/kubelet_node_status.go
user: login: aojea
body: +1
created_at: 2025-02-28T23:14:14Z
author_association: MEMBER
diff_hunk: @@ -320,8 +320,6 @@ func (f *KubeletFlags) AddFlags(mainfs *pflag.FlagSet) {
 	fs.MarkDeprecated("register-schedulable", "will be removed in a future version")
 	fs.StringVar(&f.ExperimentalMounterPath, "experimental-mounter-path", f.ExperimentalMounterPath, "[Experimental] Path of mounter binary. Leave empty to use the default mount.")
 	fs.MarkDeprecated("experimental-mounter-path", "will be removed in 1.25 or later. in favor of using CSI.")
-	fs.StringVar(&f.CloudConfigFile, "cloud-config", f.CloudConfigFile, "The path to the cloud provider configuration file. Empty string for no configuration file.")
path: cmd/kubelet/app/options/options.go
user: login: carlory
body: @aojea do you mean that I should add `ACTION REQUIRED` to the first line of the current release note text?
created_at: 2025-03-03T06:21:22Z
author_association: MEMBER
diff_hunk: @@ -320,8 +320,6 @@ func (f *KubeletFlags) AddFlags(mainfs *pflag.FlagSet) {
 	fs.MarkDeprecated("register-schedulable", "will be removed in a future version")
 	fs.StringVar(&f.ExperimentalMounterPath, "experimental-mounter-path", f.ExperimentalMounterPath, "[Experimental] Path of mounter binary. Leave empty to use the default mount.")
 	fs.MarkDeprecated("experimental-mounter-path", "will be removed in 1.25 or later. in favor of using CSI.")
-	fs.StringVar(&f.CloudConfigFile, "cloud-config", f.CloudConfigFile, "The path to the cloud provider configuration file. Empty string for no configuration file.")
path: cmd/kubelet/app/options/options.go
user: login: aojea
body: yep, I don't know what is the exact term but something like that
created_at: 2025-03-03T09:45:02Z
author_association: MEMBER
diff_hunk: @@ -66,10 +64,7 @@ var rebootEvent sync.Once
 func NodeAddress(nodeIPs []net.IP, // typically Kubelet.nodeIPs
 	validateNodeIPFunc func(net.IP) error, // typically Kubelet.nodeIPValidator
 	hostname string, // typically Kubelet.hostname
-	hostnameOverridden bool, // was the hostname force set?
path: pkg/kubelet/nodestatus/setters.go
user: login: aojea
body: @danwinship review will be helpful here
created_at: 2025-03-19T06:59:35Z
author_association: MEMBER
diff_hunk: @@ -99,7 +94,7 @@ func NodeAddress(nodeIPs []net.IP, // typically Kubelet.nodeIPs
 			klog.V(4).InfoS("Using secondary node IP", "IP", secondaryNodeIP.String())
 		}
 
-		if (externalCloudProvider || cloud != nil) && nodeIPSpecified {
+		if externalCloudProvider && nodeIPSpecified {
 			// Annotate the Node object with nodeIP for external cloud provider.
 			//
 			// We do this even when external CCM is not configured to cover a situation
path: pkg/kubelet/nodestatus/setters.go
user: login: danwinship
body: (the comment here is still talking about the internal cloud provider case)
created_at: 2025-04-24T23:49:53Z
author_association: CONTRIBUTOR
diff_hunk: @@ -149,52 +144,7 @@ func NodeAddress(nodeIPs []net.IP, // typically Kubelet.nodeIPs
 				return nil
 			}
 		}
-		if cloud != nil {
-			cloudNodeAddresses, err := nodeAddressesFunc()
-			if err != nil {
-				return err
-			}
-
-			nodeAddresses, err := cloudprovidernodeutil.GetNodeAddressesFromNodeIPLegacy(nodeIP, cloudNodeAddresses)
path: pkg/kubelet/nodestatus/setters.go
user: login: danwinship
body: I believe this is the only use of `cloudprovidernodeutil.GetNodeAddressesFromNodeIPLegacy` in the tree and so that function can be removed.
created_at: 2025-04-24T23:50:44Z
author_association: CONTRIBUTOR
diff_hunk: @@ -61,175 +59,26 @@ const (
 func TestNodeAddress(t *testing.T) {
 	type cloudProviderType int
 	const (
-		cloudProviderLegacy cloudProviderType = iota
-		cloudProviderExternal
+		cloudProviderExternal cloudProviderType = iota
 		cloudProviderNone
 	)
path: pkg/kubelet/nodestatus/setters_test.go
user: login: danwinship
body: this could just be made a `bool` now
created_at: 2025-04-24T23:52:23Z
author_association: CONTRIBUTOR
diff_hunk: @@ -61,175 +59,26 @@ const (
 func TestNodeAddress(t *testing.T) {
 	type cloudProviderType int
 	const (
-		cloudProviderLegacy cloudProviderType = iota
-		cloudProviderExternal
+		cloudProviderExternal cloudProviderType = iota
 		cloudProviderNone
 	)
 
 	existingNodeAddress := v1.NodeAddress{Address: "10.1.1.2"}
 	cases := []struct {
 		name                           string
-		hostnameOverride               bool
 		nodeIP                         net.IP
 		secondaryNodeIP                net.IP
 		resolvedIP                     net.IP
 		cloudProviderType              cloudProviderType
-		nodeAddresses                  []v1.NodeAddress
 		expectedAddresses              []v1.NodeAddress
 		existingAnnotations            map[string]string
 		expectedAnnotations            map[string]string
 		shouldError                    bool
 		shouldSetNodeAddressBeforeTest bool
 	}{
-		{
-			name:   "A single InternalIP",
-			nodeIP: netutils.ParseIPSloppy("10.1.1.1"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			shouldError: false,
-		},
-		{
-			name:   "NodeIP is external",
-			nodeIP: netutils.ParseIPSloppy("55.55.55.55"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			shouldError: false,
-		},
-		{
-			// Accommodating #45201 and #49202
-			name:   "InternalIP and ExternalIP are the same",
-			nodeIP: netutils.ParseIPSloppy("55.55.55.55"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "44.44.44.44"},
-				{Type: v1.NodeExternalIP, Address: "44.44.44.44"},
-				{Type: v1.NodeInternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			shouldError: false,
-		},
-		{
-			name:   "An Internal/ExternalIP, an Internal/ExternalDNS",
-			nodeIP: netutils.ParseIPSloppy("10.1.1.1"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeInternalDNS, Address: "ip-10-1-1-1.us-west-2.compute.internal"},
-				{Type: v1.NodeExternalDNS, Address: "ec2-55-55-55-55.us-west-2.compute.amazonaws.com"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeInternalDNS, Address: "ip-10-1-1-1.us-west-2.compute.internal"},
-				{Type: v1.NodeExternalDNS, Address: "ec2-55-55-55-55.us-west-2.compute.amazonaws.com"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			shouldError: false,
-		},
-		{
-			name:   "An Internal with multiple internal IPs",
-			nodeIP: netutils.ParseIPSloppy("10.1.1.1"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeInternalIP, Address: "10.2.2.2"},
-				{Type: v1.NodeInternalIP, Address: "10.3.3.3"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			shouldError: false,
-		},
-		{
-			name:   "An InternalIP that isn't valid: should error",
-			nodeIP: netutils.ParseIPSloppy("10.2.2.2"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname},
-			},
-			expectedAddresses: nil,
-			shouldError:       true,
-		},
-		{
-			name:          "no cloud reported hostnames",
-			nodeAddresses: []v1.NodeAddress{},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeHostName, Address: testKubeletHostname}, // detected hostname is auto-added in the absence of cloud-reported hostnames
-			},
-			shouldError: false,
-		},
-		{
-			name: "cloud reports hostname, no override",
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeHostName, Address: "cloud-host"},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeHostName, Address: "cloud-host"}, // cloud-reported hostname wins over detected hostname
-			},
-			shouldError: false,
-		},
-		{
-			name:   "cloud reports hostname, nodeIP is set, no override",
-			nodeIP: netutils.ParseIPSloppy("10.1.1.1"),
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeHostName, Address: "cloud-host"},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-				{Type: v1.NodeHostName, Address: "cloud-host"}, // cloud-reported hostname wins over detected hostname
-			},
-			shouldError: false,
-		},
-		{
-			name: "cloud reports hostname, overridden",
-			nodeAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: "cloud-host"},
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-			},
-			expectedAddresses: []v1.NodeAddress{
-				{Type: v1.NodeInternalIP, Address: "10.1.1.1"},
-				{Type: v1.NodeHostName, Address: testKubeletHostname}, // hostname-override wins over cloud-reported hostname
-				{Type: v1.NodeExternalIP, Address: "55.55.55.55"},
-			},
-			hostnameOverride: true,
-			shouldError:      false,
-		},
 		{
 			name:              "cloud provider is external and nodeIP specified",
path: pkg/kubelet/nodestatus/setters_test.go
user: login: danwinship
body: "cloud provider is external" is now a weird way to describe this. `"using cloud provider and nodeIP specified"` ? (etc below)
created_at: 2025-04-25T00:02:24Z
author_association: CONTRIBUTOR
diff_hunk: @@ -320,8 +320,6 @@ func (f *KubeletFlags) AddFlags(mainfs *pflag.FlagSet) {
 	fs.MarkDeprecated("register-schedulable", "will be removed in a future version")
 	fs.StringVar(&f.ExperimentalMounterPath, "experimental-mounter-path", f.ExperimentalMounterPath, "[Experimental] Path of mounter binary. Leave empty to use the default mount.")
 	fs.MarkDeprecated("experimental-mounter-path", "will be removed in 1.25 or later. in favor of using CSI.")
-	fs.StringVar(&f.CloudConfigFile, "cloud-config", f.CloudConfigFile, "The path to the cloud provider configuration file. Empty string for no configuration file.")
path: cmd/kubelet/app/options/options.go
user: login: pohly
body: In addition to warning in the release notes, please also check for usage in-tree. hack/local-up-cluster.sh still uses it and now fails.

created_at: 2025-05-19T07:16:15Z
author_association: CONTRIBUTOR
diff_hunk: @@ -320,8 +320,6 @@ func (f *KubeletFlags) AddFlags(mainfs *pflag.FlagSet) {
 	fs.MarkDeprecated("register-schedulable", "will be removed in a future version")
 	fs.StringVar(&f.ExperimentalMounterPath, "experimental-mounter-path", f.ExperimentalMounterPath, "[Experimental] Path of mounter binary. Leave empty to use the default mount.")
 	fs.MarkDeprecated("experimental-mounter-path", "will be removed in 1.25 or later. in favor of using CSI.")
-	fs.StringVar(&f.CloudConfigFile, "cloud-config", f.CloudConfigFile, "The path to the cloud provider configuration file. Empty string for no configuration file.")
path: cmd/kubelet/app/options/options.go
user: login: pohly
body: => https://github.com/kubernetes/kubernetes/pull/131841
created_at: 2025-05-19T07:22:42Z
author_association: CONTRIBUTOR
diff_hunk: @@ -320,8 +320,6 @@ func (f *KubeletFlags) AddFlags(mainfs *pflag.FlagSet) {
 	fs.MarkDeprecated("register-schedulable", "will be removed in a future version")
 	fs.StringVar(&f.ExperimentalMounterPath, "experimental-mounter-path", f.ExperimentalMounterPath, "[Experimental] Path of mounter binary. Leave empty to use the default mount.")
 	fs.MarkDeprecated("experimental-mounter-path", "will be removed in 1.25 or later. in favor of using CSI.")
-	fs.StringVar(&f.CloudConfigFile, "cloud-config", f.CloudConfigFile, "The path to the cloud provider configuration file. Empty string for no configuration file.")
path: cmd/kubelet/app/options/options.go
user: login: carlory
body: Sorry for that. 
created_at: 2025-05-19T08:03:51Z
author_association: MEMBER

PR comments:
user: login: carlory
created_at: 2025-02-14T10:24:19Z
body: /cc @dims @elmiko
author_association: MEMBER
user: login: bart0sh
created_at: 2025-02-17T09:32:04Z
body: /triage accepted
author_association: CONTRIBUTOR
user: login: carlory
created_at: 2025-02-26T15:17:34Z
body: @elmiko it only remove the --cloud-config flag, not remove others. I only change the description of those flags.
author_association: MEMBER
user: login: elmiko
created_at: 2025-02-26T16:33:39Z
body: ah! thank you @carlory , i misread the commit diff.
author_association: CONTRIBUTOR
user: login: carlory
created_at: 2025-02-27T03:17:34Z
body: /test pull-kubernetes-cmd
author_association: MEMBER
user: login: k8s-ci-robot
created_at: 2025-02-28T14:19:56Z
body: LGTM label has been added.  <details>Git tree hash: 617b93c8c3a84675c9ed6abf04732a15714d898e</details>
author_association: CONTRIBUTOR
user: login: carlory
created_at: 2025-03-04T02:15:23Z
body: /assign @mborsz @sjenning 
for approval
author_association: MEMBER
user: login: carlory
created_at: 2025-03-19T03:23:00Z
body: /test pull-kubernetes-unit-windows-master
author_association: MEMBER
user: login: carlory
created_at: 2025-04-24T02:58:06Z
body: /cc @danwinship @elmiko 
author_association: MEMBER
user: login: carlory
created_at: 2025-05-12T01:52:41Z
body: /cc @danwinship 
author_association: MEMBER
user: login: danwinship
created_at: 2025-05-12T12:39:08Z
body: networking parts lgtm
author_association: CONTRIBUTOR
user: login: carlory
created_at: 2025-05-13T02:29:54Z
body: /cc @elmiko
for lgtm 
/assign @mborsz @sjenning 
for approval
author_association: MEMBER
user: login: k8s-ci-robot
created_at: 2025-05-13T19:04:37Z
body: LGTM label has been added.  <details>Git tree hash: 98aae9f19dd4fc9ff5959cf69ff3690b5211cdf4</details>
author_association: CONTRIBUTOR
user: login: carlory
created_at: 2025-05-14T02:14:46Z
body: /assign @SergeyKanzhelev @derekwaynecarr @wojtek-t 
for approval (sig-node)
/assign @dims
for approval (sig-cloud-provider)
author_association: MEMBER
user: login: dims
created_at: 2025-05-15T12:41:50Z
body: @carlory do ping me after the sig-node folks take a shot at it please
author_association: MEMBER
user: login: carlory
created_at: 2025-05-16T01:52:05Z
body: /cc @tallclair @klueska 

Can you have a look? 
author_association: MEMBER
user: login: carlory
created_at: 2025-05-17T02:27:29Z
body: /cc @dims 
author_association: MEMBER
user: login: dims
created_at: 2025-05-17T12:15:05Z
body: /lgtm
/approve

thanks @carlory 
author_association: MEMBER
user: login: k8s-ci-robot
created_at: 2025-05-17T12:15:18Z
body: [APPROVALNOTIFIER] This PR is **APPROVED**

This pull-request has been approved by: *<a href="https://github.com/kubernetes/kubernetes/pull/130161#" title="Author self-approved">carlory</a>*, *<a href="https://github.com/kubernetes/kubernetes/pull/130161#issuecomment-2888347225" title="Approved">dims</a>*, *<a href="https://github.com/kubernetes/kubernetes/pull/130161#pullrequestreview-2847603825" title="Approved">SergeyKanzhelev</a>*

The full list of commands accepted by this bot can be found [here](https://go.k8s.io/bot-commands?repo=kubernetes%2Fkubernetes).

The pull request process is described [here](https://git.k8s.io/community/contributors/guide/owners.md#the-code-review-process)

<details >
Needs approval from an approver in each of these files:

- ~~[cmd/kubelet/OWNERS](https://github.com/kubernetes/kubernetes/blob/master/cmd/kubelet/OWNERS)~~ [SergeyKanzhelev,dims]
- ~~[pkg/kubelet/OWNERS](https://github.com/kubernetes/kubernetes/blob/master/pkg/kubelet/OWNERS)~~ [SergeyKanzhelev,dims]
- ~~[pkg/kubemark/OWNERS](https://github.com/kubernetes/kubernetes/blob/master/pkg/kubemark/OWNERS)~~ [dims]
- ~~[staging/src/k8s.io/cloud-provider/OWNERS](https://github.com/kubernetes/kubernetes/blob/master/staging/src/k8s.io/cloud-provider/OWNERS)~~ [dims]

Approvers can indicate their approval by writing `/approve` in a comment
Approvers can cancel approval by writing `/approve cancel` in a comment
</details>
<!-- META={"approvers":[]} -->
author_association: CONTRIBUTOR
user: login: k8s-triage-robot
created_at: 2025-05-17T15:38:35Z
body: The Kubernetes project has merge-blocking tests that are currently too flaky to consistently pass.

This bot retests PRs for certain kubernetes repos according to the following rules:
- The PR does have any `do-not-merge/*` labels
- The PR does not have the `needs-ok-to-test` label
- The PR is mergeable (does not have a `needs-rebase` label)
- The PR is approved (has `cncf-cla: yes`, `lgtm`, `approved` labels)
- The PR is failing tests required for merge

You can:
- Review the [full test history](https://prow.k8s.io/pr-history/?org=kubernetes&repo=kubernetes&pr=130161) for this PR
- Prevent this bot from retesting with `/lgtm cancel` or `/hold`
- Help make our tests less flaky by following our [Flaky Tests Guide][1]

/retest

[1]: https://git.k8s.io/community/contributors/devel/sig-testing/flaky-tests.md
author_association: NONE
user: login: k8s-triage-robot
created_at: 2025-05-17T19:25:36Z
body: The Kubernetes project has merge-blocking tests that are currently too flaky to consistently pass.

This bot retests PRs for certain kubernetes repos according to the following rules:
- The PR does have any `do-not-merge/*` labels
- The PR does not have the `needs-ok-to-test` label
- The PR is mergeable (does not have a `needs-rebase` label)
- The PR is approved (has `cncf-cla: yes`, `lgtm`, `approved` labels)
- The PR is failing tests required for merge

You can:
- Review the [full test history](https://prow.k8s.io/pr-history/?org=kubernetes&repo=kubernetes&pr=130161) for this PR
- Prevent this bot from retesting with `/lgtm cancel` or `/hold`
- Help make our tests less flaky by following our [Flaky Tests Guide][1]

/retest

[1]: https://git.k8s.io/community/contributors/devel/sig-testing/flaky-tests.md
author_association: NONE