Add architecture hints to ephemeral volumes

api/common/v1alpha1/common_types.go

@@ -32,6 +32,9 @@ const (
 	// some ephemeral controller is managing the resource.
 	EphemeralManagedByAnnotation = "common.ironcore.dev/ephemeral-managed-by"
 
+	// MachineArchitectureLabel is a label that indicates the machine architecture.
+	MachineArchitectureLabel = "common.ironcore.dev/architecture"
+
 	// DefaultEphemeralManager is the default ironcoreephemeral manager.
 	DefaultEphemeralManager = "ephemeral-manager"
 )

internal/controllers/compute/machine_ephemeralvolume_controller.go

@@ -9,16 +9,17 @@ import (
 	"fmt"
 	"maps"
 
-	"github.com/ironcore-dev/ironcore/poollet/machinepoollet/controllers/events"
-	"github.com/ironcore-dev/ironcore/utils/annotations"
-
 	"github.com/go-logr/logr"
+	commonv1alpha1 "github.com/ironcore-dev/ironcore/api/common/v1alpha1"
 	computev1alpha1 "github.com/ironcore-dev/ironcore/api/compute/v1alpha1"
 	storagev1alpha1 "github.com/ironcore-dev/ironcore/api/storage/v1alpha1"
 	computeclient "github.com/ironcore-dev/ironcore/internal/client/compute"
+	"github.com/ironcore-dev/ironcore/poollet/machinepoollet/controllers/events"
+	"github.com/ironcore-dev/ironcore/utils/annotations"
 	corev1 "k8s.io/api/core/v1"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/client-go/tools/record"
 	"k8s.io/klog/v2"
 	ctrl "sigs.k8s.io/controller-runtime"
@@ -130,6 +131,34 @@ func (r *MachineEphemeralVolumeReconciler) handleCreateVolume(ctx context.Contex
 	return r.handleExistingVolume(ctx, log, machine, true, volume)
 }
 
+func (r *MachineEphemeralVolumeReconciler) getMachineArchitecture(ctx context.Context, machine *computev1alpha1.Machine) (*string, error) {
+	machineClass := &computev1alpha1.MachineClass{}
+	if err := r.Get(ctx, types.NamespacedName{Name: machine.Spec.MachineClassRef.Name}, machineClass); err != nil {
+		return nil, fmt.Errorf("error getting machine class %s: %w", machine.Spec.MachineClassRef.Name, err)
+	}
+
+	architecture, ok := machineClass.Labels[commonv1alpha1.MachineArchitectureLabel]
+	if !ok {
+		return nil, nil
+	}
+
+	return &architecture, nil
+}
+
+func (r *MachineEphemeralVolumeReconciler) addArchitectureIfNeeded(log logr.Logger, volume *storagev1alpha1.Volume, architecture *string) {
+	if volume.Spec.DataSource.OSImage == nil || architecture == nil {
+		return
+	}
+
+	if volume.Spec.DataSource.OSImage.Architecture != nil {
+		log.V(2).Info("Architecture already set", "architecture", volume.Spec.DataSource.OSImage.Architecture)
+		return
+	}
+
+	log.V(2).Info("Adding architecture", "architecture", architecture)
+	volume.Spec.DataSource.OSImage.Architecture = architecture
+}
+
 func (r *MachineEphemeralVolumeReconciler) reconcile(ctx context.Context, log logr.Logger, machine *computev1alpha1.Machine) (ctrl.Result, error) {
 	log.V(1).Info("Reconcile")
 
@@ -141,6 +170,11 @@ func (r *MachineEphemeralVolumeReconciler) reconcile(ctx context.Context, log lo
 		return ctrl.Result{}, fmt.Errorf("error listing volumes: %w", err)
 	}
 
+	arch, err := r.getMachineArchitecture(ctx, machine)
+	if err != nil {
+		return ctrl.Result{}, fmt.Errorf("error getting machine architecture: %w", err)
+	}
+
 	var (
 		ephemVolumeByName = r.ephemeralMachineVolumeByName(machine)
 		errs              []error
@@ -157,6 +191,7 @@ func (r *MachineEphemeralVolumeReconciler) reconcile(ctx context.Context, log lo
 
 	for _, volume := range ephemVolumeByName {
 		log := log.WithValues("Volume", klog.KObj(volume))
+		r.addArchitectureIfNeeded(log, volume, arch)
 		if err := r.handleCreateVolume(ctx, log, machine, volume); err != nil {
 			if apierrors.IsForbidden(err) {
 				r.Eventf(machine, corev1.EventTypeNormal, events.VolumeNotReady, "Volume %s exceeded quota ", volume.Name)

internal/controllers/compute/machine_ephemeralvolume_controller_test.go

@@ -5,21 +5,25 @@ package compute
 
 import (
 	computev1alpha1 "github.com/ironcore-dev/ironcore/api/compute/v1alpha1"
+	corev1alpha1 "github.com/ironcore-dev/ironcore/api/core/v1alpha1"
 	storagev1alpha1 "github.com/ironcore-dev/ironcore/api/storage/v1alpha1"
 	"github.com/ironcore-dev/ironcore/utils/annotations"
 	. "github.com/ironcore-dev/ironcore/utils/testing"
 	. "github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega"
 	corev1 "k8s.io/api/core/v1"
 	apierrors "k8s.io/apimachinery/pkg/api/errors"
+	"k8s.io/apimachinery/pkg/api/resource"
 	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/utils/ptr"
 	ctrl "sigs.k8s.io/controller-runtime"
 	. "sigs.k8s.io/controller-runtime/pkg/envtest/komega"
 )
 
 var _ = Describe("MachineEphemeralVolumeController", func() {
 	ns := SetupNamespace(&k8sClient)
 	machineClass := SetupMachineClass()
+	volumeClass := SetupVolumeClass()
 
 	It("should manage ephemeral volumes for a machine", func(ctx SpecContext) {
 		By("creating a volume that will be referenced by the machine")
@@ -90,6 +94,58 @@ var _ = Describe("MachineEphemeralVolumeController", func() {
 		Eventually(Get(undesiredControlledVolume)).Should(Satisfy(apierrors.IsNotFound))
 	})
 
+	It("should manage ephemeral volumes for a machine and setting architecture hint", func(ctx SpecContext) {
+		By("creating a machine")
+		machine := &computev1alpha1.Machine{
+			ObjectMeta: metav1.ObjectMeta{
+				Namespace:    ns.Name,
+				GenerateName: "machine-",
+			},
+			Spec: computev1alpha1.MachineSpec{
+				MachineClassRef: corev1.LocalObjectReference{Name: machineClass.Name},
+				Volumes: []computev1alpha1.Volume{
+					{
+						Name: "ephem-volume",
+						VolumeSource: computev1alpha1.VolumeSource{
+							Ephemeral: &computev1alpha1.EphemeralVolumeSource{
+								VolumeTemplate: &storagev1alpha1.VolumeTemplateSpec{
+									Spec: storagev1alpha1.VolumeSpec{
+										VolumeClassRef: &corev1.LocalObjectReference{Name: volumeClass.Name},
+										Resources: corev1alpha1.ResourceList{
+											corev1alpha1.ResourceStorage: resource.MustParse("500Mi"),
+										},
+										DataSource: storagev1alpha1.VolumeDataSource{
+											OSImage: &storagev1alpha1.OSDataSource{
+												Image: "test-os-image",
+											},
+										},
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		}
+		Expect(k8sClient.Create(ctx, machine)).To(Succeed())
+
+		By("waiting for the ephemeral volume to exist")
+		ephemVolume := &storagev1alpha1.Volume{
+			ObjectMeta: metav1.ObjectMeta{
+				Namespace: ns.Name,
+				Name:      computev1alpha1.MachineEphemeralVolumeName(machine.Name, "ephem-volume"),
+			},
+		}
+		Eventually(Get(ephemVolume)).Should(Succeed())
+
+		Eventually(Object(ephemVolume)).Should(SatisfyAll(
+			HaveField("Spec.DataSource.OSImage", &storagev1alpha1.OSDataSource{
+				Image:        "test-os-image",
+				Architecture: ptr.To("amd64"),
+			}),
+		))
+	})
+
 	It("should not delete externally managed volumes for a machine", func(ctx SpecContext) {
 		By("creating a machine")
 		machine := &computev1alpha1.Machine{

internal/controllers/compute/suite_test.go

@@ -10,6 +10,8 @@ import (
 	"testing"
 	"time"
 
+	commonv1alpha1 "github.com/ironcore-dev/ironcore/api/common/v1alpha1"
+
 	"github.com/ironcore-dev/controller-utils/buildutils"
 	computev1alpha1 "github.com/ironcore-dev/ironcore/api/compute/v1alpha1"
 	corev1alpha1 "github.com/ironcore-dev/ironcore/api/core/v1alpha1"
@@ -177,6 +179,9 @@ func SetupMachineClass() *computev1alpha1.MachineClass {
 		*machineClass = computev1alpha1.MachineClass{
 			ObjectMeta: metav1.ObjectMeta{
 				GenerateName: "machine-class-",
+				Labels: map[string]string{
+					commonv1alpha1.MachineArchitectureLabel: "amd64",
+				},
 			},
 			Capabilities: corev1alpha1.ResourceList{
 				corev1alpha1.ResourceCPU:    resource.MustParse("1"),
@@ -185,3 +190,17 @@ func SetupMachineClass() *computev1alpha1.MachineClass {
 		}
 	})
 }
+
+func SetupVolumeClass() *storagev1alpha1.VolumeClass {
+	return SetupObjectStruct[*storagev1alpha1.VolumeClass](&k8sClient, func(volumeClass *storagev1alpha1.VolumeClass) {
+		*volumeClass = storagev1alpha1.VolumeClass{
+			ObjectMeta: metav1.ObjectMeta{
+				GenerateName: "volume-class-",
+			},
+			Capabilities: corev1alpha1.ResourceList{
+				corev1alpha1.ResourceIOPS: resource.MustParse("500"),
+				corev1alpha1.ResourceTPS:  resource.MustParse("500Mi"),
+			},
+		}
+	})
+}