feat(kubernetes): support storage customisation (#510)

Add support for customising storage tier and size for Kubernetes node
groups utilising GPU and Cloud Native plans.

Signed-off-by: Ville Vesilehto <ville.vesilehto@upcloud.com>

Author: thevilledev

CHANGELOG.md

@@ -18,6 +18,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Expose GPU limits in `account show` command
 - Expose GPU model and amount in `server plans` command
 - Add `audit-log export` command.
+- Add support for customising storage tier and size for Kubernetes node groups utilising GPU and Cloud Native plans.
 
 ## [3.21.0] - 2025-07-15
 

internal/commands/kubernetes/create.go

@@ -35,6 +35,12 @@ func CreateCommand() commands.Command {
 				--network 03e5ca07-f36c-4957-a676-e001e40441eb \
 				--node-group count=4,kubelet-arg="log-flush-frequency=5s",label="owner=devteam",label="env=dev",name=my-node-group,plan=4xCPU-8GB,ssh-key="ssh-ed25519 AAAAo admin@user.com",ssh-key="/path/to/your/public/ssh/key.pub",storage=01000000-0000-4000-8000-000160010100,taint="env=dev:NoSchedule",taint="env=dev2:NoSchedule" \
 				--zone de-fra1`,
+			`upctl kubernetes create \
+				--name gpu-cluster \
+				--network 03e5ca07-f36c-4957-a676-e001e40441eb \
+				--node-group count=2,name=gpu-workers,plan=GPU-8xCPU-64GB-1xL40S,storage-size=1024,storage-tier=maxiops,label="gpu=NVIDIA-L40S" \
+				--node-group count=3,name=cloud-native-workers,plan=CLOUDNATIVE-4xCPU-8GB,storage-size=100,storage-tier=standard \
+				--zone fi-hel2`,
 		),
 	}
 }
@@ -134,8 +140,11 @@ func (c *createCommand) InitCommand() {
 			"ssh-key=\"ssh-ed25519 AAAAo admin@user.com\","+
 			"ssh-key=\"/path/to/your/public/ssh/key.pub\","+
 			"storage=01000000-0000-4000-8000-000160010100,"+
+			"storage-size=100,"+
+			"storage-tier=maxiops,"+
 			"taint=\"env=dev:NoSchedule\","+
-			"taint=\"env=dev2:NoSchedule\"`",
+			"taint=\"env=dev2:NoSchedule\"`\n"+
+			"Note: storage-size and storage-tier are only supported for Cloud Native (CLOUDNATIVE-*) and GPU (GPU-*) plans. Valid storage tiers: maxiops, standard, hdd.",
 	)
 	fs.StringArrayVar(
 		&c.params.ControlPlaneIPFilter,

internal/commands/kubernetes/nodegroup/create.go

@@ -18,12 +18,21 @@ import (
 	"github.com/spf13/pflag"
 )
 
+const (
+	CloudNativePlanPrefix = "CLOUDNATIVE-"
+	GPUPlanPrefix         = "GPU-"
+)
+
+var validStorageTiers = []string{upcloud.StorageTierMaxIOPS, upcloud.StorageTierStandard, upcloud.StorageTierHDD}
+
 type CreateNodeGroupParams struct {
 	Count                int
 	Name                 string
 	Plan                 string
 	SSHKeys              []string
 	Storage              string
+	StorageSize          int
+	StorageTier          string
 	KubeletArgs          []string
 	Labels               []string
 	Taints               []string
@@ -40,6 +49,8 @@ func GetCreateNodeGroupFlagSet(p *CreateNodeGroupParams) *pflag.FlagSet {
 	fs.StringVar(&p.Plan, "plan", "", "Server plan to use for nodes in the node group. Run `upctl server plans` to list all available plans.")
 	fs.StringArrayVar(&p.SSHKeys, "ssh-key", []string{}, "SSH keys to be configured as authorized keys to the nodes.")
 	fs.StringVar(&p.Storage, "storage", "", "Storage template to use when creating the nodes. Defaults to `UpCloud K8s` public template.")
+	fs.IntVar(&p.StorageSize, "storage-size", 0, fmt.Sprintf("Custom storage size in GiB. Only applicable for Cloud Native (%s*) and GPU (%s*) plans. If not specified, uses plan default.", CloudNativePlanPrefix, GPUPlanPrefix))
+	fs.StringVar(&p.StorageTier, "storage-tier", "", fmt.Sprintf("Storage tier (maxiops, standard, hdd). Only applicable for Cloud Native (%s*) and GPU (%s*) plans. If not specified, uses plan default.", CloudNativePlanPrefix, GPUPlanPrefix))
 	fs.StringArrayVar(&p.Taints, "taint", []string{}, "Taints to be configured to the nodes in `key=value:effect` format")
 	config.AddEnableOrDisableFlag(fs, &p.UtilityNetworkAccess, true, "utility-network-access", "utility network access. If disabled, nodes in this group will not have access to utility network")
 
@@ -49,11 +60,51 @@ func GetCreateNodeGroupFlagSet(p *CreateNodeGroupParams) *pflag.FlagSet {
 	commands.Must(fs.SetAnnotation("name", commands.FlagAnnotationNoFileCompletions, nil))
 	commands.Must(fs.SetAnnotation("ssh-key", commands.FlagAnnotationNoFileCompletions, nil))
 	commands.Must(fs.SetAnnotation("storage", commands.FlagAnnotationNoFileCompletions, nil))
+	commands.Must(fs.SetAnnotation("storage-size", commands.FlagAnnotationNoFileCompletions, nil))
+	commands.Must(fs.SetAnnotation("storage-tier", commands.FlagAnnotationFixedCompletions, []string{upcloud.StorageTierMaxIOPS, upcloud.StorageTierStandard, upcloud.StorageTierHDD}))
 	commands.Must(fs.SetAnnotation("taint", commands.FlagAnnotationNoFileCompletions, nil))
 
 	return fs
 }
 
+// supportStorageCustomization checks if a plan supports storage customization
+func supportStorageCustomization(planName string) bool {
+	return strings.HasPrefix(planName, CloudNativePlanPrefix) ||
+		strings.HasPrefix(planName, GPUPlanPrefix)
+}
+
+// validateStorageTier checks if the storage tier is valid
+func validateStorageTier(tier string) error {
+	if tier == "" {
+		return nil // Empty is valid (uses plan default)
+	}
+
+	for _, validTier := range validStorageTiers {
+		if tier == validTier {
+			return nil
+		}
+	}
+
+	return fmt.Errorf("invalid storage tier %q, must be one of: %s", tier, strings.Join(validStorageTiers, ", "))
+}
+
+// validateStorageSize checks if the storage size is valid
+func validateStorageSize(size int) error {
+	if size == 0 {
+		return nil // Zero is valid (uses plan default)
+	}
+
+	if size < 25 {
+		return fmt.Errorf("storage size must be at least 25 GiB, got %d", size)
+	}
+
+	if size > 4096 {
+		return fmt.Errorf("storage size cannot exceed 4096 GiB, got %d", size)
+	}
+
+	return nil
+}
+
 func processKubeletArg(in string) (upcloud.KubernetesKubeletArg, error) {
 	split := strings.SplitN(in, "=", 2)
 	if len(split) < 2 {
@@ -83,6 +134,19 @@ func processTaint(in string) (upcloud.KubernetesTaint, error) {
 func ProcessNodeGroupParams(p CreateNodeGroupParams) (request.KubernetesNodeGroup, error) {
 	ng := request.KubernetesNodeGroup{}
 
+	hasStorageCustomization := p.StorageSize > 0 || p.StorageTier != ""
+	if hasStorageCustomization && !supportStorageCustomization(p.Plan) {
+		return ng, fmt.Errorf("storage customization (--storage-size, --storage-tier) is only supported for Cloud Native (%s*) and GPU (%s*) plans, got plan: %s", CloudNativePlanPrefix, GPUPlanPrefix, p.Plan)
+	}
+
+	if err := validateStorageTier(p.StorageTier); err != nil {
+		return ng, err
+	}
+
+	if err := validateStorageSize(p.StorageSize); err != nil {
+		return ng, err
+	}
+
 	kubeletArgs := make([]upcloud.KubernetesKubeletArg, 0)
 	for _, v := range p.KubeletArgs {
 		ka, err := processKubeletArg(v)
@@ -125,6 +189,27 @@ func ProcessNodeGroupParams(p CreateNodeGroupParams) (request.KubernetesNodeGrou
 		UtilityNetworkAccess: upcloud.BoolPtr(p.UtilityNetworkAccess.Value()),
 	}
 
+	// Set storage customization for supported plans
+	if hasStorageCustomization {
+		if strings.HasPrefix(p.Plan, CloudNativePlanPrefix) {
+			ng.CloudNativePlan = &upcloud.KubernetesNodeGroupCloudNativePlan{}
+			if p.StorageSize > 0 {
+				ng.CloudNativePlan.StorageSize = p.StorageSize
+			}
+			if p.StorageTier != "" {
+				ng.CloudNativePlan.StorageTier = upcloud.StorageTier(p.StorageTier)
+			}
+		} else if strings.HasPrefix(p.Plan, GPUPlanPrefix) {
+			ng.GPUPlan = &upcloud.KubernetesNodeGroupGPUPlan{}
+			if p.StorageSize > 0 {
+				ng.GPUPlan.StorageSize = p.StorageSize
+			}
+			if p.StorageTier != "" {
+				ng.GPUPlan.StorageTier = upcloud.StorageTier(p.StorageTier)
+			}
+		}
+	}
+
 	return ng, nil
 }
 
@@ -142,6 +227,8 @@ func CreateCommand() commands.Command {
 			"create",
 			"Create a new node group into the specified cluster.",
 			"upctl kubernetes nodegroup create 55199a44-4751-4e27-9394-7c7661910be3 --name secondary-node-group --count 3 --plan 2xCPU-4GB",
+			"upctl kubernetes nodegroup create 55199a44-4751-4e27-9394-7c7661910be3 --name gpu-nodes --count 2 --plan GPU-8xCPU-64GB-1xL40S --storage-size 1024 --storage-tier maxiops --label gpu=NVIDIA-L40S",
+			"upctl kubernetes nodegroup create 55199a44-4751-4e27-9394-7c7661910be3 --name cloud-native-nodes --count 4 --plan CLOUDNATIVE-4xCPU-8GB --storage-size 50 --storage-tier standard",
 		),
 	}
 }

internal/commands/kubernetes/nodegroup/create_test.go

@@ -127,6 +127,66 @@ func TestCreateKubernetesNodeGroup(t *testing.T) {
 				},
 			},
 		},
+		{
+			name: "GPU plan with storage customization",
+			args: []string{clusterUUID, "--count", "2", "--name", "gpu-nodes", "--plan", "GPU-8xCPU-64GB-1xL40S", "--storage-size", "1024", "--storage-tier", "maxiops"},
+			expected: request.CreateKubernetesNodeGroupRequest{
+				ClusterUUID: clusterUUID,
+				NodeGroup: request.KubernetesNodeGroup{
+					Count:                2,
+					Name:                 "gpu-nodes",
+					Plan:                 "GPU-8xCPU-64GB-1xL40S",
+					Labels:               []upcloud.Label{},
+					KubeletArgs:          []upcloud.KubernetesKubeletArg{},
+					Taints:               []upcloud.KubernetesTaint{},
+					UtilityNetworkAccess: upcloud.BoolPtr(true),
+					GPUPlan: &upcloud.KubernetesNodeGroupGPUPlan{
+						StorageSize: 1024,
+						StorageTier: upcloud.StorageTierMaxIOPS,
+					},
+				},
+			},
+		},
+		{
+			name: "Cloud Native plan with storage customization",
+			args: []string{clusterUUID, "--count", "3", "--name", "cloud-native-nodes", "--plan", "CLOUDNATIVE-4xCPU-8GB", "--storage-size", "50", "--storage-tier", "standard"},
+			expected: request.CreateKubernetesNodeGroupRequest{
+				ClusterUUID: clusterUUID,
+				NodeGroup: request.KubernetesNodeGroup{
+					Count:                3,
+					Name:                 "cloud-native-nodes",
+					Plan:                 "CLOUDNATIVE-4xCPU-8GB",
+					Labels:               []upcloud.Label{},
+					KubeletArgs:          []upcloud.KubernetesKubeletArg{},
+					Taints:               []upcloud.KubernetesTaint{},
+					UtilityNetworkAccess: upcloud.BoolPtr(true),
+					CloudNativePlan: &upcloud.KubernetesNodeGroupCloudNativePlan{
+						StorageSize: 50,
+						StorageTier: upcloud.StorageTierStandard,
+					},
+				},
+			},
+		},
+		{
+			name:     "storage customization with unsupported plan",
+			args:     []string{clusterUUID, "--count", "2", "--name", "regular-nodes", "--plan", "2xCPU-4GB", "--storage-size", "100"},
+			errorMsg: "storage customization (--storage-size, --storage-tier) is only supported for Cloud Native (CLOUDNATIVE-*) and GPU (GPU-*) plans, got plan: 2xCPU-4GB",
+		},
+		{
+			name:     "invalid storage tier",
+			args:     []string{clusterUUID, "--count", "2", "--name", "gpu-nodes", "--plan", "GPU-8xCPU-64GB-1xL40S", "--storage-tier", "invalid"},
+			errorMsg: "invalid storage tier \"invalid\", must be one of: maxiops, standard, hdd",
+		},
+		{
+			name:     "invalid storage size too small",
+			args:     []string{clusterUUID, "--count", "2", "--name", "gpu-nodes", "--plan", "GPU-8xCPU-64GB-1xL40S", "--storage-size", "20"},
+			errorMsg: "storage size must be at least 25 GiB, got 20",
+		},
+		{
+			name:     "invalid storage size too large",
+			args:     []string{clusterUUID, "--count", "2", "--name", "gpu-nodes", "--plan", "GPU-8xCPU-64GB-1xL40S", "--storage-size", "5000"},
+			errorMsg: "storage size cannot exceed 4096 GiB, got 5000",
+		},
 	} {
 		t.Run(test.name, func(t *testing.T) {
 			conf := config.New()
@@ -151,3 +211,54 @@ func TestCreateKubernetesNodeGroup(t *testing.T) {
 		})
 	}
 }
+
+func TestSupportStorageCustomization(t *testing.T) {
+	tests := []struct {
+		planName string
+		expected bool
+	}{
+		{"2xCPU-4GB", false},
+		{"4xCPU-8GB", false},
+		{"HICPU-8xCPU-16GB", false},
+		{"HIMEM-4xCPU-32GB", false},
+		{"DEV-1xCPU-1GB", false},
+		{"CLOUDNATIVE-2xCPU-4GB", true},
+		{"CLOUDNATIVE-4xCPU-8GB", true},
+		{"GPU-8xCPU-64GB-1xL40S", true},
+		{"", false},
+	}
+
+	for _, test := range tests {
+		t.Run(test.planName, func(t *testing.T) {
+			result := supportStorageCustomization(test.planName)
+			assert.Equal(t, test.expected, result)
+		})
+	}
+}
+
+func TestValidateStorageTier(t *testing.T) {
+	tests := []struct {
+		tier     string
+		hasError bool
+	}{
+		{"", false},
+		{"maxiops", false},
+		{"standard", false},
+		{"hdd", false},
+		{"archive", true},
+		{"invalid", true},
+		{"MAXIOPS", true},
+		{"Standard", true},
+	}
+
+	for _, test := range tests {
+		t.Run(test.tier, func(t *testing.T) {
+			err := validateStorageTier(test.tier)
+			if test.hasError {
+				assert.Error(t, err)
+			} else {
+				assert.NoError(t, err)
+			}
+		})
+	}
+}