kubeadm: enable v1beta3 accross the code base

- scheme: switch to:
utilruntime.Must(scheme.SetVersionPriority(v1beta3.SchemeGroupVersion))
- change all imports in the code base from v1beta2 to v1beta3
- rename all import aliases for kubeadmapiv1beta2 to "kubeadmapiv".
this allows smaller diffs when changing the default public API.

cmd/kubeadm/app/apis/kubeadm/fuzzer/fuzzer.go

@@ -21,7 +21,7 @@ import (
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	runtimeserializer "k8s.io/apimachinery/pkg/runtime/serializer"
 	"k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
-	"k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	"k8s.io/kubernetes/cmd/kubeadm/app/constants"
 )
 
@@ -58,18 +58,18 @@ func fuzzInitConfiguration(obj *kubeadm.InitConfiguration, c fuzz.Continue) {
 		DNS: kubeadm.DNS{
 			Type: kubeadm.CoreDNS,
 		},
-		CertificatesDir: v1beta2.DefaultCertificatesDir,
+		CertificatesDir: kubeadmapiv1.DefaultCertificatesDir,
-		ClusterName:     v1beta2.DefaultClusterName,
+		ClusterName:     kubeadmapiv1.DefaultClusterName,
 		Etcd: kubeadm.Etcd{
 			Local: &kubeadm.LocalEtcd{
-				DataDir: v1beta2.DefaultEtcdDataDir,
+				DataDir: kubeadmapiv1.DefaultEtcdDataDir,
 			},
 		},
-		ImageRepository:   v1beta2.DefaultImageRepository,
+		ImageRepository:   kubeadmapiv1.DefaultImageRepository,
-		KubernetesVersion: v1beta2.DefaultKubernetesVersion,
+		KubernetesVersion: kubeadmapiv1.DefaultKubernetesVersion,
 		Networking: kubeadm.Networking{
-			ServiceSubnet: v1beta2.DefaultServicesSubnet,
+			ServiceSubnet: kubeadmapiv1.DefaultServicesSubnet,
-			DNSDomain:     v1beta2.DefaultServiceDNSDomain,
+			DNSDomain:     kubeadmapiv1.DefaultServiceDNSDomain,
 		},
 	}
 	// Adds the default bootstrap token to get the round working

cmd/kubeadm/app/apis/kubeadm/scheme/scheme.go

@@ -43,5 +43,5 @@ func AddToScheme(scheme *runtime.Scheme) {
 	utilruntime.Must(kubeadm.AddToScheme(scheme))
 	utilruntime.Must(v1beta2.AddToScheme(scheme))
 	utilruntime.Must(v1beta3.AddToScheme(scheme))
-	utilruntime.Must(scheme.SetVersionPriority(v1beta2.SchemeGroupVersion))
+	utilruntime.Must(scheme.SetVersionPriority(v1beta3.SchemeGroupVersion))
 }

cmd/kubeadm/app/apis/kubeadm/validation/validation.go

@@ -34,7 +34,7 @@ import (
 	bootstraputil "k8s.io/cluster-bootstrap/token/util"
 	"k8s.io/klog/v2"
 	"k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
-	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	kubeadmcmdoptions "k8s.io/kubernetes/cmd/kubeadm/app/cmd/options"
 	"k8s.io/kubernetes/cmd/kubeadm/app/componentconfigs"
 	"k8s.io/kubernetes/cmd/kubeadm/app/constants"
@@ -639,7 +639,7 @@ func ValidateSocketPath(socket string, fldPath *field.Path) field.ErrorList {
 		if !filepath.IsAbs(u.Path) {
 			return append(allErrs, field.Invalid(fldPath, socket, fmt.Sprintf("path is not absolute: %s", socket)))
 		}
-	} else if u.Scheme != kubeadmapiv1beta2.DefaultUrlScheme {
+	} else if u.Scheme != kubeadmapiv1.DefaultUrlScheme {
 		return append(allErrs, field.Invalid(fldPath, socket, fmt.Sprintf("URL scheme %s is not supported", u.Scheme)))
 	}
 

cmd/kubeadm/app/apis/kubeadm/validation/validation_test.go

@@ -25,7 +25,7 @@ import (
 	"k8s.io/apimachinery/pkg/util/sets"
 	"k8s.io/apimachinery/pkg/util/validation/field"
 	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
-	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	"k8s.io/kubernetes/cmd/kubeadm/app/features"
 )
 
@@ -986,7 +986,7 @@ func TestValidateSocketPath(t *testing.T) {
 		expectedErrors bool
 	}{
 		{name: "valid path", criSocket: "/some/path", expectedErrors: false},
-		{name: "valid socket url", criSocket: kubeadmapiv1beta2.DefaultUrlScheme + "://" + "/some/path", expectedErrors: false},
+		{name: "valid socket url", criSocket: kubeadmapiv1.DefaultUrlScheme + "://" + "/some/path", expectedErrors: false},
 		{name: "unsupported url scheme", criSocket: "bla:///some/path", expectedErrors: true},
 		{name: "unparseable url", criSocket: ":::", expectedErrors: true},
 		{name: "invalid CRISocket (path is not absolute)", criSocket: "some/path", expectedErrors: true},

cmd/kubeadm/app/cmd/alpha/kubeconfig.go

@@ -23,7 +23,7 @@ import (
 	"github.com/spf13/cobra"
 	"k8s.io/klog/v2"
 
-	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	"k8s.io/kubernetes/cmd/kubeadm/app/cmd/options"
 	cmdutil "k8s.io/kubernetes/cmd/kubeadm/app/cmd/util"
 	kubeadmconstants "k8s.io/kubernetes/cmd/kubeadm/app/constants"
@@ -62,7 +62,7 @@ func NewCmdKubeConfigUtility(out io.Writer) *cobra.Command {
 func newCmdUserKubeConfig(out io.Writer) *cobra.Command {
 
 	initCfg := cmdutil.DefaultInitConfiguration()
-	clusterCfg := &kubeadmapiv1beta2.ClusterConfiguration{}
+	clusterCfg := &kubeadmapiv1.ClusterConfiguration{}
 
 	var (
 		token, clientName, cfgPath string

cmd/kubeadm/app/cmd/alpha/kubeconfig_test.go

@@ -28,7 +28,7 @@ import (
 	"k8s.io/client-go/tools/clientcmd"
 	"sigs.k8s.io/yaml"
 
-	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	kubeadmconstants "k8s.io/kubernetes/cmd/kubeadm/app/constants"
 	"k8s.io/kubernetes/cmd/kubeadm/app/util/pkiutil"
 	testutil "k8s.io/kubernetes/cmd/kubeadm/test"
@@ -37,19 +37,19 @@ import (
 
 func generateTestKubeadmConfig(dir, id, certDir, clusterName string) (string, error) {
 	cfgPath := filepath.Join(dir, id)
-	initCfg := kubeadmapiv1beta2.InitConfiguration{
+	initCfg := kubeadmapiv1.InitConfiguration{
 		TypeMeta: metav1.TypeMeta{
-			APIVersion: "kubeadm.k8s.io/v1beta2",
+			APIVersion: "kubeadm.k8s.io/v1beta3",
 			Kind:       "InitConfiguration",
 		},
-		LocalAPIEndpoint: kubeadmapiv1beta2.APIEndpoint{
+		LocalAPIEndpoint: kubeadmapiv1.APIEndpoint{
 			AdvertiseAddress: "1.2.3.4",
 			BindPort:         1234,
 		},
 	}
-	clusterCfg := kubeadmapiv1beta2.ClusterConfiguration{
+	clusterCfg := kubeadmapiv1.ClusterConfiguration{
 		TypeMeta: metav1.TypeMeta{
-			APIVersion: "kubeadm.k8s.io/v1beta2",
+			APIVersion: "kubeadm.k8s.io/v1beta3",
 			Kind:       "ClusterConfiguration",
 		},
 		CertificatesDir:   certDir,

cmd/kubeadm/app/cmd/certs.go

@@ -30,7 +30,7 @@ import (
 
 	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
 	kubeadmscheme "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/scheme"
-	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	"k8s.io/kubernetes/cmd/kubeadm/app/cmd/options"
 	cmdutil "k8s.io/kubernetes/cmd/kubeadm/app/cmd/util"
 	kubeadmconstants "k8s.io/kubernetes/cmd/kubeadm/app/constants"
@@ -134,7 +134,7 @@ func (o *genCSRConfig) load() (err error) {
 	o.kubeadmConfig, err = configutil.LoadOrDefaultInitConfiguration(
 		o.kubeadmConfigPath,
 		cmdutil.DefaultInitConfiguration(),
-		&kubeadmapiv1beta2.ClusterConfiguration{},
+		&kubeadmapiv1.ClusterConfiguration{},
 	)
 	if err != nil {
 		return err
@@ -214,14 +214,14 @@ func newCmdCertsRenewal(out io.Writer) *cobra.Command {
 type renewFlags struct {
 	cfgPath        string
 	kubeconfigPath string
-	cfg            kubeadmapiv1beta2.ClusterConfiguration
+	cfg            kubeadmapiv1.ClusterConfiguration
 	csrOnly        bool
 	csrPath        string
 }
 
 func getRenewSubCommands(out io.Writer, kdir string) []*cobra.Command {
 	flags := &renewFlags{
-		cfg: kubeadmapiv1beta2.ClusterConfiguration{
+		cfg: kubeadmapiv1.ClusterConfiguration{
 			// Setting kubernetes version to a default value in order to allow a not necessary internet lookup
 			KubernetesVersion: kubeadmconstants.CurrentKubernetesVersion.String(),
 		},
@@ -342,7 +342,7 @@ func renewCert(flags *renewFlags, kdir string, internalcfg *kubeadmapi.InitConfi
 	return nil
 }
 
-func getInternalCfg(cfgPath string, kubeconfigPath string, cfg kubeadmapiv1beta2.ClusterConfiguration, out io.Writer, logPrefix string) (*kubeadmapi.InitConfiguration, error) {
+func getInternalCfg(cfgPath string, kubeconfigPath string, cfg kubeadmapiv1.ClusterConfiguration, out io.Writer, logPrefix string) (*kubeadmapi.InitConfiguration, error) {
 	// In case the user is not providing a custom config, try to get current config from the cluster.
 	// NB. this operation should not block, because we want to allow certificate renewal also in case of not-working clusters
 	if cfgPath == "" {
@@ -364,7 +364,7 @@ func getInternalCfg(cfgPath string, kubeconfigPath string, cfg kubeadmapiv1beta2
 // newCmdCertsExpiration creates a new `cert check-expiration` command.
 func newCmdCertsExpiration(out io.Writer, kdir string) *cobra.Command {
 	flags := &expirationFlags{
-		cfg: kubeadmapiv1beta2.ClusterConfiguration{
+		cfg: kubeadmapiv1.ClusterConfiguration{
 			// Setting kubernetes version to a default value in order to allow a not necessary internet lookup
 			KubernetesVersion: kubeadmconstants.CurrentKubernetesVersion.String(),
 		},
@@ -463,7 +463,7 @@ func newCmdCertsExpiration(out io.Writer, kdir string) *cobra.Command {
 type expirationFlags struct {
 	cfgPath        string
 	kubeconfigPath string
-	cfg            kubeadmapiv1beta2.ClusterConfiguration
+	cfg            kubeadmapiv1.ClusterConfiguration
 }
 
 func addExpirationFlags(cmd *cobra.Command, flags *expirationFlags) {

cmd/kubeadm/app/cmd/certs_test.go

@@ -34,7 +34,7 @@ import (
 	"k8s.io/client-go/tools/clientcmd"
 
 	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
-	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	kubeadmconstants "k8s.io/kubernetes/cmd/kubeadm/app/constants"
 	certsphase "k8s.io/kubernetes/cmd/kubeadm/app/phases/certs"
 	kubeconfigphase "k8s.io/kubernetes/cmd/kubeadm/app/phases/kubeconfig"
@@ -410,7 +410,7 @@ kubernetesVersion: ` + kubeadmconstants.MinimumControlPlaneVersion.String()
 		{
 			name: "default",
 			assertions: []assertion{
-				hasCertDir(kubeadmapiv1beta2.DefaultCertificatesDir),
+				hasCertDir(kubeadmapiv1.DefaultCertificatesDir),
 				hasKubeConfigDir(kubeadmconstants.KubernetesDir),
 			},
 		},

cmd/kubeadm/app/cmd/config.go

@@ -37,7 +37,7 @@ import (
 	clientset "k8s.io/client-go/kubernetes"
 	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
 	kubeadmscheme "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/scheme"
-	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	outputapischeme "k8s.io/kubernetes/cmd/kubeadm/app/apis/output/scheme"
 	outputapiv1alpha1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/output/v1alpha1"
 	"k8s.io/kubernetes/cmd/kubeadm/app/cmd/options"
@@ -206,15 +206,15 @@ func getDefaultInitConfigBytes() ([]byte, error) {
 }
 
 func getDefaultNodeConfigBytes() ([]byte, error) {
-	internalcfg, err := configutil.DefaultedJoinConfiguration(&kubeadmapiv1beta2.JoinConfiguration{
+	internalcfg, err := configutil.DefaultedJoinConfiguration(&kubeadmapiv1.JoinConfiguration{
-		Discovery: kubeadmapiv1beta2.Discovery{
+		Discovery: kubeadmapiv1.Discovery{
-			BootstrapToken: &kubeadmapiv1beta2.BootstrapTokenDiscovery{
+			BootstrapToken: &kubeadmapiv1.BootstrapTokenDiscovery{
 				Token:                    configutil.PlaceholderToken.Token.String(),
 				APIServerEndpoint:        "kube-apiserver:6443",
 				UnsafeSkipCAVerification: true, // TODO: UnsafeSkipCAVerification: true needs to be set for validation to pass, but shouldn't be recommended as the default
 			},
 		},
-		NodeRegistration: kubeadmapiv1beta2.NodeRegistrationOptions{
+		NodeRegistration: kubeadmapiv1.NodeRegistrationOptions{
 			CRISocket: constants.DefaultDockerCRISocket, // avoid CRI detection
 		},
 	})
@@ -244,7 +244,7 @@ func newCmdConfigMigrate(out io.Writer) *cobra.Command {
 
 			In other words, the output of this command is what kubeadm actually would read internally if you
 			submitted this file to "kubeadm init"
-		`), kubeadmapiv1beta2.SchemeGroupVersion, kubeadmapiv1beta2.SchemeGroupVersion),
+		`), kubeadmapiv1.SchemeGroupVersion, kubeadmapiv1.SchemeGroupVersion),
 		RunE: func(cmd *cobra.Command, args []string) error {
 			if len(oldCfgPath) == 0 {
 				return errors.New("the --old-config flag is mandatory")
@@ -327,9 +327,9 @@ func newCmdConfigImages(out io.Writer) *cobra.Command {
 
 // newCmdConfigImagesPull returns the `kubeadm config images pull` command
 func newCmdConfigImagesPull() *cobra.Command {
-	externalClusterCfg := &kubeadmapiv1beta2.ClusterConfiguration{}
+	externalClusterCfg := &kubeadmapiv1.ClusterConfiguration{}
 	kubeadmscheme.Scheme.Default(externalClusterCfg)
-	externalInitCfg := &kubeadmapiv1beta2.InitConfiguration{}
+	externalInitCfg := &kubeadmapiv1.InitConfiguration{}
 	kubeadmscheme.Scheme.Default(externalInitCfg)
 	var cfgPath, featureGatesString string
 	var err error
@@ -388,7 +388,7 @@ func PullControlPlaneImages(runtime utilruntime.ContainerRuntime, cfg *kubeadmap
 
 // newCmdConfigImagesList returns the "kubeadm config images list" command
 func newCmdConfigImagesList(out io.Writer, mockK8sVersion *string) *cobra.Command {
-	externalcfg := &kubeadmapiv1beta2.ClusterConfiguration{}
+	externalcfg := &kubeadmapiv1.ClusterConfiguration{}
 	kubeadmscheme.Scheme.Default(externalcfg)
 	var cfgPath, featureGatesString string
 	var err error
@@ -430,7 +430,7 @@ func newCmdConfigImagesList(out io.Writer, mockK8sVersion *string) *cobra.Comman
 }
 
 // NewImagesList returns the underlying struct for the "kubeadm config images list" command
-func NewImagesList(cfgPath string, cfg *kubeadmapiv1beta2.ClusterConfiguration) (*ImagesList, error) {
+func NewImagesList(cfgPath string, cfg *kubeadmapiv1.ClusterConfiguration) (*ImagesList, error) {
 	initcfg, err := configutil.LoadOrDefaultInitConfiguration(cfgPath, cmdutil.DefaultInitConfiguration(), cfg)
 	if err != nil {
 		return nil, errors.Wrap(err, "could not convert cfg to an internal cfg")
@@ -485,7 +485,7 @@ func (i *ImagesList) Run(out io.Writer, printer output.Printer) error {
 }
 
 // AddImagesCommonConfigFlags adds the flags that configure kubeadm (and affect the images kubeadm will use)
-func AddImagesCommonConfigFlags(flagSet *flag.FlagSet, cfg *kubeadmapiv1beta2.ClusterConfiguration, cfgPath *string, featureGatesString *string) {
+func AddImagesCommonConfigFlags(flagSet *flag.FlagSet, cfg *kubeadmapiv1.ClusterConfiguration, cfgPath *string, featureGatesString *string) {
 	options.AddKubernetesVersionFlag(flagSet, &cfg.KubernetesVersion)
 	options.AddFeatureGatesStringFlag(flagSet, featureGatesString)
 	options.AddImageMetaFlags(flagSet, &cfg.ImageRepository)

cmd/kubeadm/app/cmd/config_test.go

@@ -31,7 +31,7 @@ import (
 
 	"github.com/lithammer/dedent"
 	"github.com/spf13/cobra"
-	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	outputapischeme "k8s.io/kubernetes/cmd/kubeadm/app/apis/output/scheme"
 	"k8s.io/kubernetes/cmd/kubeadm/app/constants"
 	kubeadmutil "k8s.io/kubernetes/cmd/kubeadm/app/util"
@@ -119,7 +119,7 @@ func TestImagesListRunWithCustomConfigPath(t *testing.T) {
 				t.Fatalf("Failed writing a config file: %v", err)
 			}
 
-			i, err := NewImagesList(configFilePath, &kubeadmapiv1beta2.ClusterConfiguration{
+			i, err := NewImagesList(configFilePath, &kubeadmapiv1.ClusterConfiguration{
 				KubernetesVersion: dummyKubernetesVersionStr,
 			})
 			if err != nil {
@@ -146,21 +146,21 @@ func TestImagesListRunWithCustomConfigPath(t *testing.T) {
 func TestConfigImagesListRunWithoutPath(t *testing.T) {
 	testcases := []struct {
 		name           string
-		cfg            kubeadmapiv1beta2.ClusterConfiguration
+		cfg            kubeadmapiv1.ClusterConfiguration
 		expectedImages int
 	}{
 		{
 			name:           "empty config",
 			expectedImages: defaultNumberOfImages,
-			cfg: kubeadmapiv1beta2.ClusterConfiguration{
+			cfg: kubeadmapiv1.ClusterConfiguration{
 				KubernetesVersion: dummyKubernetesVersionStr,
 			},
 		},
 		{
 			name: "external etcd configuration",
-			cfg: kubeadmapiv1beta2.ClusterConfiguration{
+			cfg: kubeadmapiv1.ClusterConfiguration{
-				Etcd: kubeadmapiv1beta2.Etcd{
+				Etcd: kubeadmapiv1.Etcd{
-					External: &kubeadmapiv1beta2.ExternalEtcd{
+					External: &kubeadmapiv1.ExternalEtcd{
 						Endpoints: []string{"https://some.etcd.com:2379"},
 					},
 				},
@@ -170,7 +170,7 @@ func TestConfigImagesListRunWithoutPath(t *testing.T) {
 		},
 		{
 			name: "coredns enabled",
-			cfg: kubeadmapiv1beta2.ClusterConfiguration{
+			cfg: kubeadmapiv1.ClusterConfiguration{
 				KubernetesVersion: dummyKubernetesVersionStr,
 			},
 			expectedImages: defaultNumberOfImages,
@@ -223,13 +223,13 @@ func TestConfigImagesListOutput(t *testing.T) {
 
 	testcases := []struct {
 		name           string
-		cfg            kubeadmapiv1beta2.ClusterConfiguration
+		cfg            kubeadmapiv1.ClusterConfiguration
 		outputFormat   string
 		expectedOutput string
 	}{
 		{
 			name: "text output",
-			cfg: kubeadmapiv1beta2.ClusterConfiguration{
+			cfg: kubeadmapiv1.ClusterConfiguration{
 				KubernetesVersion: dummyKubernetesVersionStr,
 			},
 			outputFormat: "text",
@@ -244,7 +244,7 @@ k8s.gcr.io/coredns/coredns:{{.CoreDNSVersion}}
 		},
 		{
 			name: "JSON output",
-			cfg: kubeadmapiv1beta2.ClusterConfiguration{
+			cfg: kubeadmapiv1.ClusterConfiguration{
 				KubernetesVersion: dummyKubernetesVersionStr,
 			},
 			outputFormat: "json",
@@ -265,7 +265,7 @@ k8s.gcr.io/coredns/coredns:{{.CoreDNSVersion}}
 		},
 		{
 			name: "YAML output",
-			cfg: kubeadmapiv1beta2.ClusterConfiguration{
+			cfg: kubeadmapiv1.ClusterConfiguration{
 				KubernetesVersion: dummyKubernetesVersionStr,
 			},
 			outputFormat: "yaml",
@@ -283,7 +283,7 @@ kind: Images
 		},
 		{
 			name: "go-template output",
-			cfg: kubeadmapiv1beta2.ClusterConfiguration{
+			cfg: kubeadmapiv1.ClusterConfiguration{
 				KubernetesVersion: dummyKubernetesVersionStr,
 			},
 			outputFormat: `go-template={{range .images}}{{.}}{{"\n"}}{{end}}`,
@@ -298,7 +298,7 @@ k8s.gcr.io/coredns/coredns:{{.CoreDNSVersion}}
 		},
 		{
 			name: "JSONPATH output",
-			cfg: kubeadmapiv1beta2.ClusterConfiguration{
+			cfg: kubeadmapiv1.ClusterConfiguration{
 				KubernetesVersion: dummyKubernetesVersionStr,
 			},
 			outputFormat: `jsonpath={range.images[*]}{@} {end}`,

cmd/kubeadm/app/cmd/init.go

@@ -31,7 +31,7 @@ import (
 	clientset "k8s.io/client-go/kubernetes"
 	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
 	kubeadmscheme "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/scheme"
-	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	"k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/validation"
 	"k8s.io/kubernetes/cmd/kubeadm/app/cmd/options"
 	phases "k8s.io/kubernetes/cmd/kubeadm/app/cmd/phases/init"
@@ -99,8 +99,8 @@ type initOptions struct {
 	featureGatesString      string
 	ignorePreflightErrors   []string
 	bto                     *options.BootstrapTokenOptions
-	externalInitCfg         *kubeadmapiv1beta2.InitConfiguration
+	externalInitCfg         *kubeadmapiv1.InitConfiguration
-	externalClusterCfg      *kubeadmapiv1beta2.ClusterConfiguration
+	externalClusterCfg      *kubeadmapiv1.ClusterConfiguration
 	uploadCerts             bool
 	skipCertificateKeyPrint bool
 	patchesDir              string
@@ -204,7 +204,7 @@ func newCmdInit(out io.Writer, initOptions *initOptions) *cobra.Command {
 }
 
 // AddInitConfigFlags adds init flags bound to the config to the specified flagset
-func AddInitConfigFlags(flagSet *flag.FlagSet, cfg *kubeadmapiv1beta2.InitConfiguration) {
+func AddInitConfigFlags(flagSet *flag.FlagSet, cfg *kubeadmapiv1.InitConfiguration) {
 	flagSet.StringVar(
 		&cfg.LocalAPIEndpoint.AdvertiseAddress, options.APIServerAdvertiseAddress, cfg.LocalAPIEndpoint.AdvertiseAddress,
 		"The IP address the API Server will advertise it's listening on. If not set the default network interface will be used.",
@@ -225,7 +225,7 @@ func AddInitConfigFlags(flagSet *flag.FlagSet, cfg *kubeadmapiv1beta2.InitConfig
 }
 
 // AddClusterConfigFlags adds cluster flags bound to the config to the specified flagset
-func AddClusterConfigFlags(flagSet *flag.FlagSet, cfg *kubeadmapiv1beta2.ClusterConfiguration, featureGatesString *string) {
+func AddClusterConfigFlags(flagSet *flag.FlagSet, cfg *kubeadmapiv1.ClusterConfiguration, featureGatesString *string) {
 	flagSet.StringVar(
 		&cfg.Networking.ServiceSubnet, options.NetworkingServiceSubnet, cfg.Networking.ServiceSubnet,
 		"Use alternative range of IP address for service VIPs.",
@@ -287,10 +287,10 @@ func AddInitOtherFlags(flagSet *flag.FlagSet, initOptions *initOptions) {
 // newInitOptions returns a struct ready for being used for creating cmd init flags.
 func newInitOptions() *initOptions {
 	// initialize the public kubeadm config API by applying defaults
-	externalInitCfg := &kubeadmapiv1beta2.InitConfiguration{}
+	externalInitCfg := &kubeadmapiv1.InitConfiguration{}
 	kubeadmscheme.Scheme.Default(externalInitCfg)
 
-	externalClusterCfg := &kubeadmapiv1beta2.ClusterConfiguration{}
+	externalClusterCfg := &kubeadmapiv1.ClusterConfiguration{}
 	kubeadmscheme.Scheme.Default(externalClusterCfg)
 
 	// Create the options object for the bootstrap token-related flags, and override the default value for .Description

cmd/kubeadm/app/cmd/join.go

@@ -34,7 +34,7 @@ import (
 	"k8s.io/klog/v2"
 	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
 	kubeadmscheme "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/scheme"
-	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	"k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/validation"
 	"k8s.io/kubernetes/cmd/kubeadm/app/cmd/options"
 	phases "k8s.io/kubernetes/cmd/kubeadm/app/cmd/phases/join"
@@ -127,8 +127,8 @@ type joinOptions struct {
 	token                 string `datapolicy:"token"`
 	controlPlane          bool
 	ignorePreflightErrors []string
-	externalcfg           *kubeadmapiv1beta2.JoinConfiguration
+	externalcfg           *kubeadmapiv1.JoinConfiguration
-	joinControlPlane      *kubeadmapiv1beta2.JoinControlPlane
+	joinControlPlane      *kubeadmapiv1.JoinControlPlane
 	patchesDir            string
 }
 
@@ -224,7 +224,7 @@ func newCmdJoin(out io.Writer, joinOptions *joinOptions) *cobra.Command {
 }
 
 // addJoinConfigFlags adds join flags bound to the config to the specified flagset
-func addJoinConfigFlags(flagSet *flag.FlagSet, cfg *kubeadmapiv1beta2.JoinConfiguration, jcp *kubeadmapiv1beta2.JoinControlPlane) {
+func addJoinConfigFlags(flagSet *flag.FlagSet, cfg *kubeadmapiv1.JoinConfiguration, jcp *kubeadmapiv1.JoinControlPlane) {
 	flagSet.StringVar(
 		&cfg.NodeRegistration.Name, options.NodeName, cfg.NodeRegistration.Name,
 		`Specify the node name.`,
@@ -291,20 +291,20 @@ func addJoinOtherFlags(flagSet *flag.FlagSet, joinOptions *joinOptions) {
 // newJoinOptions returns a struct ready for being used for creating cmd join flags.
 func newJoinOptions() *joinOptions {
 	// initialize the public kubeadm config API by applying defaults
-	externalcfg := &kubeadmapiv1beta2.JoinConfiguration{}
+	externalcfg := &kubeadmapiv1.JoinConfiguration{}
 
 	// Add optional config objects to host flags.
 	// un-set objects will be cleaned up afterwards (into newJoinData func)
-	externalcfg.Discovery.File = &kubeadmapiv1beta2.FileDiscovery{}
+	externalcfg.Discovery.File = &kubeadmapiv1.FileDiscovery{}
-	externalcfg.Discovery.BootstrapToken = &kubeadmapiv1beta2.BootstrapTokenDiscovery{}
+	externalcfg.Discovery.BootstrapToken = &kubeadmapiv1.BootstrapTokenDiscovery{}
-	externalcfg.ControlPlane = &kubeadmapiv1beta2.JoinControlPlane{}
+	externalcfg.ControlPlane = &kubeadmapiv1.JoinControlPlane{}
 
 	// This object is used for storage of control-plane flags.
-	joinControlPlane := &kubeadmapiv1beta2.JoinControlPlane{}
+	joinControlPlane := &kubeadmapiv1.JoinControlPlane{}
 
 	// Apply defaults
 	kubeadmscheme.Scheme.Default(externalcfg)
-	kubeadmapiv1beta2.SetDefaults_JoinControlPlane(joinControlPlane)
+	kubeadmapiv1.SetDefaults_JoinControlPlane(joinControlPlane)
 
 	return &joinOptions{
 		externalcfg:      externalcfg,
@@ -360,8 +360,8 @@ func newJoinData(cmd *cobra.Command, args []string, opt *joinOptions, out io.Wri
 	if !opt.controlPlane {
 		// Use a defaulted JoinControlPlane object to detect if the user has passed
 		// other control-plane related flags.
-		defaultJCP := &kubeadmapiv1beta2.JoinControlPlane{}
+		defaultJCP := &kubeadmapiv1.JoinControlPlane{}
-		kubeadmapiv1beta2.SetDefaults_JoinControlPlane(defaultJCP)
+		kubeadmapiv1.SetDefaults_JoinControlPlane(defaultJCP)
 
 		// This list must match the JCP flags in addJoinConfigFlags()
 		joinControlPlaneFlags := []string{
@@ -405,7 +405,7 @@ func newJoinData(cmd *cobra.Command, args []string, opt *joinOptions, out io.Wri
 			return nil, errors.Errorf("File %s does not exists. Please use 'kubeadm join phase control-plane-prepare' subcommands to generate it.", adminKubeConfigPath)
 		}
 		klog.V(1).Infof("[preflight] found discovery flags missing for this command. using FileDiscovery: %s", adminKubeConfigPath)
-		opt.externalcfg.Discovery.File = &kubeadmapiv1beta2.FileDiscovery{KubeConfigPath: adminKubeConfigPath}
+		opt.externalcfg.Discovery.File = &kubeadmapiv1.FileDiscovery{KubeConfigPath: adminKubeConfigPath}
 		opt.externalcfg.Discovery.BootstrapToken = nil //NB. this could be removed when we get better control on args (e.g. phases without discovery should have NoArgs )
 	}
 

cmd/kubeadm/app/cmd/options/token.go

@@ -23,14 +23,14 @@ import (
 	"github.com/spf13/pflag"
 
 	bootstrapapi "k8s.io/cluster-bootstrap/token/api"
-	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	kubeadmconstants "k8s.io/kubernetes/cmd/kubeadm/app/constants"
 )
 
 // NewBootstrapTokenOptions creates a new BootstrapTokenOptions object with the default values
 func NewBootstrapTokenOptions() *BootstrapTokenOptions {
-	bto := &BootstrapTokenOptions{&kubeadmapiv1beta2.BootstrapToken{}, ""}
+	bto := &BootstrapTokenOptions{&kubeadmapiv1.BootstrapToken{}, ""}
-	kubeadmapiv1beta2.SetDefaults_BootstrapToken(bto.BootstrapToken)
+	kubeadmapiv1.SetDefaults_BootstrapToken(bto.BootstrapToken)
 	return bto
 }
 
@@ -38,7 +38,7 @@ func NewBootstrapTokenOptions() *BootstrapTokenOptions {
 // and applying the parsed flags to a InitConfiguration object later at runtime
 // TODO: In the future, we might want to group the flags in a better way than adding them all individually like this
 type BootstrapTokenOptions struct {
-	*kubeadmapiv1beta2.BootstrapToken
+	*kubeadmapiv1.BootstrapToken
 	TokenStr string `datapolicy:"token"`
 }
 
@@ -89,16 +89,16 @@ func (bto *BootstrapTokenOptions) AddDescriptionFlag(fs *pflag.FlagSet) {
 
 // ApplyTo applies the values set internally in the BootstrapTokenOptions object to a InitConfiguration object at runtime
 // If --token was specified in the CLI (as a string), it's parsed and validated before it's added to the BootstrapToken object.
-func (bto *BootstrapTokenOptions) ApplyTo(cfg *kubeadmapiv1beta2.InitConfiguration) error {
+func (bto *BootstrapTokenOptions) ApplyTo(cfg *kubeadmapiv1.InitConfiguration) error {
 	if len(bto.TokenStr) > 0 {
 		var err error
-		bto.Token, err = kubeadmapiv1beta2.NewBootstrapTokenString(bto.TokenStr)
+		bto.Token, err = kubeadmapiv1.NewBootstrapTokenString(bto.TokenStr)
 		if err != nil {
 			return err
 		}
 	}
 
 	// Set the token specified by the flags as the first and only token to create in case --config is not specified
-	cfg.BootstrapTokens = []kubeadmapiv1beta2.BootstrapToken{*bto.BootstrapToken}
+	cfg.BootstrapTokens = []kubeadmapiv1.BootstrapToken{*bto.BootstrapToken}
 	return nil
 }

cmd/kubeadm/app/cmd/phases/init/certs.go

@@ -25,7 +25,7 @@ import (
 
 	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
 	kubeadmscheme "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/scheme"
-	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	"k8s.io/kubernetes/cmd/kubeadm/app/cmd/options"
 	"k8s.io/kubernetes/cmd/kubeadm/app/cmd/phases/workflow"
 	cmdutil "k8s.io/kubernetes/cmd/kubeadm/app/cmd/util"
@@ -156,7 +156,7 @@ func getSANDescription(certSpec *certsphase.KubeadmCert) string {
 	//Defaulted config we will use to get SAN certs
 	defaultConfig := cmdutil.DefaultInitConfiguration()
 	// GetAPIServerAltNames errors without an AdvertiseAddress; this is as good as any.
-	defaultConfig.LocalAPIEndpoint = kubeadmapiv1beta2.APIEndpoint{
+	defaultConfig.LocalAPIEndpoint = kubeadmapiv1.APIEndpoint{
 		AdvertiseAddress: "127.0.0.1",
 	}
 

cmd/kubeadm/app/cmd/phases/reset/cleanupnode.go

@@ -23,7 +23,7 @@ import (
 	"path/filepath"
 
 	"k8s.io/klog/v2"
-	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	"k8s.io/kubernetes/cmd/kubeadm/app/cmd/options"
 	"k8s.io/kubernetes/cmd/kubeadm/app/cmd/phases/workflow"
 	kubeadmconstants "k8s.io/kubernetes/cmd/kubeadm/app/constants"
@@ -85,7 +85,7 @@ func runCleanupNode(c workflow.RunData) error {
 
 	// Remove contents from the config and pki directories
 	klog.V(1).Infoln("[reset] Removing contents from the config and pki directories")
-	if certsDir != kubeadmapiv1beta2.DefaultCertificatesDir {
+	if certsDir != kubeadmapiv1.DefaultCertificatesDir {
 		klog.Warningf("[reset] WARNING: Cleaning a non-default certificates directory: %q\n", certsDir)
 	}
 	resetConfigDir(kubeadmconstants.KubernetesDir, certsDir)

cmd/kubeadm/app/cmd/phases/util.go

@@ -18,14 +18,14 @@ package phases
 
 import (
 	"k8s.io/component-base/version"
-	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 )
 
 // SetKubernetesVersion gets the current Kubeadm version and sets it as KubeadmVersion in the config,
 // unless it's already set to a value different from the default.
-func SetKubernetesVersion(cfg *kubeadmapiv1beta2.ClusterConfiguration) {
+func SetKubernetesVersion(cfg *kubeadmapiv1.ClusterConfiguration) {
 
-	if cfg.KubernetesVersion != kubeadmapiv1beta2.DefaultKubernetesVersion && cfg.KubernetesVersion != "" {
+	if cfg.KubernetesVersion != kubeadmapiv1.DefaultKubernetesVersion && cfg.KubernetesVersion != "" {
 		return
 	}
 	cfg.KubernetesVersion = version.Get().String()

cmd/kubeadm/app/cmd/phases/util_test.go

@@ -20,7 +20,7 @@ import (
 	"testing"
 
 	"k8s.io/component-base/version"
-	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 )
 
 func TestSetKubernetesVersion(t *testing.T) {
@@ -39,7 +39,7 @@ func TestSetKubernetesVersion(t *testing.T) {
 		},
 		{
 			name:   "default version is processed",
-			input:  kubeadmapiv1beta2.DefaultKubernetesVersion,
+			input:  kubeadmapiv1.DefaultKubernetesVersion,
 			output: ver,
 		},
 		{
@@ -51,7 +51,7 @@ func TestSetKubernetesVersion(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			cfg := &kubeadmapiv1beta2.ClusterConfiguration{KubernetesVersion: test.input}
+			cfg := &kubeadmapiv1.ClusterConfiguration{KubernetesVersion: test.input}
 			SetKubernetesVersion(cfg)
 			if cfg.KubernetesVersion != test.output {
 				t.Fatalf("expected %q, got %q", test.output, cfg.KubernetesVersion)

cmd/kubeadm/app/cmd/reset.go

@@ -27,7 +27,7 @@ import (
 	clientset "k8s.io/client-go/kubernetes"
 	"k8s.io/klog/v2"
 	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
-	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	"k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/validation"
 	"k8s.io/kubernetes/cmd/kubeadm/app/cmd/options"
 	phases "k8s.io/kubernetes/cmd/kubeadm/app/cmd/phases/reset"
@@ -81,7 +81,7 @@ type resetData struct {
 // newResetOptions returns a struct ready for being used for creating cmd join flags.
 func newResetOptions() *resetOptions {
 	return &resetOptions{
-		certificatesDir: kubeadmapiv1beta2.DefaultCertificatesDir,
+		certificatesDir: kubeadmapiv1.DefaultCertificatesDir,
 		forceReset:      false,
 		kubeconfigPath:  kubeadmconstants.GetAdminKubeConfigPath(),
 	}

cmd/kubeadm/app/cmd/token.go

@@ -41,6 +41,7 @@ import (
 	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
 	kubeadmscheme "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/scheme"
 	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	"k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/validation"
 	outputapischeme "k8s.io/kubernetes/cmd/kubeadm/app/apis/output/scheme"
 	outputapiv1alpha1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/output/v1alpha1"
@@ -232,9 +233,9 @@ func newCmdTokenGenerate(out io.Writer) *cobra.Command {
 }
 
 // RunCreateToken generates a new bootstrap token and stores it as a secret on the server.
-func RunCreateToken(out io.Writer, client clientset.Interface, cfgPath string, initCfg *kubeadmapiv1beta2.InitConfiguration, printJoinCommand bool, certificateKey string, kubeConfigFile string) error {
+func RunCreateToken(out io.Writer, client clientset.Interface, cfgPath string, initCfg *kubeadmapiv1.InitConfiguration, printJoinCommand bool, certificateKey string, kubeConfigFile string) error {
 	// ClusterConfiguration is needed just for the call to LoadOrDefaultInitConfiguration
-	clusterCfg := &kubeadmapiv1beta2.ClusterConfiguration{
+	clusterCfg := &kubeadmapiv1.ClusterConfiguration{
 		// KubernetesVersion is not used, but we set this explicitly to avoid
 		// the lookup of the version from the internet when executing LoadOrDefaultInitConfiguration
 		KubernetesVersion: kubeadmconstants.CurrentKubernetesVersion.String(),
@@ -415,7 +416,7 @@ func RunDeleteTokens(out io.Writer, client clientset.Interface, tokenIDsOrTokens
 		klog.V(1).Info("[token] parsing token")
 		if !bootstraputil.IsValidBootstrapTokenID(tokenIDOrToken) {
 			// Okay, the full token with both id and secret was probably passed. Parse it and extract the ID only
-			bts, err := kubeadmapiv1beta2.NewBootstrapTokenString(tokenIDOrToken)
+			bts, err := kubeadmapiv1.NewBootstrapTokenString(tokenIDOrToken)
 			if err != nil {
 				return errors.Errorf("given token didn't match pattern %q or %q",
 					bootstrapapi.BootstrapTokenIDPattern, bootstrapapi.BootstrapTokenIDPattern)

cmd/kubeadm/app/cmd/token_test.go

@@ -32,6 +32,7 @@ import (
 	core "k8s.io/client-go/testing"
 	"k8s.io/client-go/tools/clientcmd"
 	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	outputapischeme "k8s.io/kubernetes/cmd/kubeadm/app/apis/output/scheme"
 	outputapiv1alpha1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/output/v1alpha1"
 	"k8s.io/kubernetes/cmd/kubeadm/app/util/output"
@@ -156,13 +157,13 @@ func TestRunCreateToken(t *testing.T) {
 	}
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			bts, err := kubeadmapiv1beta2.NewBootstrapTokenString(tc.token)
+			bts, err := kubeadmapiv1.NewBootstrapTokenString(tc.token)
 			if err != nil && len(tc.token) != 0 { // if tc.token is "" it's okay as it will be generated later at runtime
 				t.Fatalf("token couldn't be parsed for testing: %v", err)
 			}
 
-			cfg := &kubeadmapiv1beta2.InitConfiguration{
+			cfg := &kubeadmapiv1.InitConfiguration{
-				BootstrapTokens: []kubeadmapiv1beta2.BootstrapToken{
+				BootstrapTokens: []kubeadmapiv1.BootstrapToken{
 					{
 						Token:  bts,
 						TTL:    &metav1.Duration{Duration: 0},

cmd/kubeadm/app/cmd/upgrade/common_test.go

@@ -91,7 +91,7 @@ func TestPrintConfiguration(t *testing.T) {
 			},
 			expectedBytes: []byte(`[upgrade/config] Configuration used:
 	apiServer: {}
-	apiVersion: kubeadm.k8s.io/v1beta2
+	apiVersion: kubeadm.k8s.io/v1beta3
 	controllerManager: {}
 	dns:
 	  type: CoreDNS
@@ -122,7 +122,7 @@ func TestPrintConfiguration(t *testing.T) {
 			},
 			expectedBytes: []byte(`[upgrade/config] Configuration used:
 	apiServer: {}
-	apiVersion: kubeadm.k8s.io/v1beta2
+	apiVersion: kubeadm.k8s.io/v1beta3
 	controllerManager: {}
 	dns:
 	  type: CoreDNS

cmd/kubeadm/app/cmd/util/cmdutil.go

@@ -23,7 +23,7 @@ import (
 
 	"k8s.io/client-go/tools/clientcmd"
 	"k8s.io/klog/v2"
-	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	"k8s.io/kubernetes/cmd/kubeadm/app/cmd/options"
 	kubeadmconstants "k8s.io/kubernetes/cmd/kubeadm/app/constants"
 )
@@ -91,9 +91,9 @@ func AddCRISocketFlag(flagSet *pflag.FlagSet, criSocket *string) {
 
 // DefaultInitConfiguration return default InitConfiguration. Avoid running the CRI auto-detection
 // code as we don't need it.
-func DefaultInitConfiguration() *kubeadmapiv1beta2.InitConfiguration {
+func DefaultInitConfiguration() *kubeadmapiv1.InitConfiguration {
-	initCfg := &kubeadmapiv1beta2.InitConfiguration{
+	initCfg := &kubeadmapiv1.InitConfiguration{
-		NodeRegistration: kubeadmapiv1beta2.NodeRegistrationOptions{
+		NodeRegistration: kubeadmapiv1.NodeRegistrationOptions{
 			CRISocket: kubeadmconstants.UnknownCRISocket, // avoid CRI detection
 		},
 	}

cmd/kubeadm/app/componentconfigs/kubelet.go

@@ -30,7 +30,7 @@ import (
 	utilpointer "k8s.io/utils/pointer"
 
 	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
-	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	"k8s.io/kubernetes/cmd/kubeadm/app/constants"
 	"k8s.io/kubernetes/cmd/kubeadm/app/features"
 	kubeadmutil "k8s.io/kubernetes/cmd/kubeadm/app/util"
@@ -128,15 +128,15 @@ func (kc *kubeletConfig) Default(cfg *kubeadmapi.ClusterConfiguration, _ *kubead
 	}
 
 	if kc.config.StaticPodPath == "" {
-		kc.config.StaticPodPath = kubeadmapiv1beta2.DefaultManifestsDir
+		kc.config.StaticPodPath = kubeadmapiv1.DefaultManifestsDir
-	} else if kc.config.StaticPodPath != kubeadmapiv1beta2.DefaultManifestsDir {
+	} else if kc.config.StaticPodPath != kubeadmapiv1.DefaultManifestsDir {
-		warnDefaultComponentConfigValue(kind, "staticPodPath", kubeadmapiv1beta2.DefaultManifestsDir, kc.config.StaticPodPath)
+		warnDefaultComponentConfigValue(kind, "staticPodPath", kubeadmapiv1.DefaultManifestsDir, kc.config.StaticPodPath)
 	}
 
 	clusterDNS := ""
 	dnsIP, err := constants.GetDNSIP(cfg.Networking.ServiceSubnet, features.Enabled(cfg.FeatureGates, features.IPv6DualStack))
 	if err != nil {
-		clusterDNS = kubeadmapiv1beta2.DefaultClusterDNSIP
+		clusterDNS = kubeadmapiv1.DefaultClusterDNSIP
 	} else {
 		clusterDNS = dnsIP.String()
 	}

cmd/kubeadm/app/componentconfigs/kubelet_test.go

@@ -32,7 +32,7 @@ import (
 	utilpointer "k8s.io/utils/pointer"
 
 	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
-	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	"k8s.io/kubernetes/cmd/kubeadm/app/constants"
 	"k8s.io/kubernetes/cmd/kubeadm/app/features"
 )
@@ -67,8 +67,8 @@ func TestKubeletDefault(t *testing.T) {
 			expected: kubeletConfig{
 				config: kubeletconfig.KubeletConfiguration{
 					FeatureGates:  map[string]bool{},
-					StaticPodPath: kubeadmapiv1beta2.DefaultManifestsDir,
+					StaticPodPath: kubeadmapiv1.DefaultManifestsDir,
-					ClusterDNS:    []string{kubeadmapiv1beta2.DefaultClusterDNSIP},
+					ClusterDNS:    []string{kubeadmapiv1.DefaultClusterDNSIP},
 					Authentication: kubeletconfig.KubeletAuthentication{
 						X509: kubeletconfig.KubeletX509Authentication{
 							ClientCAFile: constants.CACertName,
@@ -100,7 +100,7 @@ func TestKubeletDefault(t *testing.T) {
 			expected: kubeletConfig{
 				config: kubeletconfig.KubeletConfiguration{
 					FeatureGates:  map[string]bool{},
-					StaticPodPath: kubeadmapiv1beta2.DefaultManifestsDir,
+					StaticPodPath: kubeadmapiv1.DefaultManifestsDir,
 					ClusterDNS:    []string{"192.168.0.10"},
 					Authentication: kubeletconfig.KubeletAuthentication{
 						X509: kubeletconfig.KubeletX509Authentication{
@@ -138,7 +138,7 @@ func TestKubeletDefault(t *testing.T) {
 					FeatureGates: map[string]bool{
 						features.IPv6DualStack: false,
 					},
-					StaticPodPath: kubeadmapiv1beta2.DefaultManifestsDir,
+					StaticPodPath: kubeadmapiv1.DefaultManifestsDir,
 					ClusterDNS:    []string{"192.168.0.10"},
 					Authentication: kubeletconfig.KubeletAuthentication{
 						X509: kubeletconfig.KubeletX509Authentication{
@@ -176,7 +176,7 @@ func TestKubeletDefault(t *testing.T) {
 					FeatureGates: map[string]bool{
 						features.IPv6DualStack: true,
 					},
-					StaticPodPath: kubeadmapiv1beta2.DefaultManifestsDir,
+					StaticPodPath: kubeadmapiv1.DefaultManifestsDir,
 					ClusterDNS:    []string{"192.168.0.10"},
 					Authentication: kubeletconfig.KubeletAuthentication{
 						X509: kubeletconfig.KubeletX509Authentication{
@@ -209,8 +209,8 @@ func TestKubeletDefault(t *testing.T) {
 			expected: kubeletConfig{
 				config: kubeletconfig.KubeletConfiguration{
 					FeatureGates:  map[string]bool{},
-					StaticPodPath: kubeadmapiv1beta2.DefaultManifestsDir,
+					StaticPodPath: kubeadmapiv1.DefaultManifestsDir,
-					ClusterDNS:    []string{kubeadmapiv1beta2.DefaultClusterDNSIP},
+					ClusterDNS:    []string{kubeadmapiv1.DefaultClusterDNSIP},
 					ClusterDomain: "example.com",
 					Authentication: kubeletconfig.KubeletAuthentication{
 						X509: kubeletconfig.KubeletX509Authentication{
@@ -241,8 +241,8 @@ func TestKubeletDefault(t *testing.T) {
 			expected: kubeletConfig{
 				config: kubeletconfig.KubeletConfiguration{
 					FeatureGates:  map[string]bool{},
-					StaticPodPath: kubeadmapiv1beta2.DefaultManifestsDir,
+					StaticPodPath: kubeadmapiv1.DefaultManifestsDir,
-					ClusterDNS:    []string{kubeadmapiv1beta2.DefaultClusterDNSIP},
+					ClusterDNS:    []string{kubeadmapiv1.DefaultClusterDNSIP},
 					Authentication: kubeletconfig.KubeletAuthentication{
 						X509: kubeletconfig.KubeletX509Authentication{
 							ClientCAFile: filepath.Join("/path/to/certs", constants.CACertName),

cmd/kubeadm/app/componentconfigs/kubeproxy.go

@@ -23,7 +23,7 @@ import (
 	kubeproxyconfig "k8s.io/kube-proxy/config/v1alpha1"
 
 	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
-	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	kubeadmconstants "k8s.io/kubernetes/cmd/kubeadm/app/constants"
 	"k8s.io/kubernetes/cmd/kubeadm/app/features"
 )
@@ -78,9 +78,9 @@ func (kp *kubeProxyConfig) Unmarshal(docmap kubeadmapi.DocumentMap) error {
 func kubeProxyDefaultBindAddress(localAdvertiseAddress string) string {
 	ip := net.ParseIP(localAdvertiseAddress)
 	if ip.To4() != nil {
-		return kubeadmapiv1beta2.DefaultProxyBindAddressv4
+		return kubeadmapiv1.DefaultProxyBindAddressv4
 	}
-	return kubeadmapiv1beta2.DefaultProxyBindAddressv6
+	return kubeadmapiv1.DefaultProxyBindAddressv6
 }
 
 func (kp *kubeProxyConfig) Get() interface{} {

cmd/kubeadm/app/componentconfigs/kubeproxy_test.go

@@ -31,7 +31,7 @@ import (
 
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
-	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	"k8s.io/kubernetes/cmd/kubeadm/app/constants"
 	"k8s.io/kubernetes/cmd/kubeadm/app/features"
 )
@@ -62,7 +62,7 @@ func TestKubeProxyDefault(t *testing.T) {
 			expected: kubeProxyConfig{
 				config: kubeproxyconfig.KubeProxyConfiguration{
 					FeatureGates: map[string]bool{},
-					BindAddress:  kubeadmapiv1beta2.DefaultProxyBindAddressv6,
+					BindAddress:  kubeadmapiv1.DefaultProxyBindAddressv6,
 					ClientConnection: componentbaseconfig.ClientConnectionConfiguration{
 						Kubeconfig: kubeproxyKubeConfigFileName,
 					},
@@ -78,7 +78,7 @@ func TestKubeProxyDefault(t *testing.T) {
 			expected: kubeProxyConfig{
 				config: kubeproxyconfig.KubeProxyConfiguration{
 					FeatureGates: map[string]bool{},
-					BindAddress:  kubeadmapiv1beta2.DefaultProxyBindAddressv4,
+					BindAddress:  kubeadmapiv1.DefaultProxyBindAddressv4,
 					ClientConnection: componentbaseconfig.ClientConnectionConfiguration{
 						Kubeconfig: kubeproxyKubeConfigFileName,
 					},
@@ -96,7 +96,7 @@ func TestKubeProxyDefault(t *testing.T) {
 			expected: kubeProxyConfig{
 				config: kubeproxyconfig.KubeProxyConfiguration{
 					FeatureGates: map[string]bool{},
-					BindAddress:  kubeadmapiv1beta2.DefaultProxyBindAddressv6,
+					BindAddress:  kubeadmapiv1.DefaultProxyBindAddressv6,
 					ClientConnection: componentbaseconfig.ClientConnectionConfiguration{
 						Kubeconfig: kubeproxyKubeConfigFileName,
 					},
@@ -117,7 +117,7 @@ func TestKubeProxyDefault(t *testing.T) {
 					FeatureGates: map[string]bool{
 						features.IPv6DualStack: true,
 					},
-					BindAddress: kubeadmapiv1beta2.DefaultProxyBindAddressv6,
+					BindAddress: kubeadmapiv1.DefaultProxyBindAddressv6,
 					ClientConnection: componentbaseconfig.ClientConnectionConfiguration{
 						Kubeconfig: kubeproxyKubeConfigFileName,
 					},
@@ -137,7 +137,7 @@ func TestKubeProxyDefault(t *testing.T) {
 					FeatureGates: map[string]bool{
 						features.IPv6DualStack: false,
 					},
-					BindAddress: kubeadmapiv1beta2.DefaultProxyBindAddressv6,
+					BindAddress: kubeadmapiv1.DefaultProxyBindAddressv6,
 					ClientConnection: componentbaseconfig.ClientConnectionConfiguration{
 						Kubeconfig: kubeproxyKubeConfigFileName,
 					},

cmd/kubeadm/app/discovery/discovery.go

@@ -24,7 +24,7 @@ import (
 	clientcmdapi "k8s.io/client-go/tools/clientcmd/api"
 	"k8s.io/klog/v2"
 	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
-	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	"k8s.io/kubernetes/cmd/kubeadm/app/discovery/file"
 	"k8s.io/kubernetes/cmd/kubeadm/app/discovery/https"
 	"k8s.io/kubernetes/cmd/kubeadm/app/discovery/token"
@@ -53,7 +53,7 @@ func For(cfg *kubeadmapi.JoinConfiguration) (*clientcmdapi.Config, error) {
 		clusterinfo := kubeconfigutil.GetClusterFromKubeConfig(config)
 		return kubeconfigutil.CreateWithToken(
 			clusterinfo.Server,
-			kubeadmapiv1beta2.DefaultClusterName,
+			kubeadmapiv1.DefaultClusterName,
 			TokenUser,
 			clusterinfo.CertificateAuthorityData,
 			cfg.Discovery.TLSBootstrapToken,
@@ -75,9 +75,9 @@ func DiscoverValidatedKubeConfig(cfg *kubeadmapi.JoinConfiguration) (*clientcmda
 	case cfg.Discovery.File != nil:
 		kubeConfigPath := cfg.Discovery.File.KubeConfigPath
 		if isHTTPSURL(kubeConfigPath) {
-			return https.RetrieveValidatedConfigInfo(kubeConfigPath, kubeadmapiv1beta2.DefaultClusterName, cfg.Discovery.Timeout.Duration)
+			return https.RetrieveValidatedConfigInfo(kubeConfigPath, kubeadmapiv1.DefaultClusterName, cfg.Discovery.Timeout.Duration)
 		}
-		return file.RetrieveValidatedConfigInfo(kubeConfigPath, kubeadmapiv1beta2.DefaultClusterName, cfg.Discovery.Timeout.Duration)
+		return file.RetrieveValidatedConfigInfo(kubeConfigPath, kubeadmapiv1.DefaultClusterName, cfg.Discovery.Timeout.Duration)
 	case cfg.Discovery.BootstrapToken != nil:
 		return token.RetrieveValidatedConfigInfo(&cfg.Discovery)
 	default:

cmd/kubeadm/app/discovery/token/token.go

@@ -35,7 +35,7 @@ import (
 	bootstrap "k8s.io/cluster-bootstrap/token/jws"
 	"k8s.io/klog/v2"
 	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
-	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	"k8s.io/kubernetes/cmd/kubeadm/app/constants"
 	kubeconfigutil "k8s.io/kubernetes/cmd/kubeadm/app/util/kubeconfig"
 	"k8s.io/kubernetes/cmd/kubeadm/app/util/pubkeypin"
@@ -72,7 +72,7 @@ func retrieveValidatedConfigInfo(client clientset.Interface, cfg *kubeadmapi.Dis
 	}
 
 	endpoint := cfg.BootstrapToken.APIServerEndpoint
-	insecureBootstrapConfig := buildInsecureBootstrapKubeConfig(endpoint, kubeadmapiv1beta2.DefaultClusterName)
+	insecureBootstrapConfig := buildInsecureBootstrapKubeConfig(endpoint, kubeadmapiv1.DefaultClusterName)
 	clusterName := insecureBootstrapConfig.Contexts[insecureBootstrapConfig.CurrentContext].Cluster
 
 	klog.V(1).Infof("[discovery] Created cluster-info discovery client, requesting info from %q", endpoint)

cmd/kubeadm/app/util/config/common.go

@@ -31,7 +31,7 @@ import (
 	"k8s.io/apimachinery/pkg/util/version"
 	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
 	kubeadmscheme "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/scheme"
-	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	"k8s.io/kubernetes/cmd/kubeadm/app/constants"
 	kubeadmutil "k8s.io/kubernetes/cmd/kubeadm/app/util"
 )
@@ -40,9 +40,9 @@ import (
 func MarshalKubeadmConfigObject(obj runtime.Object) ([]byte, error) {
 	switch internalcfg := obj.(type) {
 	case *kubeadmapi.InitConfiguration:
-		return MarshalInitConfigurationToBytes(internalcfg, kubeadmapiv1beta2.SchemeGroupVersion)
+		return MarshalInitConfigurationToBytes(internalcfg, kubeadmapiv1.SchemeGroupVersion)
 	default:
-		return kubeadmutil.MarshalToYamlForCodecs(obj, kubeadmapiv1beta2.SchemeGroupVersion, kubeadmscheme.Codecs)
+		return kubeadmutil.MarshalToYamlForCodecs(obj, kubeadmapiv1.SchemeGroupVersion, kubeadmscheme.Codecs)
 	}
 }
 

cmd/kubeadm/app/util/config/common_test.go

@@ -23,7 +23,7 @@ import (
 	"github.com/lithammer/dedent"
 
 	"k8s.io/apimachinery/pkg/runtime/schema"
-	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	"k8s.io/kubernetes/cmd/kubeadm/app/constants"
 	kubeadmutil "k8s.io/kubernetes/cmd/kubeadm/app/util"
 )
@@ -124,8 +124,8 @@ func TestLowercaseSANs(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			cfg := &kubeadmapiv1beta2.ClusterConfiguration{
+			cfg := &kubeadmapiv1.ClusterConfiguration{
-				APIServer: kubeadmapiv1beta2.APIServer{
+				APIServer: kubeadmapiv1.APIServer{
 					CertSANs: test.in,
 				},
 			}

cmd/kubeadm/app/util/config/initconfiguration.go

@@ -33,9 +33,10 @@ import (
 	bootstraputil "k8s.io/cluster-bootstrap/token/util"
 	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
 	kubeadmscheme "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/scheme"
-	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	"k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/validation"
 	"k8s.io/kubernetes/cmd/kubeadm/app/componentconfigs"
+	"k8s.io/kubernetes/cmd/kubeadm/app/constants"
 	kubeadmconstants "k8s.io/kubernetes/cmd/kubeadm/app/constants"
 	kubeadmutil "k8s.io/kubernetes/cmd/kubeadm/app/util"
 	"k8s.io/kubernetes/cmd/kubeadm/app/util/config/strict"
@@ -44,8 +45,8 @@ import (
 
 var (
 	// PlaceholderToken is only set statically to make kubeadm not randomize the token on every run
-	PlaceholderToken = kubeadmapiv1beta2.BootstrapToken{
+	PlaceholderToken = kubeadmapiv1.BootstrapToken{
-		Token: &kubeadmapiv1beta2.BootstrapTokenString{
+		Token: &kubeadmapiv1.BootstrapTokenString{
 			ID:     "abcdef",
 			Secret: "0123456789abcdef",
 		},
@@ -181,16 +182,16 @@ func SetClusterDynamicDefaults(cfg *kubeadmapi.ClusterConfiguration, localAPIEnd
 
 // DefaultedStaticInitConfiguration returns the internal InitConfiguration with static defaults.
 func DefaultedStaticInitConfiguration() (*kubeadmapi.InitConfiguration, error) {
-	versionedInitCfg := &kubeadmapiv1beta2.InitConfiguration{
+	versionedInitCfg := &kubeadmapiv1.InitConfiguration{
-		LocalAPIEndpoint: kubeadmapiv1beta2.APIEndpoint{AdvertiseAddress: "1.2.3.4"},
+		LocalAPIEndpoint: kubeadmapiv1.APIEndpoint{AdvertiseAddress: "1.2.3.4"},
-		BootstrapTokens:  []kubeadmapiv1beta2.BootstrapToken{PlaceholderToken},
+		BootstrapTokens:  []kubeadmapiv1.BootstrapToken{PlaceholderToken},
-		NodeRegistration: kubeadmapiv1beta2.NodeRegistrationOptions{
+		NodeRegistration: kubeadmapiv1.NodeRegistrationOptions{
 			CRISocket: kubeadmconstants.DefaultDockerCRISocket, // avoid CRI detection
 			Name:      "node",
 		},
 	}
-	versionedClusterCfg := &kubeadmapiv1beta2.ClusterConfiguration{
+	versionedClusterCfg := &kubeadmapiv1.ClusterConfiguration{
-		KubernetesVersion: kubeadmconstants.CurrentKubernetesVersion.String(), // avoid going to the Internet for the current Kubernetes version
+		KubernetesVersion: constants.CurrentKubernetesVersion.String(), // avoid going to the Internet for the current Kubernetes version
 	}
 
 	internalcfg := &kubeadmapi.InitConfiguration{}
@@ -214,7 +215,7 @@ func DefaultedStaticInitConfiguration() (*kubeadmapi.InitConfiguration, error) {
 }
 
 // DefaultedInitConfiguration takes a versioned init config (often populated by flags), defaults it and converts it into internal InitConfiguration
-func DefaultedInitConfiguration(versionedInitCfg *kubeadmapiv1beta2.InitConfiguration, versionedClusterCfg *kubeadmapiv1beta2.ClusterConfiguration) (*kubeadmapi.InitConfiguration, error) {
+func DefaultedInitConfiguration(versionedInitCfg *kubeadmapiv1.InitConfiguration, versionedClusterCfg *kubeadmapiv1.ClusterConfiguration) (*kubeadmapi.InitConfiguration, error) {
 	internalcfg := &kubeadmapi.InitConfiguration{}
 
 	// Takes passed flags into account; the defaulting is executed once again enforcing assignment of
@@ -257,7 +258,7 @@ func LoadInitConfigurationFromFile(cfgPath string) (*kubeadmapi.InitConfiguratio
 // The external, versioned configuration is defaulted and converted to the internal type.
 // Right thereafter, the configuration is defaulted again with dynamic values (like IP addresses of a machine, etc)
 // Lastly, the internal config is validated and returned.
-func LoadOrDefaultInitConfiguration(cfgPath string, versionedInitCfg *kubeadmapiv1beta2.InitConfiguration, versionedClusterCfg *kubeadmapiv1beta2.ClusterConfiguration) (*kubeadmapi.InitConfiguration, error) {
+func LoadOrDefaultInitConfiguration(cfgPath string, versionedInitCfg *kubeadmapiv1.InitConfiguration, versionedClusterCfg *kubeadmapiv1.ClusterConfiguration) (*kubeadmapi.InitConfiguration, error) {
 	if cfgPath != "" {
 		// Loads configuration from config file, if provided
 		// Nb. --config overrides command line flags
@@ -328,7 +329,7 @@ func documentMapToInitConfiguration(gvkmap kubeadmapi.DocumentMap, allowDeprecat
 
 	// If InitConfiguration wasn't given, default it by creating an external struct instance, default it and convert into the internal type
 	if initcfg == nil {
-		extinitcfg := &kubeadmapiv1beta2.InitConfiguration{}
+		extinitcfg := &kubeadmapiv1.InitConfiguration{}
 		kubeadmscheme.Scheme.Default(extinitcfg)
 		// Set initcfg to an empty struct value the deserializer will populate
 		initcfg = &kubeadmapi.InitConfiguration{}

cmd/kubeadm/app/util/config/initconfiguration_test.go

@@ -25,7 +25,7 @@ import (
 
 	v1 "k8s.io/api/core/v1"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
-	kubeadmapiv1beta3 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	"k8s.io/kubernetes/cmd/kubeadm/app/constants"
 	"sigs.k8s.io/yaml"
 )
@@ -111,12 +111,12 @@ func TestLoadInitConfigurationFromFile(t *testing.T) {
 func TestDefaultTaintsMarshaling(t *testing.T) {
 	tests := []struct {
 		desc             string
-		cfg              kubeadmapiv1beta3.InitConfiguration
+		cfg              kubeadmapiv1.InitConfiguration
 		expectedTaintCnt int
 	}{
 		{
 			desc: "Uninitialized nodeRegistration field produces a single taint (the master one)",
-			cfg: kubeadmapiv1beta3.InitConfiguration{
+			cfg: kubeadmapiv1.InitConfiguration{
 				TypeMeta: metav1.TypeMeta{
 					APIVersion: "kubeadm.k8s.io/v1beta3",
 					Kind:       constants.InitConfigurationKind,
@@ -126,23 +126,23 @@ func TestDefaultTaintsMarshaling(t *testing.T) {
 		},
 		{
 			desc: "Uninitialized taints field produces a single taint (the master one)",
-			cfg: kubeadmapiv1beta3.InitConfiguration{
+			cfg: kubeadmapiv1.InitConfiguration{
 				TypeMeta: metav1.TypeMeta{
 					APIVersion: "kubeadm.k8s.io/v1beta3",
 					Kind:       constants.InitConfigurationKind,
 				},
-				NodeRegistration: kubeadmapiv1beta3.NodeRegistrationOptions{},
+				NodeRegistration: kubeadmapiv1.NodeRegistrationOptions{},
 			},
 			expectedTaintCnt: 1,
 		},
 		{
 			desc: "Forsing taints to an empty slice produces no taints",
-			cfg: kubeadmapiv1beta3.InitConfiguration{
+			cfg: kubeadmapiv1.InitConfiguration{
 				TypeMeta: metav1.TypeMeta{
 					APIVersion: "kubeadm.k8s.io/v1beta3",
 					Kind:       constants.InitConfigurationKind,
 				},
-				NodeRegistration: kubeadmapiv1beta3.NodeRegistrationOptions{
+				NodeRegistration: kubeadmapiv1.NodeRegistrationOptions{
 					Taints: []v1.Taint{},
 				},
 			},
@@ -150,12 +150,12 @@ func TestDefaultTaintsMarshaling(t *testing.T) {
 		},
 		{
 			desc: "Custom taints are used",
-			cfg: kubeadmapiv1beta3.InitConfiguration{
+			cfg: kubeadmapiv1.InitConfiguration{
 				TypeMeta: metav1.TypeMeta{
 					APIVersion: "kubeadm.k8s.io/v1beta3",
 					Kind:       constants.InitConfigurationKind,
 				},
-				NodeRegistration: kubeadmapiv1beta3.NodeRegistrationOptions{
+				NodeRegistration: kubeadmapiv1.NodeRegistrationOptions{
 					Taints: []v1.Taint{
 						{Key: "taint1"},
 						{Key: "taint2"},

cmd/kubeadm/app/util/config/joinconfiguration.go

@@ -24,7 +24,7 @@ import (
 	"k8s.io/klog/v2"
 	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
 	kubeadmscheme "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/scheme"
-	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	"k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/validation"
 	"k8s.io/kubernetes/cmd/kubeadm/app/constants"
 	kubeadmutil "k8s.io/kubernetes/cmd/kubeadm/app/util"
@@ -59,7 +59,7 @@ func SetJoinControlPlaneDefaults(cfg *kubeadmapi.JoinControlPlane) error {
 // Then the external, versioned configuration is defaulted and converted to the internal type.
 // Right thereafter, the configuration is defaulted again with dynamic values (like IP addresses of a machine, etc)
 // Lastly, the internal config is validated and returned.
-func LoadOrDefaultJoinConfiguration(cfgPath string, defaultversionedcfg *kubeadmapiv1beta2.JoinConfiguration) (*kubeadmapi.JoinConfiguration, error) {
+func LoadOrDefaultJoinConfiguration(cfgPath string, defaultversionedcfg *kubeadmapiv1.JoinConfiguration) (*kubeadmapi.JoinConfiguration, error) {
 	if cfgPath != "" {
 		// Loads configuration from config file, if provided
 		// Nb. --config overrides command line flags, TODO: fix this
@@ -129,7 +129,7 @@ func documentMapToJoinConfiguration(gvkmap kubeadmapi.DocumentMap, allowDeprecat
 }
 
 // DefaultedJoinConfiguration takes a versioned JoinConfiguration (usually filled in by command line parameters), defaults it, converts it to internal and validates it
-func DefaultedJoinConfiguration(defaultversionedcfg *kubeadmapiv1beta2.JoinConfiguration) (*kubeadmapi.JoinConfiguration, error) {
+func DefaultedJoinConfiguration(defaultversionedcfg *kubeadmapiv1.JoinConfiguration) (*kubeadmapi.JoinConfiguration, error) {
 	internalcfg := &kubeadmapi.JoinConfiguration{}
 
 	// Takes passed flags into account; the defaulting is executed once again enforcing assignment of

cmd/kubeadm/app/util/config/strict/strict_test.go

@@ -24,7 +24,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	kubeproxyconfigv1alpha1 "k8s.io/kube-proxy/config/v1alpha1"
 	kubeletconfigv1beta1 "k8s.io/kubelet/config/v1beta1"
-	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	"k8s.io/kubernetes/cmd/kubeadm/app/constants"
 )
 
@@ -43,13 +43,13 @@ func TestVerifyUnmarshalStrict(t *testing.T) {
 		{
 			fileName:      "invalid_duplicate_field_clustercfg.yaml",
 			kind:          constants.InitConfigurationKind,
-			groupVersion:  kubeadmapiv1beta2.SchemeGroupVersion,
+			groupVersion:  kubeadmapiv1.SchemeGroupVersion,
 			expectedError: true,
 		},
 		{
 			fileName:      "invalid_duplicate_field_joincfg.yaml",
 			kind:          constants.JoinConfigurationKind,
-			groupVersion:  kubeadmapiv1beta2.SchemeGroupVersion,
+			groupVersion:  kubeadmapiv1.SchemeGroupVersion,
 			expectedError: true,
 		},
 		{
@@ -67,19 +67,19 @@ func TestVerifyUnmarshalStrict(t *testing.T) {
 		{
 			fileName:      "invalid_unknown_field_clustercfg.yaml",
 			kind:          constants.ClusterConfigurationKind,
-			groupVersion:  kubeadmapiv1beta2.SchemeGroupVersion,
+			groupVersion:  kubeadmapiv1.SchemeGroupVersion,
 			expectedError: true,
 		},
 		{
 			fileName:      "invalid_unknown_field_initcfg.yaml",
 			kind:          constants.InitConfigurationKind,
-			groupVersion:  kubeadmapiv1beta2.SchemeGroupVersion,
+			groupVersion:  kubeadmapiv1.SchemeGroupVersion,
 			expectedError: true,
 		},
 		{
 			fileName:      "invalid_unknown_field_joincfg.yaml",
 			kind:          constants.JoinConfigurationKind,
-			groupVersion:  kubeadmapiv1beta2.SchemeGroupVersion,
+			groupVersion:  kubeadmapiv1.SchemeGroupVersion,
 			expectedError: true,
 		},
 		{
@@ -104,26 +104,26 @@ func TestVerifyUnmarshalStrict(t *testing.T) {
 		{
 			fileName:      "valid_clustercfg.yaml",
 			kind:          "SomeUnknownKind",
-			groupVersion:  kubeadmapiv1beta2.SchemeGroupVersion,
+			groupVersion:  kubeadmapiv1.SchemeGroupVersion,
 			expectedError: true,
 		},
 		// valid tests
 		{
 			fileName:      "valid_clustercfg.yaml",
 			kind:          constants.ClusterConfigurationKind,
-			groupVersion:  kubeadmapiv1beta2.SchemeGroupVersion,
+			groupVersion:  kubeadmapiv1.SchemeGroupVersion,
 			expectedError: false,
 		},
 		{
 			fileName:      "valid_initcfg.yaml",
 			kind:          constants.InitConfigurationKind,
-			groupVersion:  kubeadmapiv1beta2.SchemeGroupVersion,
+			groupVersion:  kubeadmapiv1.SchemeGroupVersion,
 			expectedError: false,
 		},
 		{
 			fileName:      "valid_joincfg.yaml",
 			kind:          constants.JoinConfigurationKind,
-			groupVersion:  kubeadmapiv1beta2.SchemeGroupVersion,
+			groupVersion:  kubeadmapiv1.SchemeGroupVersion,
 			expectedError: false,
 		},
 		{

cmd/kubeadm/app/util/marshal_test.go

@@ -28,7 +28,7 @@ import (
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/runtime/serializer"
 	kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
-	kubeadmapiv1beta2 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta2"
+	kubeadmapiv1 "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm/v1beta3"
 	"k8s.io/kubernetes/cmd/kubeadm/app/constants"
 )
 
@@ -110,44 +110,44 @@ func TestMarshalUnmarshalYaml(t *testing.T) {
 }
 
 func TestMarshalUnmarshalToYamlForCodecs(t *testing.T) {
-	cfg := &kubeadmapiv1beta2.InitConfiguration{
+	cfg := &kubeadmapiv1.InitConfiguration{
 		TypeMeta: metav1.TypeMeta{
 			Kind:       constants.InitConfigurationKind,
-			APIVersion: kubeadmapiv1beta2.SchemeGroupVersion.String(),
+			APIVersion: kubeadmapiv1.SchemeGroupVersion.String(),
 		},
-		NodeRegistration: kubeadmapiv1beta2.NodeRegistrationOptions{
+		NodeRegistration: kubeadmapiv1.NodeRegistrationOptions{
 			Name:      "testNode",
 			CRISocket: "/var/run/cri.sock",
 		},
-		BootstrapTokens: []kubeadmapiv1beta2.BootstrapToken{
+		BootstrapTokens: []kubeadmapiv1.BootstrapToken{
 			{
-				Token: &kubeadmapiv1beta2.BootstrapTokenString{ID: "abcdef", Secret: "abcdef0123456789"},
+				Token: &kubeadmapiv1.BootstrapTokenString{ID: "abcdef", Secret: "abcdef0123456789"},
 			},
 		},
 		// NOTE: Using MarshalToYamlForCodecs and UnmarshalFromYamlForCodecs for ClusterConfiguration fields here won't work
 		// by design. This is because we have a `json:"-"` annotation in order to avoid struct duplication. See the comment
-		// at the kubeadmapiv1beta2.InitConfiguration definition.
+		// at the kubeadmapiv1.InitConfiguration definition.
 	}
 
-	kubeadmapiv1beta2.SetDefaults_InitConfiguration(cfg)
+	kubeadmapiv1.SetDefaults_InitConfiguration(cfg)
 	scheme := runtime.NewScheme()
-	if err := kubeadmapiv1beta2.AddToScheme(scheme); err != nil {
+	if err := kubeadmapiv1.AddToScheme(scheme); err != nil {
 		t.Fatal(err)
 	}
 	codecs := serializer.NewCodecFactory(scheme)
 
-	bytes, err := MarshalToYamlForCodecs(cfg, kubeadmapiv1beta2.SchemeGroupVersion, codecs)
+	bytes, err := MarshalToYamlForCodecs(cfg, kubeadmapiv1.SchemeGroupVersion, codecs)
 	if err != nil {
 		t.Fatalf("unexpected error marshalling InitConfiguration: %v", err)
 	}
 	t.Logf("\n%s", bytes)
 
-	obj, err := UnmarshalFromYamlForCodecs(bytes, kubeadmapiv1beta2.SchemeGroupVersion, codecs)
+	obj, err := UnmarshalFromYamlForCodecs(bytes, kubeadmapiv1.SchemeGroupVersion, codecs)
 	if err != nil {
 		t.Fatalf("unexpected error unmarshalling InitConfiguration: %v", err)
 	}
 
-	cfg2, ok := obj.(*kubeadmapiv1beta2.InitConfiguration)
+	cfg2, ok := obj.(*kubeadmapiv1.InitConfiguration)
 	if !ok || cfg2 == nil {
 		t.Fatal("did not get InitConfiguration back")
 	}