Merge pull request #12366 from justinsb/zone_autocompletion

Support zone autocompletion

cmd/kops/BUILD.bazel

@@ -68,6 +68,7 @@ go_library(
         "//pkg/assets:go_default_library",
         "//pkg/client/simple:go_default_library",
         "//pkg/cloudinstances:go_default_library",
+        "//pkg/clouds:go_default_library",
         "//pkg/clusteraddons:go_default_library",
         "//pkg/commands:go_default_library",
         "//pkg/commands/commandutils:go_default_library",
@@ -87,6 +88,7 @@ go_library(
         "//pkg/try:go_default_library",
         "//pkg/util/templater:go_default_library",
         "//pkg/validation:go_default_library",
+        "//pkg/zones:go_default_library",
         "//upup/pkg/fi:go_default_library",
         "//upup/pkg/fi/cloudup:go_default_library",
         "//upup/pkg/fi/cloudup/awsup:go_default_library",

cmd/kops/create_cluster.go

@@ -24,6 +24,7 @@ import (
 	"io"
 	"io/ioutil"
 	"os"
+	"sort"
 	"strings"
 
 	"github.com/aws/aws-sdk-go/service/ec2"
@@ -42,12 +43,14 @@ import (
 	kopsutil "k8s.io/kops/pkg/apis/kops/util"
 	"k8s.io/kops/pkg/apis/kops/validation"
 	"k8s.io/kops/pkg/assets"
+	"k8s.io/kops/pkg/clouds"
 	"k8s.io/kops/pkg/clusteraddons"
 	"k8s.io/kops/pkg/commands"
 	"k8s.io/kops/pkg/commands/commandutils"
 	"k8s.io/kops/pkg/featureflag"
 	"k8s.io/kops/pkg/kubeconfig"
 	"k8s.io/kops/pkg/kubemanifest"
+	"k8s.io/kops/pkg/zones"
 	"k8s.io/kops/upup/pkg/fi"
 	"k8s.io/kops/upup/pkg/fi/cloudup"
 	"k8s.io/kops/upup/pkg/fi/utils"
@@ -218,15 +221,24 @@ func NewCmdCreateCluster(f *util.Factory, out io.Writer) *cobra.Command {
 		})
 	}
 
-	cmd.Flags().StringVar(&options.CloudProvider, "cloud", options.CloudProvider, fmt.Sprintf("Cloud provider to use - %s", strings.Join(cloudup.SupportedClouds(), ", ")))
+	var validClouds []string
+	{
+		allClouds := clouds.SupportedClouds()
+		var validClouds []string
+		for _, c := range allClouds {
+			validClouds = append(validClouds, string(c))
+		}
+		sort.Strings(validClouds)
+	}
+	cmd.Flags().StringVar(&options.CloudProvider, "cloud", options.CloudProvider, fmt.Sprintf("Cloud provider to use - %s", strings.Join(validClouds, ", ")))
 	cmd.RegisterFlagCompletionFunc("cloud", func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-		return cloudup.SupportedClouds(), cobra.ShellCompDirectiveNoFileComp
+		return validClouds, cobra.ShellCompDirectiveNoFileComp
 	})
 
 	cmd.Flags().StringSliceVar(&options.Zones, "zones", options.Zones, "Zones in which to run the cluster")
-	cmd.RegisterFlagCompletionFunc("zones", completeZone)
+	cmd.RegisterFlagCompletionFunc("zones", completeZone(options))
 	cmd.Flags().StringSliceVar(&options.MasterZones, "master-zones", options.MasterZones, "Zones in which to run masters (must be an odd number)")
-	cmd.RegisterFlagCompletionFunc("master-zones", completeZone)
+	cmd.RegisterFlagCompletionFunc("master-zones", completeZone(options))
 
 	if featureflag.ClusterAddons.Enabled() {
 		cmd.Flags().StringSliceVar(&options.AddonPaths, "add", options.AddonPaths, "Paths to addons we should add to the cluster")
@@ -829,9 +841,29 @@ func loadSSHPublicKeys(sshPublicKey string) (map[string][]byte, error) {
 	return sshPublicKeys, nil
 }
 
-func completeZone(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
+func completeZone(options *CreateClusterOptions) func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-	// TODO call into cloud provider(s) to get list of valid zones
+	return func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {
-	return nil, cobra.ShellCompDirectiveNoFileComp
+		var allClouds []api.CloudProviderID
+		if options.CloudProvider != "" {
+			allClouds = []api.CloudProviderID{api.CloudProviderID(options.CloudProvider)}
+		} else {
+			allClouds = clouds.SupportedClouds()
+		}
+
+		var allZones []string
+		for _, c := range allClouds {
+			zones := zones.WellKnownZonesForCloud(c)
+			for _, z := range zones {
+				if options.CloudProvider == "" {
+					allZones = append(allZones, z+"\t"+string(c))
+				} else {
+					allZones = append(allZones, z)
+				}
+			}
+		}
+		sort.Strings(allZones)
+		return allZones, cobra.ShellCompDirectiveNoFileComp
+	}
 }
 
 func completeKubernetesVersion(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) {

docs/cli/kops_create_cluster.md

@@ -73,7 +73,7 @@ kops create cluster [CLUSTER] [flags]
       --authorization string             Authorization mode: AlwaysAllow or RBAC (default "RBAC")
       --bastion                          Enable a bastion instance group. Only applies to private topology.
       --channel string                   Channel for default versions and configuration to use (default "stable")
-      --cloud string                     Cloud provider to use - aws, digitalocean, openstack
+      --cloud string                     Cloud provider to use - 
       --cloud-labels string              A list of key/value pairs used to tag all instance groups (for example "Owner=John Doe,Team=Some Team").
       --container-runtime string         Container runtime to use: containerd, docker
       --disable-subnet-tags              Disable automatic subnet tagging

pkg/clouds/BUILD.bazel

@@ -0,0 +1,12 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["supported.go"],
+    importpath = "k8s.io/kops/pkg/clouds",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//pkg/apis/kops:go_default_library",
+        "//pkg/featureflag:go_default_library",
+    ],
+)

pkg/clouds/supported.go

@@ -0,0 +1,41 @@
+/*
+Copyright 2021 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 clouds
+
+import (
+	"k8s.io/kops/pkg/apis/kops"
+	"k8s.io/kops/pkg/featureflag"
+)
+
+func SupportedClouds() []kops.CloudProviderID {
+	clouds := []kops.CloudProviderID{
+		kops.CloudProviderAWS,
+		kops.CloudProviderDO,
+		kops.CloudProviderOpenstack,
+	}
+	if featureflag.AlphaAllowALI.Enabled() {
+		clouds = append(clouds, kops.CloudProviderALI)
+	}
+	if featureflag.Azure.Enabled() {
+		clouds = append(clouds, kops.CloudProviderAzure)
+	}
+	if featureflag.AlphaAllowGCE.Enabled() {
+		clouds = append(clouds, kops.CloudProviderGCE)
+	}
+
+	return clouds
+}

pkg/zones/BUILD.bazel

@@ -0,0 +1,13 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "go_default_library",
+    srcs = ["wellknown.go"],
+    importpath = "k8s.io/kops/pkg/zones",
+    visibility = ["//visibility:public"],
+    deps = [
+        "//pkg/apis/kops:go_default_library",
+        "//pkg/clouds:go_default_library",
+        "//vendor/k8s.io/klog/v2:go_default_library",
+    ],
+)

pkg/zones/wellknown.go

@@ -0,0 +1,435 @@
+/*
+Copyright 2021 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 zones
+
+import (
+	"k8s.io/klog/v2"
+	"k8s.io/kops/pkg/apis/kops"
+	"k8s.io/kops/pkg/clouds"
+)
+
+// These lists allows us to infer from certain well-known zones to a cloud
+// Note it is safe to "overmap" zones that don't exist: we'll check later if the zones actually exist
+
+var awsZones = []string{
+	"us-east-1a",
+	"us-east-1b",
+	"us-east-1c",
+	"us-east-1d",
+	"us-east-1e",
+	"us-east-1f",
+
+	"us-east-2a",
+	"us-east-2b",
+	"us-east-2c",
+	"us-east-2d",
+	"us-east-2e",
+	"us-east-2f",
+
+	"us-west-1a",
+	"us-west-1b",
+	"us-west-1c",
+	"us-west-1d",
+	"us-west-1e",
+	"us-west-1f",
+
+	"us-west-2a",
+	"us-west-2b",
+	"us-west-2c",
+	"us-west-2d",
+	"us-west-2e",
+	"us-west-2f",
+
+	"ca-central-1a",
+	"ca-central-1b",
+	"ca-central-1c",
+	"ca-central-1d",
+
+	"eu-north-1a",
+	"eu-north-1b",
+	"eu-north-1c",
+
+	"eu-west-1a",
+	"eu-west-1b",
+	"eu-west-1c",
+	"eu-west-1d",
+	"eu-west-1e",
+
+	"eu-west-2a",
+	"eu-west-2b",
+	"eu-west-2c",
+
+	"eu-west-3a",
+	"eu-west-3b",
+	"eu-west-3c",
+
+	"eu-central-1a",
+	"eu-central-1b",
+	"eu-central-1c",
+	"eu-central-1d",
+	"eu-central-1e",
+
+	"ap-south-1a",
+	"ap-south-1b",
+	"ap-south-1c",
+	"ap-south-1d",
+	"ap-south-1e",
+
+	"ap-southeast-1a",
+	"ap-southeast-1b",
+	"ap-southeast-1c",
+	"ap-southeast-1d",
+	"ap-southeast-1e",
+
+	"ap-southeast-2a",
+	"ap-southeast-2b",
+	"ap-southeast-2c",
+	"ap-southeast-2d",
+	"ap-southeast-2e",
+
+	"ap-northeast-1a",
+	"ap-northeast-1b",
+	"ap-northeast-1c",
+	"ap-northeast-1d",
+	"ap-northeast-1e",
+
+	"ap-northeast-2a",
+	"ap-northeast-2b",
+	"ap-northeast-2c",
+	"ap-northeast-2d",
+	"ap-northeast-2e",
+
+	"ap-northeast-3a",
+	"ap-northeast-3b",
+	"ap-northeast-3c",
+	"ap-northeast-3d",
+	"ap-northeast-3e",
+
+	"ap-east-1a",
+	"ap-east-1b",
+	"ap-east-1c",
+	"ap-east-1d",
+	"ap-east-1e",
+
+	"sa-east-1a",
+	"sa-east-1b",
+	"sa-east-1c",
+	"sa-east-1d",
+	"sa-east-1e",
+
+	"cn-north-1a",
+	"cn-north-1b",
+
+	"cn-northwest-1a",
+	"cn-northwest-1b",
+	"cn-northwest-1c",
+
+	"me-south-1a",
+	"me-south-1b",
+	"me-south-1c",
+
+	"us-gov-east-1a",
+	"us-gov-east-1b",
+	"us-gov-east-1c",
+
+	"us-gov-west-1a",
+	"us-gov-west-1b",
+	"us-gov-west-1c",
+
+	"af-south-1a",
+	"af-south-1b",
+	"af-south-1c",
+
+	"eu-south-1a",
+	"eu-south-1b",
+	"eu-south-1c",
+}
+
+var gceZones = []string{
+	"asia-east1-a",
+	"asia-east1-b",
+	"asia-east1-c",
+	"asia-east1-d",
+
+	"asia-east2-a",
+	"asia-east2-b",
+	"asia-east2-c",
+
+	"asia-northeast1-a",
+	"asia-northeast1-b",
+	"asia-northeast1-c",
+	"asia-northeast1-d",
+
+	"asia-northeast2-a",
+	"asia-northeast2-b",
+	"asia-northeast2-c",
+
+	"asia-northeast3-a",
+	"asia-northeast3-b",
+	"asia-northeast3-c",
+
+	"asia-south1-a",
+	"asia-south1-b",
+	"asia-south1-c",
+
+	"asia-southeast1-a",
+	"asia-southeast1-b",
+
+	"asia-southeast2-a",
+	"asia-southeast2-b",
+	"asia-southeast2-c",
+
+	"australia-southeast1-a",
+	"australia-southeast1-b",
+	"australia-southeast1-c",
+
+	"europe-north1-a",
+	"europe-north1-b",
+	"europe-north1-c",
+
+	"europe-west1-a",
+	"europe-west1-b",
+	"europe-west1-c",
+	"europe-west1-d",
+	"europe-west1-e",
+
+	"europe-west2-a",
+	"europe-west2-b",
+	"europe-west2-c",
+
+	"europe-west3-a",
+	"europe-west3-b",
+	"europe-west3-c",
+
+	"europe-west4-a",
+	"europe-west4-b",
+	"europe-west4-c",
+
+	"europe-west6-a",
+	"europe-west6-b",
+	"europe-west6-c",
+
+	"us-central1-a",
+	"us-central1-b",
+	"us-central1-c",
+	"us-central1-d",
+	"us-central1-e",
+	"us-central1-f",
+	"us-central1-g",
+	"us-central1-h",
+
+	"us-east1-a",
+	"us-east1-b",
+	"us-east1-c",
+	"us-east1-d",
+
+	"us-east4-a",
+	"us-east4-b",
+	"us-east4-c",
+
+	"us-west1-a",
+	"us-west1-b",
+	"us-west1-c",
+	"us-west1-d",
+
+	"us-west2-a",
+	"us-west2-b",
+	"us-west2-c",
+
+	"us-west3-a",
+	"us-west3-b",
+	"us-west3-c",
+
+	"us-west4-a",
+	"us-west4-b",
+	"us-west4-c",
+
+	"northamerica-northeast1-a",
+	"northamerica-northeast1-b",
+	"northamerica-northeast1-c",
+
+	"southamerica-east1-a",
+	"southamerica-east1-b",
+	"southamerica-east1-c",
+}
+
+var doZones = []string{
+	"nyc1",
+	"nyc2",
+	"nyc3",
+
+	"sfo1",
+	"sfo2",
+	"sfo3",
+
+	"ams2",
+	"ams3",
+
+	"tor1",
+
+	"sgp1",
+
+	"lon1",
+
+	"fra1",
+
+	"blr1",
+}
+
+var aliZones = []string{
+	"cn-qingdao-b",
+	"cn-qingdao-c",
+
+	"cn-beijing-a",
+	"cn-beijing-b",
+	"cn-beijing-c",
+	"cn-beijing-d",
+	"cn-beijing-e",
+
+	"cn-zhangjiakou-a",
+
+	"cn-huhehaote-a",
+
+	"cn-hangzhou-b",
+	"cn-hangzhou-c",
+	"cn-hangzhou-d",
+	"cn-hangzhou-e",
+	"cn-hangzhou-f",
+	"cn-hangzhou-g",
+
+	"cn-shanghai-a",
+	"cn-shanghai-b",
+	"cn-shanghai-c",
+	"cn-shanghai-d",
+
+	"cn-shenzhen-a",
+	"cn-shenzhen-b",
+	"cn-shenzhen-c",
+
+	"cn-hongkong-a",
+	"cn-hongkong-b",
+	"cn-hongkong-c",
+}
+
+var azureZones = []string{
+	"asia",
+	"asiapacific",
+	"australia",
+	"australiacentral",
+	"australiacentral2",
+	"australiaeast",
+	"australiasoutheast",
+	"brazil",
+	"brazilsouth",
+	"brazilsoutheast",
+	"canada",
+	"canadacentral",
+	"canadaeast",
+	"centralindia",
+	"centralus",
+	"centraluseuap",
+	"centralusstage",
+	"eastasia",
+	"eastasiastage",
+	"eastus",
+	"eastus2",
+	"eastus2euap",
+	"eastus2stage",
+	"eastusstage",
+	"europe",
+	"francecentral",
+	"francesouth",
+	"germanynorth",
+	"germanywestcentral",
+	"global",
+	"india",
+	"japan",
+	"japaneast",
+	"japanwest",
+	"koreacentral",
+	"koreasouth",
+	"northcentralus",
+	"northcentralusstage",
+	"northeurope",
+	"norwayeast",
+	"norwaywest",
+	"southafricanorth",
+	"southafricawest",
+	"southcentralus",
+	"southcentralusstage",
+	"southeastasia",
+	"southeastasiastage",
+	"southindia",
+	"switzerlandnorth",
+	"switzerlandwest",
+	"uaecentral",
+	"uaenorth",
+	"uk",
+	"uksouth",
+	"ukwest",
+	"unitedstates",
+	"westcentralus",
+	"westeurope",
+	"westindia",
+	"westus",
+	"westus2",
+	"westus2stage",
+	"westusstage",
+}
+
+// GuessCloudForZone tries to infer the cloudprovider from the zone name
+// Ali has the same zoneNames as AWS in the regions outside China, so if use AliCloud to install k8s in the regions outside China,
+// the users need to provide parameter "--cloud". But the regions inside China can be easily identified.
+func GuessCloudForZone(zone string) (kops.CloudProviderID, bool) {
+	providers := clouds.SupportedClouds()
+	var matches []kops.CloudProviderID
+	for _, provider := range providers {
+		zones := WellKnownZonesForCloud(provider)
+		for _, z := range zones {
+			if z == zone {
+				matches = append(matches, provider)
+			}
+		}
+	}
+
+	if len(matches) == 0 {
+		return "", false
+	}
+	if len(matches) > 1 {
+		klog.Warningf("found multiple providers for zone %q, must pass --cloud", zone)
+		return "", false
+	}
+	return matches[0], true
+}
+
+func WellKnownZonesForCloud(matchCloud kops.CloudProviderID) []string {
+	switch matchCloud {
+	case kops.CloudProviderALI:
+		return aliZones
+	case kops.CloudProviderAWS:
+		return awsZones
+	case kops.CloudProviderAzure:
+		return azureZones
+	case kops.CloudProviderDO:
+		return doZones
+	case kops.CloudProviderGCE:
+		return gceZones
+
+	default:
+		return nil
+	}
+}

upup/pkg/fi/cloud.go

@@ -81,372 +81,3 @@ type ApiIngressStatus struct {
 	// +optional
 	Hostname string `json:"hostname,omitempty" protobuf:"bytes,2,opt,name=hostname"`
 }
-
-// zonesToCloud allows us to infer from certain well-known zones to a cloud
-// Note it is safe to "overmap" zones that don't exist: we'll check later if the zones actually exist
-var zonesToCloud = map[string]kops.CloudProviderID{
-	"us-east-1a": kops.CloudProviderAWS,
-	"us-east-1b": kops.CloudProviderAWS,
-	"us-east-1c": kops.CloudProviderAWS,
-	"us-east-1d": kops.CloudProviderAWS,
-	"us-east-1e": kops.CloudProviderAWS,
-	"us-east-1f": kops.CloudProviderAWS,
-
-	"us-east-2a": kops.CloudProviderAWS,
-	"us-east-2b": kops.CloudProviderAWS,
-	"us-east-2c": kops.CloudProviderAWS,
-	"us-east-2d": kops.CloudProviderAWS,
-	"us-east-2e": kops.CloudProviderAWS,
-	"us-east-2f": kops.CloudProviderAWS,
-
-	"us-west-1a": kops.CloudProviderAWS,
-	"us-west-1b": kops.CloudProviderAWS,
-	"us-west-1c": kops.CloudProviderAWS,
-	"us-west-1d": kops.CloudProviderAWS,
-	"us-west-1e": kops.CloudProviderAWS,
-	"us-west-1f": kops.CloudProviderAWS,
-
-	"us-west-2a": kops.CloudProviderAWS,
-	"us-west-2b": kops.CloudProviderAWS,
-	"us-west-2c": kops.CloudProviderAWS,
-	"us-west-2d": kops.CloudProviderAWS,
-	"us-west-2e": kops.CloudProviderAWS,
-	"us-west-2f": kops.CloudProviderAWS,
-
-	"ca-central-1a": kops.CloudProviderAWS,
-	"ca-central-1b": kops.CloudProviderAWS,
-	"ca-central-1c": kops.CloudProviderAWS,
-	"ca-central-1d": kops.CloudProviderAWS,
-
-	"eu-north-1a": kops.CloudProviderAWS,
-	"eu-north-1b": kops.CloudProviderAWS,
-	"eu-north-1c": kops.CloudProviderAWS,
-
-	"eu-west-1a": kops.CloudProviderAWS,
-	"eu-west-1b": kops.CloudProviderAWS,
-	"eu-west-1c": kops.CloudProviderAWS,
-	"eu-west-1d": kops.CloudProviderAWS,
-	"eu-west-1e": kops.CloudProviderAWS,
-
-	"eu-west-2a": kops.CloudProviderAWS,
-	"eu-west-2b": kops.CloudProviderAWS,
-	"eu-west-2c": kops.CloudProviderAWS,
-
-	"eu-west-3a": kops.CloudProviderAWS,
-	"eu-west-3b": kops.CloudProviderAWS,
-	"eu-west-3c": kops.CloudProviderAWS,
-
-	"eu-central-1a": kops.CloudProviderAWS,
-	"eu-central-1b": kops.CloudProviderAWS,
-	"eu-central-1c": kops.CloudProviderAWS,
-	"eu-central-1d": kops.CloudProviderAWS,
-	"eu-central-1e": kops.CloudProviderAWS,
-
-	"ap-south-1a": kops.CloudProviderAWS,
-	"ap-south-1b": kops.CloudProviderAWS,
-	"ap-south-1c": kops.CloudProviderAWS,
-	"ap-south-1d": kops.CloudProviderAWS,
-	"ap-south-1e": kops.CloudProviderAWS,
-
-	"ap-southeast-1a": kops.CloudProviderAWS,
-	"ap-southeast-1b": kops.CloudProviderAWS,
-	"ap-southeast-1c": kops.CloudProviderAWS,
-	"ap-southeast-1d": kops.CloudProviderAWS,
-	"ap-southeast-1e": kops.CloudProviderAWS,
-
-	"ap-southeast-2a": kops.CloudProviderAWS,
-	"ap-southeast-2b": kops.CloudProviderAWS,
-	"ap-southeast-2c": kops.CloudProviderAWS,
-	"ap-southeast-2d": kops.CloudProviderAWS,
-	"ap-southeast-2e": kops.CloudProviderAWS,
-
-	"ap-northeast-1a": kops.CloudProviderAWS,
-	"ap-northeast-1b": kops.CloudProviderAWS,
-	"ap-northeast-1c": kops.CloudProviderAWS,
-	"ap-northeast-1d": kops.CloudProviderAWS,
-	"ap-northeast-1e": kops.CloudProviderAWS,
-
-	"ap-northeast-2a": kops.CloudProviderAWS,
-	"ap-northeast-2b": kops.CloudProviderAWS,
-	"ap-northeast-2c": kops.CloudProviderAWS,
-	"ap-northeast-2d": kops.CloudProviderAWS,
-	"ap-northeast-2e": kops.CloudProviderAWS,
-
-	"ap-northeast-3a": kops.CloudProviderAWS,
-	"ap-northeast-3b": kops.CloudProviderAWS,
-	"ap-northeast-3c": kops.CloudProviderAWS,
-	"ap-northeast-3d": kops.CloudProviderAWS,
-	"ap-northeast-3e": kops.CloudProviderAWS,
-
-	"ap-east-1a": kops.CloudProviderAWS,
-	"ap-east-1b": kops.CloudProviderAWS,
-	"ap-east-1c": kops.CloudProviderAWS,
-	"ap-east-1d": kops.CloudProviderAWS,
-	"ap-east-1e": kops.CloudProviderAWS,
-
-	"sa-east-1a": kops.CloudProviderAWS,
-	"sa-east-1b": kops.CloudProviderAWS,
-	"sa-east-1c": kops.CloudProviderAWS,
-	"sa-east-1d": kops.CloudProviderAWS,
-	"sa-east-1e": kops.CloudProviderAWS,
-
-	"cn-north-1a": kops.CloudProviderAWS,
-	"cn-north-1b": kops.CloudProviderAWS,
-
-	"cn-northwest-1a": kops.CloudProviderAWS,
-	"cn-northwest-1b": kops.CloudProviderAWS,
-	"cn-northwest-1c": kops.CloudProviderAWS,
-
-	"me-south-1a": kops.CloudProviderAWS,
-	"me-south-1b": kops.CloudProviderAWS,
-	"me-south-1c": kops.CloudProviderAWS,
-
-	"us-gov-east-1a": kops.CloudProviderAWS,
-	"us-gov-east-1b": kops.CloudProviderAWS,
-	"us-gov-east-1c": kops.CloudProviderAWS,
-
-	"us-gov-west-1a": kops.CloudProviderAWS,
-	"us-gov-west-1b": kops.CloudProviderAWS,
-	"us-gov-west-1c": kops.CloudProviderAWS,
-
-	"af-south-1a": kops.CloudProviderAWS,
-	"af-south-1b": kops.CloudProviderAWS,
-	"af-south-1c": kops.CloudProviderAWS,
-
-	"eu-south-1a": kops.CloudProviderAWS,
-	"eu-south-1b": kops.CloudProviderAWS,
-	"eu-south-1c": kops.CloudProviderAWS,
-
-	// GCE
-	"asia-east1-a": kops.CloudProviderGCE,
-	"asia-east1-b": kops.CloudProviderGCE,
-	"asia-east1-c": kops.CloudProviderGCE,
-	"asia-east1-d": kops.CloudProviderGCE,
-
-	"asia-east2-a": kops.CloudProviderGCE,
-	"asia-east2-b": kops.CloudProviderGCE,
-	"asia-east2-c": kops.CloudProviderGCE,
-
-	"asia-northeast1-a": kops.CloudProviderGCE,
-	"asia-northeast1-b": kops.CloudProviderGCE,
-	"asia-northeast1-c": kops.CloudProviderGCE,
-	"asia-northeast1-d": kops.CloudProviderGCE,
-
-	"asia-northeast2-a": kops.CloudProviderGCE,
-	"asia-northeast2-b": kops.CloudProviderGCE,
-	"asia-northeast2-c": kops.CloudProviderGCE,
-
-	"asia-northeast3-a": kops.CloudProviderGCE,
-	"asia-northeast3-b": kops.CloudProviderGCE,
-	"asia-northeast3-c": kops.CloudProviderGCE,
-
-	"asia-south1-a": kops.CloudProviderGCE,
-	"asia-south1-b": kops.CloudProviderGCE,
-	"asia-south1-c": kops.CloudProviderGCE,
-
-	"asia-southeast1-a": kops.CloudProviderGCE,
-	"asia-southeast1-b": kops.CloudProviderGCE,
-
-	"asia-southeast2-a": kops.CloudProviderGCE,
-	"asia-southeast2-b": kops.CloudProviderGCE,
-	"asia-southeast2-c": kops.CloudProviderGCE,
-
-	"australia-southeast1-a": kops.CloudProviderGCE,
-	"australia-southeast1-b": kops.CloudProviderGCE,
-	"australia-southeast1-c": kops.CloudProviderGCE,
-
-	"europe-north1-a": kops.CloudProviderGCE,
-	"europe-north1-b": kops.CloudProviderGCE,
-	"europe-north1-c": kops.CloudProviderGCE,
-
-	"europe-west1-a": kops.CloudProviderGCE,
-	"europe-west1-b": kops.CloudProviderGCE,
-	"europe-west1-c": kops.CloudProviderGCE,
-	"europe-west1-d": kops.CloudProviderGCE,
-	"europe-west1-e": kops.CloudProviderGCE,
-
-	"europe-west2-a": kops.CloudProviderGCE,
-	"europe-west2-b": kops.CloudProviderGCE,
-	"europe-west2-c": kops.CloudProviderGCE,
-
-	"europe-west3-a": kops.CloudProviderGCE,
-	"europe-west3-b": kops.CloudProviderGCE,
-	"europe-west3-c": kops.CloudProviderGCE,
-
-	"europe-west4-a": kops.CloudProviderGCE,
-	"europe-west4-b": kops.CloudProviderGCE,
-	"europe-west4-c": kops.CloudProviderGCE,
-
-	"europe-west6-a": kops.CloudProviderGCE,
-	"europe-west6-b": kops.CloudProviderGCE,
-	"europe-west6-c": kops.CloudProviderGCE,
-
-	"us-central1-a": kops.CloudProviderGCE,
-	"us-central1-b": kops.CloudProviderGCE,
-	"us-central1-c": kops.CloudProviderGCE,
-	"us-central1-d": kops.CloudProviderGCE,
-	"us-central1-e": kops.CloudProviderGCE,
-	"us-central1-f": kops.CloudProviderGCE,
-	"us-central1-g": kops.CloudProviderGCE,
-	"us-central1-h": kops.CloudProviderGCE,
-
-	"us-east1-a": kops.CloudProviderGCE,
-	"us-east1-b": kops.CloudProviderGCE,
-	"us-east1-c": kops.CloudProviderGCE,
-	"us-east1-d": kops.CloudProviderGCE,
-
-	"us-east4-a": kops.CloudProviderGCE,
-	"us-east4-b": kops.CloudProviderGCE,
-	"us-east4-c": kops.CloudProviderGCE,
-
-	"us-west1-a": kops.CloudProviderGCE,
-	"us-west1-b": kops.CloudProviderGCE,
-	"us-west1-c": kops.CloudProviderGCE,
-	"us-west1-d": kops.CloudProviderGCE,
-
-	"us-west2-a": kops.CloudProviderGCE,
-	"us-west2-b": kops.CloudProviderGCE,
-	"us-west2-c": kops.CloudProviderGCE,
-
-	"us-west3-a": kops.CloudProviderGCE,
-	"us-west3-b": kops.CloudProviderGCE,
-	"us-west3-c": kops.CloudProviderGCE,
-
-	"us-west4-a": kops.CloudProviderGCE,
-	"us-west4-b": kops.CloudProviderGCE,
-	"us-west4-c": kops.CloudProviderGCE,
-
-	"northamerica-northeast1-a": kops.CloudProviderGCE,
-	"northamerica-northeast1-b": kops.CloudProviderGCE,
-	"northamerica-northeast1-c": kops.CloudProviderGCE,
-
-	"southamerica-east1-a": kops.CloudProviderGCE,
-	"southamerica-east1-b": kops.CloudProviderGCE,
-	"southamerica-east1-c": kops.CloudProviderGCE,
-
-	"nyc1": kops.CloudProviderDO,
-	"nyc2": kops.CloudProviderDO,
-	"nyc3": kops.CloudProviderDO,
-
-	"sfo1": kops.CloudProviderDO,
-	"sfo2": kops.CloudProviderDO,
-	"sfo3": kops.CloudProviderDO,
-
-	"ams2": kops.CloudProviderDO,
-	"ams3": kops.CloudProviderDO,
-
-	"tor1": kops.CloudProviderDO,
-
-	"sgp1": kops.CloudProviderDO,
-
-	"lon1": kops.CloudProviderDO,
-
-	"fra1": kops.CloudProviderDO,
-
-	"blr1": kops.CloudProviderDO,
-
-	"cn-qingdao-b": kops.CloudProviderALI,
-	"cn-qingdao-c": kops.CloudProviderALI,
-
-	"cn-beijing-a": kops.CloudProviderALI,
-	"cn-beijing-b": kops.CloudProviderALI,
-	"cn-beijing-c": kops.CloudProviderALI,
-	"cn-beijing-d": kops.CloudProviderALI,
-	"cn-beijing-e": kops.CloudProviderALI,
-
-	"cn-zhangjiakou-a": kops.CloudProviderALI,
-
-	"cn-huhehaote-a": kops.CloudProviderALI,
-
-	"cn-hangzhou-b": kops.CloudProviderALI,
-	"cn-hangzhou-c": kops.CloudProviderALI,
-	"cn-hangzhou-d": kops.CloudProviderALI,
-	"cn-hangzhou-e": kops.CloudProviderALI,
-	"cn-hangzhou-f": kops.CloudProviderALI,
-	"cn-hangzhou-g": kops.CloudProviderALI,
-
-	"cn-shanghai-a": kops.CloudProviderALI,
-	"cn-shanghai-b": kops.CloudProviderALI,
-	"cn-shanghai-c": kops.CloudProviderALI,
-	"cn-shanghai-d": kops.CloudProviderALI,
-
-	"cn-shenzhen-a": kops.CloudProviderALI,
-	"cn-shenzhen-b": kops.CloudProviderALI,
-	"cn-shenzhen-c": kops.CloudProviderALI,
-
-	"cn-hongkong-a": kops.CloudProviderALI,
-	"cn-hongkong-b": kops.CloudProviderALI,
-	"cn-hongkong-c": kops.CloudProviderALI,
-
-	"asia":                kops.CloudProviderAzure,
-	"asiapacific":         kops.CloudProviderAzure,
-	"australia":           kops.CloudProviderAzure,
-	"australiacentral":    kops.CloudProviderAzure,
-	"australiacentral2":   kops.CloudProviderAzure,
-	"australiaeast":       kops.CloudProviderAzure,
-	"australiasoutheast":  kops.CloudProviderAzure,
-	"brazil":              kops.CloudProviderAzure,
-	"brazilsouth":         kops.CloudProviderAzure,
-	"brazilsoutheast":     kops.CloudProviderAzure,
-	"canada":              kops.CloudProviderAzure,
-	"canadacentral":       kops.CloudProviderAzure,
-	"canadaeast":          kops.CloudProviderAzure,
-	"centralindia":        kops.CloudProviderAzure,
-	"centralus":           kops.CloudProviderAzure,
-	"centraluseuap":       kops.CloudProviderAzure,
-	"centralusstage":      kops.CloudProviderAzure,
-	"eastasia":            kops.CloudProviderAzure,
-	"eastasiastage":       kops.CloudProviderAzure,
-	"eastus":              kops.CloudProviderAzure,
-	"eastus2":             kops.CloudProviderAzure,
-	"eastus2euap":         kops.CloudProviderAzure,
-	"eastus2stage":        kops.CloudProviderAzure,
-	"eastusstage":         kops.CloudProviderAzure,
-	"europe":              kops.CloudProviderAzure,
-	"francecentral":       kops.CloudProviderAzure,
-	"francesouth":         kops.CloudProviderAzure,
-	"germanynorth":        kops.CloudProviderAzure,
-	"germanywestcentral":  kops.CloudProviderAzure,
-	"global":              kops.CloudProviderAzure,
-	"india":               kops.CloudProviderAzure,
-	"japan":               kops.CloudProviderAzure,
-	"japaneast":           kops.CloudProviderAzure,
-	"japanwest":           kops.CloudProviderAzure,
-	"koreacentral":        kops.CloudProviderAzure,
-	"koreasouth":          kops.CloudProviderAzure,
-	"northcentralus":      kops.CloudProviderAzure,
-	"northcentralusstage": kops.CloudProviderAzure,
-	"northeurope":         kops.CloudProviderAzure,
-	"norwayeast":          kops.CloudProviderAzure,
-	"norwaywest":          kops.CloudProviderAzure,
-	"southafricanorth":    kops.CloudProviderAzure,
-	"southafricawest":     kops.CloudProviderAzure,
-	"southcentralus":      kops.CloudProviderAzure,
-	"southcentralusstage": kops.CloudProviderAzure,
-	"southeastasia":       kops.CloudProviderAzure,
-	"southeastasiastage":  kops.CloudProviderAzure,
-	"southindia":          kops.CloudProviderAzure,
-	"switzerlandnorth":    kops.CloudProviderAzure,
-	"switzerlandwest":     kops.CloudProviderAzure,
-	"uaecentral":          kops.CloudProviderAzure,
-	"uaenorth":            kops.CloudProviderAzure,
-	"uk":                  kops.CloudProviderAzure,
-	"uksouth":             kops.CloudProviderAzure,
-	"ukwest":              kops.CloudProviderAzure,
-	"unitedstates":        kops.CloudProviderAzure,
-	"westcentralus":       kops.CloudProviderAzure,
-	"westeurope":          kops.CloudProviderAzure,
-	"westindia":           kops.CloudProviderAzure,
-	"westus":              kops.CloudProviderAzure,
-	"westus2":             kops.CloudProviderAzure,
-	"westus2stage":        kops.CloudProviderAzure,
-	"westusstage":         kops.CloudProviderAzure,
-}
-
-// GuessCloudForZone tries to infer the cloudprovider from the zone name
-// Ali has the same zoneNames as AWS in the regions outside China, so if use AliCloud to install k8s in the regions outside China,
-// the users need to provide parameter "--cloud". But the regions inside China can be easily identified.
-func GuessCloudForZone(zone string) (kops.CloudProviderID, bool) {
-	c, found := zonesToCloud[zone]
-	return c, found
-}

upup/pkg/fi/cloudup/BUILD.bazel

@@ -55,6 +55,7 @@ go_library(
         "//pkg/templates:go_default_library",
         "//pkg/util/subnet:go_default_library",
         "//pkg/wellknownports:go_default_library",
+        "//pkg/zones:go_default_library",
         "//upup/models:go_default_library",
         "//upup/pkg/fi:go_default_library",
         "//upup/pkg/fi/cloudup/aliup:go_default_library",

upup/pkg/fi/cloudup/new_cluster.go

@@ -33,6 +33,7 @@ import (
 	"k8s.io/kops/pkg/client/simple"
 	"k8s.io/kops/pkg/dns"
 	"k8s.io/kops/pkg/featureflag"
+	"k8s.io/kops/pkg/zones"
 	"k8s.io/kops/upup/pkg/fi"
 	"k8s.io/kops/upup/pkg/fi/cloudup/aliup"
 	"k8s.io/kops/upup/pkg/fi/cloudup/awsup"
@@ -236,7 +237,7 @@ func NewCluster(opt *NewClusterOptions, clientset simple.Clientset) (*NewCluster
 	cluster.Spec.CloudProvider = opt.CloudProvider
 	if cluster.Spec.CloudProvider == "" {
 		for _, zone := range allZones.List() {
-			cloud, known := fi.GuessCloudForZone(zone)
+			cloud, known := zones.GuessCloudForZone(zone)
 			if known {
 				klog.Infof("Inferred %q cloud provider from zone %q", cloud, zone)
 				cluster.Spec.CloudProvider = string(cloud)

upup/pkg/fi/cloudup/utils.go

@@ -18,14 +18,12 @@ package cloudup
 
 import (
 	"fmt"
-	"sort"
 	"strings"
 
 	"k8s.io/klog/v2"
 	"k8s.io/kops/dnsprovider/pkg/dnsprovider"
 	"k8s.io/kops/dnsprovider/pkg/dnsprovider/providers/aws/route53"
 	"k8s.io/kops/pkg/apis/kops"
-	"k8s.io/kops/pkg/featureflag"
 	"k8s.io/kops/upup/pkg/fi"
 	"k8s.io/kops/upup/pkg/fi/cloudup/aliup"
 	"k8s.io/kops/upup/pkg/fi/cloudup/awsup"
@@ -170,26 +168,6 @@ func BuildCloud(cluster *kops.Cluster) (fi.Cloud, error) {
 	return cloud, nil
 }
 
-func SupportedClouds() []string {
-	clouds := []string{
-		string(kops.CloudProviderAWS),
-		string(kops.CloudProviderDO),
-		string(kops.CloudProviderOpenstack),
-	}
-	if featureflag.AlphaAllowALI.Enabled() {
-		clouds = append(clouds, string(kops.CloudProviderALI))
-	}
-	if featureflag.Azure.Enabled() {
-		clouds = append(clouds, string(kops.CloudProviderAzure))
-	}
-	if featureflag.AlphaAllowGCE.Enabled() {
-		clouds = append(clouds, string(kops.CloudProviderGCE))
-	}
-
-	sort.Strings(clouds)
-	return clouds
-}
-
 func FindDNSHostedZone(dns dnsprovider.Interface, clusterDNSName string, dnsType kops.DNSType) (string, error) {
 	klog.V(2).Infof("Querying for all DNS zones to find match for %q", clusterDNSName)