diff --git a/cmd/kops/BUILD.bazel b/cmd/kops/BUILD.bazel index 38c421aeb3..4b11e336a5 100644 --- a/cmd/kops/BUILD.bazel +++ b/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", diff --git a/cmd/kops/create_cluster.go b/cmd/kops/create_cluster.go index 13315c90f7..a76cd9ddc7 100644 --- a/cmd/kops/create_cluster.go +++ b/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) { - // TODO call into cloud provider(s) to get list of valid zones - return nil, cobra.ShellCompDirectiveNoFileComp +func completeZone(options *CreateClusterOptions) func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { + return func(cmd *cobra.Command, args []string, toComplete string) ([]string, cobra.ShellCompDirective) { + 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) { diff --git a/docs/cli/kops_create_cluster.md b/docs/cli/kops_create_cluster.md index 47d85e11c8..ec64d462ce 100644 --- a/docs/cli/kops_create_cluster.md +++ b/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 diff --git a/pkg/clouds/BUILD.bazel b/pkg/clouds/BUILD.bazel new file mode 100644 index 0000000000..b8ffe0ed37 --- /dev/null +++ b/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", + ], +) diff --git a/pkg/clouds/supported.go b/pkg/clouds/supported.go new file mode 100644 index 0000000000..f457b20fe9 --- /dev/null +++ b/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 +} diff --git a/pkg/zones/BUILD.bazel b/pkg/zones/BUILD.bazel new file mode 100644 index 0000000000..eaf58924cd --- /dev/null +++ b/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", + ], +) diff --git a/pkg/zones/wellknown.go b/pkg/zones/wellknown.go new file mode 100644 index 0000000000..6f14ce6cab --- /dev/null +++ b/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 + } +} diff --git a/upup/pkg/fi/cloud.go b/upup/pkg/fi/cloud.go index 6e578736dc..687b5bf051 100644 --- a/upup/pkg/fi/cloud.go +++ b/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 -} diff --git a/upup/pkg/fi/cloudup/BUILD.bazel b/upup/pkg/fi/cloudup/BUILD.bazel index cdf3c5d74e..90ced92049 100644 --- a/upup/pkg/fi/cloudup/BUILD.bazel +++ b/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", diff --git a/upup/pkg/fi/cloudup/new_cluster.go b/upup/pkg/fi/cloudup/new_cluster.go index deabac0d76..cdde1e4899 100644 --- a/upup/pkg/fi/cloudup/new_cluster.go +++ b/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) diff --git a/upup/pkg/fi/cloudup/utils.go b/upup/pkg/fi/cloudup/utils.go index 61a6f008e4..fdb873ec57 100644 --- a/upup/pkg/fi/cloudup/utils.go +++ b/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)