kubernetes

Documentation

Index

• Constants
• Variables
• type VersionGroup

Constants

const NoHeaderKey = "no-header"

Variables

var KubernetesCmd = &cobra.Command{
	Use:     "kubernetes",
	Aliases: []string{"kube", "k8s", "k"},
	Short:   "Manage Kubernetes clusters, node pools and more services related to Kubernetes",
	Long:    "Kubernetes commands to manage your Kubernetes clusters and node pools within the Thalassa Cloud Platform",
}

var KubernetesKubeConfigCmd = &cobra.Command{
	Use:               "kubeconfig",
	Aliases:           []string{},
	Short:             "Kubernetes Kubeconfig management",
	ValidArgsFunction: completion.CompleteKubernetesCluster,
	Args:              cobra.MaximumNArgs(1),
	Run: func(cmd *cobra.Command, args []string) {
		ctx := cmd.Context()
		client, err := thalassaclient.GetThalassaClient()
		if err != nil {
			fmt.Fprintln(os.Stderr, err)
			return
		}

		if len(args) != 1 {
			fmt.Fprintln(os.Stderr, "must provide a cluster. Missing value <cluster>")
			return
		}

		clusterIdentity := args[0]

		cluster, err := client.Kubernetes().GetKubernetesCluster(ctx, clusterIdentity)
		if err != nil {

			clusters, err := client.Kubernetes().ListKubernetesClusters(ctx, &kubernetes.ListKubernetesClustersRequest{})
			if err != nil {
				fmt.Println(err)
				return
			}
			for _, potentialCluster := range clusters {
				if potentialCluster.Name == clusterIdentity || potentialCluster.Slug == clusterIdentity {
					cluster = &potentialCluster
					break
				}
			}
		}
		if cluster == nil {
			fmt.Fprintln(os.Stderr, "cluster not found")
			return
		}

		fmt.Fprintf(os.Stderr, "Getting kubeconfig for cluster %s\n", cluster.Name)
		session, err := client.Kubernetes().GetKubernetesClusterKubeconfig(ctx, cluster.Identity)
		if err != nil {
			fmt.Println(err)
			return
		}

		fmt.Println(session.Kubeconfig)
	},
}

var KubernetesUpgradeCmd = &cobra.Command{
	Use:     "upgrade <cluster>",
	Short:   "Upgrade a Kubernetes cluster",
	Aliases: []string{"u"},
	Args:    cobra.MaximumNArgs(1),
	Run: func(cmd *cobra.Command, args []string) {
		client, err := thalassaclient.GetThalassaClient()
		if err != nil {
			fmt.Println("Error getting client:", err)
			return
		}
		versions, err := client.Kubernetes().ListKubernetesVersions(cmd.Context())
		if err != nil {
			fmt.Println("Error getting versions:", err)
			return
		}

		clusters := []kubernetes.KubernetesCluster{}

		if upgradeAllClusters {
			fmt.Println("Upgrading all clusters")
			clusters, err = client.Kubernetes().ListKubernetesClusters(cmd.Context(), &kubernetes.ListKubernetesClustersRequest{})
			if err != nil {
				fmt.Println("Error getting clusters:", err)
				return
			}
		} else {

			clusterIdentity, err := getSelectedCluster(args)
			if err != nil {
				fmt.Println("Error getting cluster:", err)
				return
			}

			cluster, err := client.Kubernetes().GetKubernetesCluster(cmd.Context(), clusterIdentity)
			if err != nil {
				fmt.Println("Error getting cluster:", err)
				return
			}
			clusters = append(clusters, *cluster)
		}

		for _, cluster := range clusters {
			if cluster.Status == "error" || cluster.Status == "deleting" {
				fmt.Println("Cluster is in error or deleting state...")
				continue
			}

			currentVersion, err := semver.Parse(cluster.ClusterVersion.KubernetesVersion)
			if err != nil {
				if !upgradeAllClusters {
					fmt.Println("Error parsing current cluster version:", err)
				}
				continue
			}

			upgradeToVersion, err := selectUpgradeVersion(currentVersion, versions, upgradeClusterToVersion)
			if err != nil {

				if upgradeClusterToVersion == "" && strings.Contains(err.Error(), "already at the latest available version") {
					fmt.Println("Cluster", cluster.Name, "is already at the latest available version:", cluster.ClusterVersion.KubernetesVersion)
					continue
				}
				if !upgradeAllClusters {
					fmt.Println("Error selecting upgrade version:", err)
				}
				continue
			}

			if cluster.ClusterVersion.KubernetesVersion == upgradeToVersion.KubernetesVersion {
				fmt.Println("Cluster", cluster.Name, "is already at the desired version")
				continue
			}

			if upgradeClusterDryRun {
				fmt.Println("Dry run mode: would upgrade cluster", cluster.Name, "to version", upgradeToVersion.KubernetesVersion)
				continue
			}

			fmt.Println("Upgrading cluster", cluster.Name, "to version", upgradeToVersion.KubernetesVersion)

			updateRequest := kubernetes.UpdateKubernetesCluster{
				KubernetesVersionIdentity: ptr.To(upgradeToVersion.Identity),
			}

			_, err = client.Kubernetes().UpdateKubernetesCluster(cmd.Context(), cluster.Identity, updateRequest)
			if err != nil {
				fmt.Println("Error upgrading cluster:", err)
				continue
			}
			if !upgradeAllClusters {
				fmt.Println("Upgrade of cluster", cluster.Name, "initiated successfully. The cluster will be upgraded in the background.")
			}
		}

		if upgradeAllClusters {
			fmt.Println("Upgrade of all clusters initiated successfully. The clusters will be upgraded in the background.")
		}

	},
}

Types

type VersionGroup

type VersionGroup struct {
	MajorMinor string
	Versions   []kubernetes.KubernetesVersion
}

Group candidates by major.minor to identify patch versions