chore: ephemeral storage requests and limits

Signed-off-by: Artem Bortnikov <brongineer747@gmail.com>

Author: BROngineer

internal/controller/factory/backup_job.go

@@ -18,6 +18,7 @@ package factory
 
 import (
 	"fmt"
+	"strconv"
 	"strings"
 
 	etcdaenixiov1alpha1 "github.com/aenix-io/etcd-operator/api/v1alpha1"
@@ -33,8 +34,36 @@ import (
 const (
 	stringTrue = "true"
 	backupData = "backup-data"
+
+	// defaultEtcdQuotaBytes is etcd's default backend quota (2 GiB).
+	defaultEtcdQuotaBytes int64 = 2 * 1024 * 1024 * 1024
 )
 
+// getEffectiveDBQuota returns the maximum etcd DB size for the given cluster,
+// used to set ephemeral-storage requests/limits on backup Jobs.
+// It checks, in order: explicit quota-backend-bytes option, the full cluster
+// storage size, and falls back to etcd's default 2 GiB quota.
+func getEffectiveDBQuota(cluster *etcdaenixiov1alpha1.EtcdCluster) resource.Quantity {
+	// we'll use an explicit quota-backend-bytes option if set.
+	if v, ok := cluster.Spec.Options["quota-backend-bytes"]; ok && v != "" {
+		if parsed, err := strconv.ParseInt(v, 10, 64); err == nil && parsed > 0 {
+			return *resource.NewQuantity(parsed, resource.BinarySI)
+		}
+	}
+
+	// if a quota-backend-bytes option is not set, use the full cluster storage size
+	if cluster.Spec.Storage.EmptyDir != nil {
+		if cluster.Spec.Storage.EmptyDir.SizeLimit != nil {
+			return *cluster.Spec.Storage.EmptyDir.SizeLimit
+		}
+	} else if req := cluster.Spec.Storage.VolumeClaimTemplate.Spec.Resources.Requests.Storage(); req != nil {
+		return *req
+	}
+
+	// otherwise we'll fall back to etcd's default quota.
+	return *resource.NewQuantity(defaultEtcdQuotaBytes, resource.BinarySI)
+}
+
 // CreateBackupJob builds a Job that runs the backup-agent to take an etcd snapshot
 // and store it to the configured destination.
 func CreateBackupJob(
@@ -209,6 +238,7 @@ func buildBackupContainer(
 
 	envVars = append(envVars, corev1.EnvVar{Name: "BACKUP_INCLUDE_REVISION", Value: stringTrue})
 
+	ephemeralStorage := getEffectiveDBQuota(cluster)
 	container := corev1.Container{
 		Name:         "backup-agent",
 		Image:        operatorImage,
@@ -217,11 +247,13 @@ func buildBackupContainer(
 		VolumeMounts: volumeMounts,
 		Resources: corev1.ResourceRequirements{
 			Requests: corev1.ResourceList{
-				corev1.ResourceCPU:    resource.MustParse("100m"),
-				corev1.ResourceMemory: resource.MustParse("128Mi"),
+				corev1.ResourceCPU:              resource.MustParse("100m"),
+				corev1.ResourceMemory:           resource.MustParse("128Mi"),
+				corev1.ResourceEphemeralStorage: ephemeralStorage,
 			},
 			Limits: corev1.ResourceList{
-				corev1.ResourceMemory: resource.MustParse("512Mi"),
+				corev1.ResourceMemory:           resource.MustParse("512Mi"),
+				corev1.ResourceEphemeralStorage: ephemeralStorage,
 			},
 		},
 	}

internal/controller/factory/backup_job_test.go

@@ -22,6 +22,7 @@ import (
 
 	etcdaenixiov1alpha1 "github.com/aenix-io/etcd-operator/api/v1alpha1"
 	corev1 "k8s.io/api/core/v1"
+	"k8s.io/apimachinery/pkg/api/resource"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 	"k8s.io/apimachinery/pkg/runtime"
 	clientgoscheme "k8s.io/client-go/kubernetes/scheme"
@@ -116,6 +117,19 @@ func TestCreateBackupJob_PVC(t *testing.T) {
 		t.Errorf("expected owner name 'my-backup', got %q", job.OwnerReferences[0].Name)
 	}
 
+	// Check ephemeral storage (EmptyDir without SizeLimit → etcd default 2Gi)
+	expectedEphemeral := resource.NewQuantity(2*1024*1024*1024, resource.BinarySI)
+	if req, ok := container.Resources.Requests[corev1.ResourceEphemeralStorage]; !ok {
+		t.Error("ephemeral-storage request not set")
+	} else if req.Cmp(*expectedEphemeral) != 0 {
+		t.Errorf("expected ephemeral-storage request %s, got %s", expectedEphemeral.String(), req.String())
+	}
+	if lim, ok := container.Resources.Limits[corev1.ResourceEphemeralStorage]; !ok {
+		t.Error("ephemeral-storage limit not set")
+	} else if lim.Cmp(*expectedEphemeral) != 0 {
+		t.Errorf("expected ephemeral-storage limit %s, got %s", expectedEphemeral.String(), lim.String())
+	}
+
 	// Check labels
 	if job.Labels["etcd.aenix.io/etcdbackup-name"] != "my-backup" {
 		t.Errorf("expected label etcd.aenix.io/etcdbackup-name=my-backup, got %q", job.Labels["etcd.aenix.io/etcdbackup-name"])
@@ -363,3 +377,92 @@ func TestCreateBackupJob_PVCSubPath(t *testing.T) {
 		t.Errorf("expected PVC_BACKUP_PATH=%q, got %q", expected, envMap["PVC_BACKUP_PATH"].Value)
 	}
 }
+
+func TestGetEffectiveDBQuota(t *testing.T) {
+	tests := []struct {
+		name     string
+		cluster  *etcdaenixiov1alpha1.EtcdCluster
+		expected int64
+	}{
+		{
+			name: "explicit quota-backend-bytes",
+			cluster: &etcdaenixiov1alpha1.EtcdCluster{
+				Spec: etcdaenixiov1alpha1.EtcdClusterSpec{
+					Options: map[string]string{"quota-backend-bytes": "8589934592"}, // 8Gi
+					Storage: etcdaenixiov1alpha1.StorageSpec{
+						EmptyDir: &corev1.EmptyDirVolumeSource{},
+					},
+				},
+			},
+			expected: 8589934592,
+		},
+		{
+			name: "derived from EmptyDir SizeLimit",
+			cluster: &etcdaenixiov1alpha1.EtcdCluster{
+				Spec: etcdaenixiov1alpha1.EtcdClusterSpec{
+					Storage: etcdaenixiov1alpha1.StorageSpec{
+						EmptyDir: &corev1.EmptyDirVolumeSource{
+							SizeLimit: ptr.To(resource.MustParse("4Gi")),
+						},
+					},
+				},
+			},
+			expected: 4 * 1024 * 1024 * 1024, // 4Gi
+		},
+		{
+			name: "derived from PVC storage request",
+			cluster: &etcdaenixiov1alpha1.EtcdCluster{
+				Spec: etcdaenixiov1alpha1.EtcdClusterSpec{
+					Storage: etcdaenixiov1alpha1.StorageSpec{
+						VolumeClaimTemplate: etcdaenixiov1alpha1.EmbeddedPersistentVolumeClaim{
+							Spec: corev1.PersistentVolumeClaimSpec{
+								Resources: corev1.VolumeResourceRequirements{
+									Requests: corev1.ResourceList{
+										corev1.ResourceStorage: resource.MustParse("10Gi"),
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+			expected: 10 * 1024 * 1024 * 1024, // 10Gi
+		},
+		{
+			name: "EmptyDir without SizeLimit falls back to etcd default",
+			cluster: &etcdaenixiov1alpha1.EtcdCluster{
+				Spec: etcdaenixiov1alpha1.EtcdClusterSpec{
+					Storage: etcdaenixiov1alpha1.StorageSpec{
+						EmptyDir: &corev1.EmptyDirVolumeSource{},
+					},
+				},
+			},
+			expected: 2 * 1024 * 1024 * 1024, // 2Gi
+		},
+		{
+			name: "invalid quota-backend-bytes falls through to storage size",
+			cluster: &etcdaenixiov1alpha1.EtcdCluster{
+				Spec: etcdaenixiov1alpha1.EtcdClusterSpec{
+					Options: map[string]string{"quota-backend-bytes": "not-a-number"},
+					Storage: etcdaenixiov1alpha1.StorageSpec{
+						EmptyDir: &corev1.EmptyDirVolumeSource{
+							SizeLimit: ptr.To(resource.MustParse("4Gi")),
+						},
+					},
+				},
+			},
+			expected: 4 * 1024 * 1024 * 1024, // 4Gi
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := getEffectiveDBQuota(tt.cluster)
+			expectedQ := resource.NewQuantity(tt.expected, resource.BinarySI)
+			if got.Cmp(*expectedQ) != 0 {
+				t.Errorf("expected %s (%d bytes), got %s (%d bytes)",
+					expectedQ.String(), tt.expected, got.String(), got.Value())
+			}
+		})
+	}
+}