mirror of https://github.com/k3s-io/k3s
526 lines
24 KiB
Go
526 lines
24 KiB
Go
/*
|
|
Copyright 2019 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 constants
|
|
|
|
import (
|
|
"fmt"
|
|
"io/ioutil"
|
|
"net"
|
|
"os"
|
|
"path"
|
|
"path/filepath"
|
|
"time"
|
|
|
|
"github.com/pkg/errors"
|
|
v1 "k8s.io/api/core/v1"
|
|
"k8s.io/apimachinery/pkg/util/version"
|
|
bootstrapapi "k8s.io/cluster-bootstrap/token/api"
|
|
kubeadmapi "k8s.io/kubernetes/cmd/kubeadm/app/apis/kubeadm"
|
|
"k8s.io/kubernetes/pkg/registry/core/service/ipallocator"
|
|
)
|
|
|
|
// KubernetesDir is the directory Kubernetes owns for storing various configuration files
|
|
// This semi-constant MUST NOT be modified during runtime. It's a variable solely for use in unit testing.
|
|
var KubernetesDir = "/etc/kubernetes"
|
|
|
|
const (
|
|
// ManifestsSubDirName defines directory name to store manifests
|
|
ManifestsSubDirName = "manifests"
|
|
// TempDirForKubeadm defines temporary directory for kubeadm
|
|
// should be joined with KubernetesDir.
|
|
TempDirForKubeadm = "tmp"
|
|
|
|
// CACertAndKeyBaseName defines certificate authority base name
|
|
CACertAndKeyBaseName = "ca"
|
|
// CACertName defines certificate name
|
|
CACertName = "ca.crt"
|
|
// CAKeyName defines certificate name
|
|
CAKeyName = "ca.key"
|
|
|
|
// APIServerCertAndKeyBaseName defines API's server certificate and key base name
|
|
APIServerCertAndKeyBaseName = "apiserver"
|
|
// APIServerCertName defines API's server certificate name
|
|
APIServerCertName = "apiserver.crt"
|
|
// APIServerKeyName defines API's server key name
|
|
APIServerKeyName = "apiserver.key"
|
|
// APIServerCertCommonName defines API's server certificate common name (CN)
|
|
APIServerCertCommonName = "kube-apiserver"
|
|
|
|
// APIServerKubeletClientCertAndKeyBaseName defines kubelet client certificate and key base name
|
|
APIServerKubeletClientCertAndKeyBaseName = "apiserver-kubelet-client"
|
|
// APIServerKubeletClientCertName defines kubelet client certificate name
|
|
APIServerKubeletClientCertName = "apiserver-kubelet-client.crt"
|
|
// APIServerKubeletClientKeyName defines kubelet client key name
|
|
APIServerKubeletClientKeyName = "apiserver-kubelet-client.key"
|
|
// APIServerKubeletClientCertCommonName defines kubelet client certificate common name (CN)
|
|
APIServerKubeletClientCertCommonName = "kube-apiserver-kubelet-client"
|
|
|
|
// EtcdCACertAndKeyBaseName defines etcd's CA certificate and key base name
|
|
EtcdCACertAndKeyBaseName = "etcd/ca"
|
|
// EtcdCACertName defines etcd's CA certificate name
|
|
EtcdCACertName = "etcd/ca.crt"
|
|
// EtcdCAKeyName defines etcd's CA key name
|
|
EtcdCAKeyName = "etcd/ca.key"
|
|
|
|
// EtcdServerCertAndKeyBaseName defines etcd's server certificate and key base name
|
|
EtcdServerCertAndKeyBaseName = "etcd/server"
|
|
// EtcdServerCertName defines etcd's server certificate name
|
|
EtcdServerCertName = "etcd/server.crt"
|
|
// EtcdServerKeyName defines etcd's server key name
|
|
EtcdServerKeyName = "etcd/server.key"
|
|
|
|
// EtcdListenClientPort defines the port etcd listen on for client traffic
|
|
EtcdListenClientPort = 2379
|
|
|
|
// EtcdPeerCertAndKeyBaseName defines etcd's peer certificate and key base name
|
|
EtcdPeerCertAndKeyBaseName = "etcd/peer"
|
|
// EtcdPeerCertName defines etcd's peer certificate name
|
|
EtcdPeerCertName = "etcd/peer.crt"
|
|
// EtcdPeerKeyName defines etcd's peer key name
|
|
EtcdPeerKeyName = "etcd/peer.key"
|
|
|
|
// EtcdListenPeerPort defines the port etcd listen on for peer traffic
|
|
EtcdListenPeerPort = 2380
|
|
|
|
// EtcdHealthcheckClientCertAndKeyBaseName defines etcd's healthcheck client certificate and key base name
|
|
EtcdHealthcheckClientCertAndKeyBaseName = "etcd/healthcheck-client"
|
|
// EtcdHealthcheckClientCertName defines etcd's healthcheck client certificate name
|
|
EtcdHealthcheckClientCertName = "etcd/healthcheck-client.crt"
|
|
// EtcdHealthcheckClientKeyName defines etcd's healthcheck client key name
|
|
EtcdHealthcheckClientKeyName = "etcd/healthcheck-client.key"
|
|
// EtcdHealthcheckClientCertCommonName defines etcd's healthcheck client certificate common name (CN)
|
|
EtcdHealthcheckClientCertCommonName = "kube-etcd-healthcheck-client"
|
|
|
|
// APIServerEtcdClientCertAndKeyBaseName defines apiserver's etcd client certificate and key base name
|
|
APIServerEtcdClientCertAndKeyBaseName = "apiserver-etcd-client"
|
|
// APIServerEtcdClientCertName defines apiserver's etcd client certificate name
|
|
APIServerEtcdClientCertName = "apiserver-etcd-client.crt"
|
|
// APIServerEtcdClientKeyName defines apiserver's etcd client key name
|
|
APIServerEtcdClientKeyName = "apiserver-etcd-client.key"
|
|
// APIServerEtcdClientCertCommonName defines apiserver's etcd client certificate common name (CN)
|
|
APIServerEtcdClientCertCommonName = "kube-apiserver-etcd-client"
|
|
|
|
// ServiceAccountKeyBaseName defines SA key base name
|
|
ServiceAccountKeyBaseName = "sa"
|
|
// ServiceAccountPublicKeyName defines SA public key base name
|
|
ServiceAccountPublicKeyName = "sa.pub"
|
|
// ServiceAccountPrivateKeyName defines SA private key base name
|
|
ServiceAccountPrivateKeyName = "sa.key"
|
|
|
|
// FrontProxyCACertAndKeyBaseName defines front proxy CA certificate and key base name
|
|
FrontProxyCACertAndKeyBaseName = "front-proxy-ca"
|
|
// FrontProxyCACertName defines front proxy CA certificate name
|
|
FrontProxyCACertName = "front-proxy-ca.crt"
|
|
// FrontProxyCAKeyName defines front proxy CA key name
|
|
FrontProxyCAKeyName = "front-proxy-ca.key"
|
|
|
|
// FrontProxyClientCertAndKeyBaseName defines front proxy certificate and key base name
|
|
FrontProxyClientCertAndKeyBaseName = "front-proxy-client"
|
|
// FrontProxyClientCertName defines front proxy certificate name
|
|
FrontProxyClientCertName = "front-proxy-client.crt"
|
|
// FrontProxyClientKeyName defines front proxy key name
|
|
FrontProxyClientKeyName = "front-proxy-client.key"
|
|
// FrontProxyClientCertCommonName defines front proxy certificate common name
|
|
FrontProxyClientCertCommonName = "front-proxy-client" //used as subject.commonname attribute (CN)
|
|
|
|
// AdminKubeConfigFileName defines name for the kubeconfig aimed to be used by the superuser/admin of the cluster
|
|
AdminKubeConfigFileName = "admin.conf"
|
|
// KubeletBootstrapKubeConfigFileName defines the file name for the kubeconfig that the kubelet will use to do
|
|
// the TLS bootstrap to get itself an unique credential
|
|
KubeletBootstrapKubeConfigFileName = "bootstrap-kubelet.conf"
|
|
|
|
// KubeletKubeConfigFileName defines the file name for the kubeconfig that the control-plane kubelet will use for talking
|
|
// to the API server
|
|
KubeletKubeConfigFileName = "kubelet.conf"
|
|
// ControllerManagerKubeConfigFileName defines the file name for the controller manager's kubeconfig file
|
|
ControllerManagerKubeConfigFileName = "controller-manager.conf"
|
|
// SchedulerKubeConfigFileName defines the file name for the scheduler's kubeconfig file
|
|
SchedulerKubeConfigFileName = "scheduler.conf"
|
|
|
|
// Some well-known users and groups in the core Kubernetes authorization system
|
|
|
|
// ControllerManagerUser defines the well-known user the controller-manager should be authenticated as
|
|
ControllerManagerUser = "system:kube-controller-manager"
|
|
// SchedulerUser defines the well-known user the scheduler should be authenticated as
|
|
SchedulerUser = "system:kube-scheduler"
|
|
// SystemPrivilegedGroup defines the well-known group for the apiservers. This group is also superuser by default
|
|
// (i.e. bound to the cluster-admin ClusterRole)
|
|
SystemPrivilegedGroup = "system:masters"
|
|
// NodesGroup defines the well-known group for all nodes.
|
|
NodesGroup = "system:nodes"
|
|
// NodesUserPrefix defines the user name prefix as requested by the Node authorizer.
|
|
NodesUserPrefix = "system:node:"
|
|
// NodesClusterRoleBinding defines the well-known ClusterRoleBinding which binds the too permissive system:node
|
|
// ClusterRole to the system:nodes group. Since kubeadm is using the Node Authorizer, this ClusterRoleBinding's
|
|
// system:nodes group subject is removed if present.
|
|
NodesClusterRoleBinding = "system:node"
|
|
|
|
// APICallRetryInterval defines how long kubeadm should wait before retrying a failed API operation
|
|
APICallRetryInterval = 500 * time.Millisecond
|
|
// DiscoveryRetryInterval specifies how long kubeadm should wait before retrying to connect to the control-plane when doing discovery
|
|
DiscoveryRetryInterval = 5 * time.Second
|
|
// PatchNodeTimeout specifies how long kubeadm should wait for applying the label and taint on the control-plane before timing out
|
|
PatchNodeTimeout = 2 * time.Minute
|
|
// UpdateNodeTimeout specifies how long kubeadm should wait for updating node with the initial remote configuration of kubelet before timing out
|
|
UpdateNodeTimeout = 2 * time.Minute
|
|
// TLSBootstrapTimeout specifies how long kubeadm should wait for the kubelet to perform the TLS Bootstrap
|
|
TLSBootstrapTimeout = 2 * time.Minute
|
|
|
|
// DefaultControlPlaneTimeout specifies the default control plane (actually API Server) timeout for use by kubeadm
|
|
DefaultControlPlaneTimeout = 4 * time.Minute
|
|
|
|
// MinimumAddressesInServiceSubnet defines minimum amount of nodes the Service subnet should allow.
|
|
// We need at least ten, because the DNS service is always at the tenth cluster clusterIP
|
|
MinimumAddressesInServiceSubnet = 10
|
|
|
|
// DefaultTokenDuration specifies the default amount of time that a bootstrap token will be valid
|
|
// Default behaviour is 24 hours
|
|
DefaultTokenDuration = 24 * time.Hour
|
|
|
|
// DefaultCertTokenDuration specifies the default amount of time that the token used by upload certs will be valid
|
|
// Default behaviour is 2 hours
|
|
DefaultCertTokenDuration = 2 * time.Hour
|
|
|
|
// CertificateKeySize specifies the size of the key used to encrypt certificates on uploadcerts phase
|
|
CertificateKeySize = 32
|
|
|
|
// LabelNodeRoleMaster specifies that a node is a control-plane
|
|
// This is a duplicate definition of the constant in pkg/controller/service/service_controller.go
|
|
LabelNodeRoleMaster = "node-role.kubernetes.io/master"
|
|
|
|
// AnnotationKubeadmCRISocket specifies the annotation kubeadm uses to preserve the crisocket information given to kubeadm at
|
|
// init/join time for use later. kubeadm annotates the node object with this information
|
|
AnnotationKubeadmCRISocket = "kubeadm.alpha.kubernetes.io/cri-socket"
|
|
|
|
// KubeadmConfigConfigMap specifies in what ConfigMap in the kube-system namespace the `kubeadm init` configuration should be stored
|
|
KubeadmConfigConfigMap = "kubeadm-config"
|
|
|
|
// ClusterConfigurationConfigMapKey specifies in what ConfigMap key the cluster configuration should be stored
|
|
ClusterConfigurationConfigMapKey = "ClusterConfiguration"
|
|
|
|
// ClusterStatusConfigMapKey specifies in what ConfigMap key the cluster status should be stored
|
|
ClusterStatusConfigMapKey = "ClusterStatus"
|
|
|
|
// KubeProxyConfigMap specifies in what ConfigMap in the kube-system namespace the kube-proxy configuration should be stored
|
|
KubeProxyConfigMap = "kube-proxy"
|
|
|
|
// KubeProxyConfigMapKey specifies in what ConfigMap key the component config of kube-proxy should be stored
|
|
KubeProxyConfigMapKey = "config.conf"
|
|
|
|
// KubeletBaseConfigurationConfigMapPrefix specifies in what ConfigMap in the kube-system namespace the initial remote configuration of kubelet should be stored
|
|
KubeletBaseConfigurationConfigMapPrefix = "kubelet-config-"
|
|
|
|
// KubeletBaseConfigurationConfigMapKey specifies in what ConfigMap key the initial remote configuration of kubelet should be stored
|
|
KubeletBaseConfigurationConfigMapKey = "kubelet"
|
|
|
|
// KubeletBaseConfigMapRolePrefix defines the base kubelet configuration ConfigMap.
|
|
KubeletBaseConfigMapRolePrefix = "kubeadm:kubelet-config-"
|
|
|
|
// KubeletRunDirectory specifies the directory where the kubelet runtime information is stored.
|
|
KubeletRunDirectory = "/var/lib/kubelet"
|
|
|
|
// KubeletConfigurationFileName specifies the file name on the node which stores initial remote configuration of kubelet
|
|
// This file should exist under KubeletRunDirectory
|
|
KubeletConfigurationFileName = "config.yaml"
|
|
|
|
// DynamicKubeletConfigurationDirectoryName specifies the directory which stores the dynamic configuration checkpoints for the kubelet
|
|
// This directory should exist under KubeletRunDirectory
|
|
DynamicKubeletConfigurationDirectoryName = "dynamic-config"
|
|
|
|
// KubeletEnvFileName is a file "kubeadm init" writes at runtime. Using that interface, kubeadm can customize certain
|
|
// kubelet flags conditionally based on the environment at runtime. Also, parameters given to the configuration file
|
|
// might be passed through this file. "kubeadm init" writes one variable, with the name ${KubeletEnvFileVariableName}.
|
|
// This file should exist under KubeletRunDirectory
|
|
KubeletEnvFileName = "kubeadm-flags.env"
|
|
|
|
// KubeletEnvFileVariableName specifies the shell script variable name "kubeadm init" should write a value to in KubeletEnvFile
|
|
KubeletEnvFileVariableName = "KUBELET_KUBEADM_ARGS"
|
|
|
|
// KubeletHealthzPort is the port of the kubelet healthz endpoint
|
|
KubeletHealthzPort = 10248
|
|
|
|
// MinExternalEtcdVersion indicates minimum external etcd version which kubeadm supports
|
|
MinExternalEtcdVersion = "3.2.18"
|
|
|
|
// DefaultEtcdVersion indicates the default etcd version that kubeadm uses
|
|
DefaultEtcdVersion = "3.3.10"
|
|
|
|
// PauseVersion indicates the default pause image version for kubeadm
|
|
PauseVersion = "3.1"
|
|
|
|
// Etcd defines variable used internally when referring to etcd component
|
|
Etcd = "etcd"
|
|
// KubeAPIServer defines variable used internally when referring to kube-apiserver component
|
|
KubeAPIServer = "kube-apiserver"
|
|
// KubeControllerManager defines variable used internally when referring to kube-controller-manager component
|
|
KubeControllerManager = "kube-controller-manager"
|
|
// KubeScheduler defines variable used internally when referring to kube-scheduler component
|
|
KubeScheduler = "kube-scheduler"
|
|
// KubeProxy defines variable used internally when referring to kube-proxy component
|
|
KubeProxy = "kube-proxy"
|
|
// HyperKube defines variable used internally when referring to the hyperkube image
|
|
HyperKube = "hyperkube"
|
|
|
|
// SelfHostingPrefix describes the prefix workloads that are self-hosted by kubeadm has
|
|
SelfHostingPrefix = "self-hosted-"
|
|
|
|
// KubeCertificatesVolumeName specifies the name for the Volume that is used for injecting certificates to control plane components (can be both a hostPath volume or a projected, all-in-one volume)
|
|
KubeCertificatesVolumeName = "k8s-certs"
|
|
|
|
// KubeConfigVolumeName specifies the name for the Volume that is used for injecting the kubeconfig to talk securely to the api server for a control plane component if applicable
|
|
KubeConfigVolumeName = "kubeconfig"
|
|
|
|
// NodeBootstrapTokenAuthGroup specifies which group a Node Bootstrap Token should be authenticated in
|
|
NodeBootstrapTokenAuthGroup = "system:bootstrappers:kubeadm:default-node-token"
|
|
|
|
// DefaultCIImageRepository points to image registry where CI uploads images from ci-cross build job
|
|
DefaultCIImageRepository = "gcr.io/kubernetes-ci-images"
|
|
|
|
// CoreDNSConfigMap specifies in what ConfigMap in the kube-system namespace the CoreDNS config should be stored
|
|
CoreDNSConfigMap = "coredns"
|
|
|
|
// CoreDNSDeploymentName specifies the name of the Deployment for CoreDNS add-on
|
|
CoreDNSDeploymentName = "coredns"
|
|
|
|
// CoreDNSImageName specifies the name of the image for CoreDNS add-on
|
|
CoreDNSImageName = "coredns"
|
|
|
|
// KubeDNSConfigMap specifies in what ConfigMap in the kube-system namespace the kube-dns config should be stored
|
|
KubeDNSConfigMap = "kube-dns"
|
|
|
|
// KubeDNSDeploymentName specifies the name of the Deployment for kube-dns add-on
|
|
KubeDNSDeploymentName = "kube-dns"
|
|
|
|
// KubeDNSKubeDNSImageName specifies the name of the image for the kubedns container in the kube-dns add-on
|
|
KubeDNSKubeDNSImageName = "k8s-dns-kube-dns"
|
|
|
|
// KubeDNSSidecarImageName specifies the name of the image for the sidecar container in the kube-dns add-on
|
|
KubeDNSSidecarImageName = "k8s-dns-sidecar"
|
|
|
|
// KubeDNSDnsMasqNannyImageName specifies the name of the image for the dnsmasq container in the kube-dns add-on
|
|
KubeDNSDnsMasqNannyImageName = "k8s-dns-dnsmasq-nanny"
|
|
|
|
// CRICtlPackage defines the go package that installs crictl
|
|
CRICtlPackage = "github.com/kubernetes-incubator/cri-tools/cmd/crictl"
|
|
|
|
// KubeAuditPolicyVolumeName is the name of the volume that will contain the audit policy
|
|
KubeAuditPolicyVolumeName = "audit"
|
|
// AuditPolicyDir is the directory that will contain the audit policy
|
|
AuditPolicyDir = "audit"
|
|
// AuditPolicyFile is the name of the audit policy file itself
|
|
AuditPolicyFile = "audit.yaml"
|
|
// AuditPolicyLogFile is the name of the file audit logs get written to
|
|
AuditPolicyLogFile = "audit.log"
|
|
// KubeAuditPolicyLogVolumeName is the name of the volume that will contain the audit logs
|
|
KubeAuditPolicyLogVolumeName = "audit-log"
|
|
// StaticPodAuditPolicyLogDir is the name of the directory in the static pod that will have the audit logs
|
|
StaticPodAuditPolicyLogDir = "/var/log/kubernetes/audit"
|
|
|
|
// LeaseEndpointReconcilerType will select a storage based reconciler
|
|
// Copied from pkg/master/reconcilers to avoid pulling extra dependencies
|
|
// TODO: Import this constant from a consts only package, that does not pull any further dependencies.
|
|
LeaseEndpointReconcilerType = "lease"
|
|
|
|
// KubeDNSVersion is the version of kube-dns to be deployed if it is used
|
|
KubeDNSVersion = "1.14.13"
|
|
|
|
// CoreDNSVersion is the version of CoreDNS to be deployed if it is used
|
|
CoreDNSVersion = "1.3.1"
|
|
|
|
// ClusterConfigurationKind is the string kind value for the ClusterConfiguration struct
|
|
ClusterConfigurationKind = "ClusterConfiguration"
|
|
|
|
// InitConfigurationKind is the string kind value for the InitConfiguration struct
|
|
InitConfigurationKind = "InitConfiguration"
|
|
|
|
// JoinConfigurationKind is the string kind value for the JoinConfiguration struct
|
|
JoinConfigurationKind = "JoinConfiguration"
|
|
|
|
// YAMLDocumentSeparator is the separator for YAML documents
|
|
// TODO: Find a better place for this constant
|
|
YAMLDocumentSeparator = "---\n"
|
|
|
|
// DefaultAPIServerBindAddress is the default bind address for the API Server
|
|
DefaultAPIServerBindAddress = "0.0.0.0"
|
|
|
|
// ControlPlaneNumCPU is the number of CPUs required on control-plane
|
|
ControlPlaneNumCPU = 2
|
|
|
|
// KubeadmCertsSecret specifies in what Secret in the kube-system namespace the certificates should be stored
|
|
KubeadmCertsSecret = "kubeadm-certs"
|
|
)
|
|
|
|
var (
|
|
// ControlPlaneTaint is the taint to apply on the PodSpec for being able to run that Pod on the control-plane
|
|
ControlPlaneTaint = v1.Taint{
|
|
Key: LabelNodeRoleMaster,
|
|
Effect: v1.TaintEffectNoSchedule,
|
|
}
|
|
|
|
// ControlPlaneToleration is the toleration to apply on the PodSpec for being able to run that Pod on the control-plane
|
|
ControlPlaneToleration = v1.Toleration{
|
|
Key: LabelNodeRoleMaster,
|
|
Effect: v1.TaintEffectNoSchedule,
|
|
}
|
|
|
|
// DefaultTokenUsages specifies the default functions a token will get
|
|
DefaultTokenUsages = bootstrapapi.KnownTokenUsages
|
|
|
|
// DefaultTokenGroups specifies the default groups that this token will authenticate as when used for authentication
|
|
DefaultTokenGroups = []string{NodeBootstrapTokenAuthGroup}
|
|
|
|
// ControlPlaneComponents defines the control-plane component names
|
|
ControlPlaneComponents = []string{KubeAPIServer, KubeControllerManager, KubeScheduler}
|
|
|
|
// MinimumControlPlaneVersion specifies the minimum control plane version kubeadm can deploy
|
|
MinimumControlPlaneVersion = version.MustParseSemantic("v1.13.0")
|
|
|
|
// MinimumKubeletVersion specifies the minimum version of kubelet which kubeadm supports
|
|
MinimumKubeletVersion = version.MustParseSemantic("v1.13.0")
|
|
|
|
// CurrentKubernetesVersion specifies current Kubernetes version supported by kubeadm
|
|
CurrentKubernetesVersion = version.MustParseSemantic("v1.14.0")
|
|
|
|
// SupportedEtcdVersion lists officially supported etcd versions with corresponding Kubernetes releases
|
|
SupportedEtcdVersion = map[uint8]string{
|
|
12: "3.2.24",
|
|
13: "3.2.24",
|
|
14: "3.3.10",
|
|
}
|
|
|
|
// KubeadmCertsClusterRoleName sets the name for the ClusterRole that allows
|
|
// the bootstrap tokens to access the kubeadm-certs Secret during the join of a new control-plane
|
|
KubeadmCertsClusterRoleName = fmt.Sprintf("kubeadm:%s", KubeadmCertsSecret)
|
|
)
|
|
|
|
// EtcdSupportedVersion returns officially supported version of etcd for a specific Kubernetes release
|
|
// if passed version is not listed, the function returns nil and an error
|
|
func EtcdSupportedVersion(versionString string) (*version.Version, error) {
|
|
kubernetesVersion, err := version.ParseSemantic(versionString)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
if etcdStringVersion, ok := SupportedEtcdVersion[uint8(kubernetesVersion.Minor())]; ok {
|
|
etcdVersion, err := version.ParseSemantic(etcdStringVersion)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return etcdVersion, nil
|
|
}
|
|
return nil, errors.Errorf("Unsupported or unknown Kubernetes version(%v)", kubernetesVersion)
|
|
}
|
|
|
|
// GetStaticPodDirectory returns the location on the disk where the Static Pod should be present
|
|
func GetStaticPodDirectory() string {
|
|
return filepath.Join(KubernetesDir, ManifestsSubDirName)
|
|
}
|
|
|
|
// GetStaticPodFilepath returns the location on the disk where the Static Pod should be present
|
|
func GetStaticPodFilepath(componentName, manifestsDir string) string {
|
|
return filepath.Join(manifestsDir, componentName+".yaml")
|
|
}
|
|
|
|
// GetAdminKubeConfigPath returns the location on the disk where admin kubeconfig is located by default
|
|
func GetAdminKubeConfigPath() string {
|
|
return filepath.Join(KubernetesDir, AdminKubeConfigFileName)
|
|
}
|
|
|
|
// GetBootstrapKubeletKubeConfigPath returns the location on the disk where bootstrap kubelet kubeconfig is located by default
|
|
func GetBootstrapKubeletKubeConfigPath() string {
|
|
return filepath.Join(KubernetesDir, KubeletBootstrapKubeConfigFileName)
|
|
}
|
|
|
|
// GetKubeletKubeConfigPath returns the location on the disk where kubelet kubeconfig is located by default
|
|
func GetKubeletKubeConfigPath() string {
|
|
return filepath.Join(KubernetesDir, KubeletKubeConfigFileName)
|
|
}
|
|
|
|
// AddSelfHostedPrefix adds the self-hosted- prefix to the component name
|
|
func AddSelfHostedPrefix(componentName string) string {
|
|
return fmt.Sprintf("%s%s", SelfHostingPrefix, componentName)
|
|
}
|
|
|
|
// CreateTempDirForKubeadm is a function that creates a temporary directory under /etc/kubernetes/tmp (not using /tmp as that would potentially be dangerous)
|
|
func CreateTempDirForKubeadm(dirName string) (string, error) {
|
|
tempDir := path.Join(KubernetesDir, TempDirForKubeadm)
|
|
// creates target folder if not already exists
|
|
if err := os.MkdirAll(tempDir, 0700); err != nil {
|
|
return "", errors.Wrapf(err, "failed to create directory %q", tempDir)
|
|
}
|
|
|
|
tempDir, err := ioutil.TempDir(tempDir, dirName)
|
|
if err != nil {
|
|
return "", errors.Wrap(err, "couldn't create a temporary directory")
|
|
}
|
|
return tempDir, nil
|
|
}
|
|
|
|
// CreateTimestampDirForKubeadm is a function that creates a temporary directory under /etc/kubernetes/tmp formatted with the current date
|
|
func CreateTimestampDirForKubeadm(dirName string) (string, error) {
|
|
tempDir := path.Join(KubernetesDir, TempDirForKubeadm)
|
|
// creates target folder if not already exists
|
|
if err := os.MkdirAll(tempDir, 0700); err != nil {
|
|
return "", errors.Wrapf(err, "failed to create directory %q", tempDir)
|
|
}
|
|
|
|
timestampDirName := fmt.Sprintf("%s-%s", dirName, time.Now().Format("2006-01-02-15-04-05"))
|
|
timestampDir := path.Join(tempDir, timestampDirName)
|
|
if err := os.Mkdir(timestampDir, 0700); err != nil {
|
|
return "", errors.Wrap(err, "could not create timestamp directory")
|
|
}
|
|
|
|
return timestampDir, nil
|
|
}
|
|
|
|
// GetDNSIP returns a dnsIP, which is 10th IP in svcSubnet CIDR range
|
|
func GetDNSIP(svcSubnet string) (net.IP, error) {
|
|
// Get the service subnet CIDR
|
|
_, svcSubnetCIDR, err := net.ParseCIDR(svcSubnet)
|
|
if err != nil {
|
|
return nil, errors.Wrapf(err, "couldn't parse service subnet CIDR %q", svcSubnet)
|
|
}
|
|
|
|
// Selects the 10th IP in service subnet CIDR range as dnsIP
|
|
dnsIP, err := ipallocator.GetIndexedIP(svcSubnetCIDR, 10)
|
|
if err != nil {
|
|
return nil, errors.Wrapf(err, "unable to get tenth IP address from service subnet CIDR %s", svcSubnetCIDR.String())
|
|
}
|
|
|
|
return dnsIP, nil
|
|
}
|
|
|
|
// GetStaticPodAuditPolicyFile returns the path to the audit policy file within a static pod
|
|
func GetStaticPodAuditPolicyFile() string {
|
|
return filepath.Join(KubernetesDir, AuditPolicyDir, AuditPolicyFile)
|
|
}
|
|
|
|
// GetDNSVersion is a handy function that returns the DNS version by DNS type
|
|
func GetDNSVersion(dnsType kubeadmapi.DNSAddOnType) string {
|
|
switch dnsType {
|
|
case kubeadmapi.KubeDNS:
|
|
return KubeDNSVersion
|
|
default:
|
|
return CoreDNSVersion
|
|
}
|
|
}
|
|
|
|
// GetKubeletConfigMapName returns the right ConfigMap name for the right branch of k8s
|
|
func GetKubeletConfigMapName(k8sVersion *version.Version) string {
|
|
return fmt.Sprintf("%s%d.%d", KubeletBaseConfigurationConfigMapPrefix, k8sVersion.Major(), k8sVersion.Minor())
|
|
}
|