This change mostly consists of three parts:

1. A MachinePool lifecycle controller:

Implements `machinepool-lifecycle-controller` monitoring MachinePool health, with corresponding API additions for MachinePool/VolumePool/BucketPool conditions, codegen updates

2. A pool health heartbeat runnable in the machinepoollet:

The poollet now actively reports pool liveness so the lifecycle controller can set pools whose poollets have gone away to Unknown. It also includes kustomizations adding the Lease namespace and RBAC adjustments.
The MachinePoolHeartbeat, a ticker-driven Runnable that probes the IRI runtime via Status, renews the pool's Lease in ironcore-machinepool-lease, and patches Ready only when its value or observedGeneration actually changes. Errors on either sub-step are logged and retried on the next tick; the lifecycle controller's grace period absorbs short blips. Lease takeover from a previous holder is logged at Info. Contains app arguments that make the heartbeat intervals configurable, defaulting to the IEP-15 values.

3. Lease namespaces and RBACs

Contributes to #1472

Author: friegger

Makefile

@@ -358,7 +358,7 @@ PROTOC_GEN_GO_GRPC ?= $(LOCALBIN)/protoc-gen-go-grpc
 
 ## Tool Versions
 KUSTOMIZE_VERSION ?= v5.1.1
-VGOPATH_VERSION ?= v0.1.3
+VGOPATH_VERSION ?= v0.1.10
 CONTROLLER_TOOLS_VERSION ?= v0.20.0
 GEN_CRD_API_REFERENCE_DOCS_VERSION ?= v0.3.0
 ADDLICENSE_VERSION ?= v1.1.1

api/compute/v1alpha1/common.go

@@ -9,6 +9,10 @@ import (
 	corev1 "k8s.io/api/core/v1"
 )
 
+const (
+	NamespaceMachinePoolLease = "ironcore-machinepool-lease"
+)
+
 const (
 	MachineMachinePoolRefNameField  = "spec.machinePoolRef.name"
 	MachineMachineClassRefNameField = "spec.machineClassRef.name"

api/compute/v1alpha1/conditions.go

@@ -0,0 +1,46 @@
+// SPDX-FileCopyrightText: 2026 SAP SE or an SAP affiliate company and IronCore contributors
+// SPDX-License-Identifier: Apache-2.0
+
+package v1alpha1
+
+import (
+	"slices"
+
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+// FindMachinePoolCondition returns a pointer to the condition of the given type,
+// or nil if no condition of that type is present.
+func FindMachinePoolCondition(conditions []MachinePoolCondition, typ MachinePoolConditionType) *MachinePoolCondition {
+	idx := slices.IndexFunc(conditions, func(cond MachinePoolCondition) bool {
+		return cond.Type == typ
+	})
+	if idx < 0 {
+		return nil
+	}
+	return &conditions[idx]
+}
+
+// SetMachinePoolCondition inserts or updates a condition of the given type in the
+// conditions slice. LastUpdateTime is always set to now. LastTransitionTime is set
+// to now only when the condition is newly inserted or its Status differs from the
+// previous value.
+func SetMachinePoolCondition(conditions []MachinePoolCondition, cond MachinePoolCondition) []MachinePoolCondition {
+	idx := slices.IndexFunc(conditions, func(c MachinePoolCondition) bool {
+		return c.Type == cond.Type
+	})
+
+	cond.LastUpdateTime = metav1.Now()
+
+	if idx < 0 || conditions[idx].Status != cond.Status {
+		cond.LastTransitionTime = metav1.Now()
+	} else {
+		cond.LastTransitionTime = conditions[idx].LastTransitionTime
+	}
+
+	if idx < 0 {
+		return append(conditions, cond)
+	}
+	conditions[idx] = cond
+	return conditions
+}

api/compute/v1alpha1/conditions_test.go

@@ -0,0 +1,83 @@
+// SPDX-FileCopyrightText: 2026 SAP SE or an SAP affiliate company and IronCore contributors
+// SPDX-License-Identifier: Apache-2.0
+
+package v1alpha1_test
+
+import (
+	"testing"
+	"time"
+
+	computev1alpha1 "github.com/ironcore-dev/ironcore/api/compute/v1alpha1"
+	corev1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+)
+
+func TestFindMachinePoolCondition_returnsMatch(t *testing.T) {
+	conds := []computev1alpha1.MachinePoolCondition{
+		{Type: "Other", Status: corev1.ConditionTrue},
+		{Type: computev1alpha1.MachinePoolReady, Status: corev1.ConditionFalse, Reason: "X"},
+	}
+	got := computev1alpha1.FindMachinePoolCondition(conds, computev1alpha1.MachinePoolReady)
+	if got == nil || got.Reason != "X" {
+		t.Fatalf("expected Ready condition with reason X, got %+v", got)
+	}
+}
+
+func TestFindMachinePoolCondition_returnsNilWhenMissing(t *testing.T) {
+	conds := []computev1alpha1.MachinePoolCondition{{Type: "Other"}}
+	if got := computev1alpha1.FindMachinePoolCondition(conds, computev1alpha1.MachinePoolReady); got != nil {
+		t.Fatalf("expected nil, got %+v", got)
+	}
+}
+
+func TestSetMachinePoolCondition_appendsWhenAbsent(t *testing.T) {
+	out := computev1alpha1.SetMachinePoolCondition(nil, computev1alpha1.MachinePoolCondition{
+		Type:   computev1alpha1.MachinePoolReady,
+		Status: corev1.ConditionTrue,
+	})
+	if len(out) != 1 || out[0].Type != computev1alpha1.MachinePoolReady {
+		t.Fatalf("expected Ready appended, got %+v", out)
+	}
+	if out[0].LastTransitionTime.IsZero() {
+		t.Fatal("expected LastTransitionTime to be set on first append")
+	}
+	if out[0].LastUpdateTime.IsZero() {
+		t.Fatal("expected LastUpdateTime to be set on first append")
+	}
+}
+
+func TestSetMachinePoolCondition_updatesInPlaceWithoutTransition(t *testing.T) {
+	earlier := metav1.NewTime(time.Now().Add(-time.Hour))
+	in := []computev1alpha1.MachinePoolCondition{{
+		Type:               computev1alpha1.MachinePoolReady,
+		Status:             corev1.ConditionTrue,
+		LastTransitionTime: earlier,
+	}}
+	out := computev1alpha1.SetMachinePoolCondition(in, computev1alpha1.MachinePoolCondition{
+		Type:    computev1alpha1.MachinePoolReady,
+		Status:  corev1.ConditionTrue, // same status
+		Message: "still ready",
+	})
+	if !out[0].LastTransitionTime.Equal(&earlier) {
+		t.Fatalf("expected LastTransitionTime preserved when status unchanged, got %v", out[0].LastTransitionTime)
+	}
+	if out[0].LastUpdateTime.IsZero() {
+		t.Fatal("expected LastUpdateTime advanced")
+	}
+}
+
+func TestSetMachinePoolCondition_advancesTransitionWhenStatusChanges(t *testing.T) {
+	earlier := metav1.NewTime(time.Now().Add(-time.Hour))
+	in := []computev1alpha1.MachinePoolCondition{{
+		Type:               computev1alpha1.MachinePoolReady,
+		Status:             corev1.ConditionTrue,
+		LastTransitionTime: earlier,
+	}}
+	out := computev1alpha1.SetMachinePoolCondition(in, computev1alpha1.MachinePoolCondition{
+		Type:   computev1alpha1.MachinePoolReady,
+		Status: corev1.ConditionFalse,
+	})
+	if out[0].LastTransitionTime.Equal(&earlier) {
+		t.Fatal("expected LastTransitionTime to advance when status changes")
+	}
+}

api/compute/v1alpha1/machinepool_types.go

@@ -85,6 +85,11 @@ type MachinePoolAddress struct {
 // MachinePoolConditionType is a type a MachinePoolCondition can have.
 type MachinePoolConditionType string
 
+const (
+	// MachinePoolReady means the machine pool is healthy and ready to accept machines.
+	MachinePoolReady MachinePoolConditionType = "Ready"
+)
+
 // MachinePoolCondition is one of the conditions of a MachinePool.
 type MachinePoolCondition struct {
 	// Type is the type of the condition.
@@ -97,6 +102,8 @@ type MachinePoolCondition struct {
 	Message string `json:"message"`
 	// ObservedGeneration represents the .metadata.generation that the condition was set based upon.
 	ObservedGeneration int64 `json:"observedGeneration,omitempty"`
+	// LastUpdateTime is the last time this condition was updated.
+	LastUpdateTime metav1.Time `json:"lastUpdateTime,omitempty"`
 	// LastTransitionTime is the last time the status of a condition has transitioned from one state to another.
 	LastTransitionTime metav1.Time `json:"lastTransitionTime,omitempty"`
 }

api/compute/v1alpha1/zz_generated.deepcopy.go

@@ -22,11 +22,38 @@ type BucketPoolSpec struct {
 // BucketPoolStatus defines the observed state of BucketPool
 type BucketPoolStatus struct {
 	// State represents the infrastructure state of a BucketPool.
-	State BucketPoolState `json:"state,omitempty"`
+	State      BucketPoolState       `json:"state,omitempty"`
+	Conditions []BucketPoolCondition `json:"conditions,omitempty"`
 	// AvailableBucketClasses list the references of any supported BucketClass of this pool
 	AvailableBucketClasses []corev1.LocalObjectReference `json:"availableBucketClasses,omitempty"`
 }
 
+// BucketPoolConditionType is a type a BucketPoolCondition can have.
+type BucketPoolConditionType string
+
+const (
+	// BucketPoolReady means the bucket pool is healthy and ready to accept buckets.
+	BucketPoolReady BucketPoolConditionType = "Ready"
+)
+
+// BucketPoolCondition is one of the conditions of a BucketPool.
+type BucketPoolCondition struct {
+	// Type is the type of the condition.
+	Type BucketPoolConditionType `json:"type"`
+	// Status is the status of the condition.
+	Status corev1.ConditionStatus `json:"status"`
+	// Reason is a machine-readable indication of why the condition is in a certain state.
+	Reason string `json:"reason"`
+	// Message is a human-readable explanation of why the condition has a certain reason / state.
+	Message string `json:"message"`
+	// ObservedGeneration represents the .metadata.generation that the condition was set based upon.
+	ObservedGeneration int64 `json:"observedGeneration,omitempty"`
+	// LastUpdateTime is the last time this condition was updated.
+	LastUpdateTime metav1.Time `json:"lastUpdateTime,omitempty"`
+	// LastTransitionTime is the last time the status of a condition has transitioned from one state to another.
+	LastTransitionTime metav1.Time `json:"lastTransitionTime,omitempty"`
+}
+
 type BucketPoolState string
 
 const (

api/storage/v1alpha1/bucketpool_types.go

@@ -5,6 +5,11 @@ package v1alpha1
 
 import corev1 "k8s.io/api/core/v1"
 
+const (
+	NamespaceVolumePoolLease = "ironcore-volumepool-lease"
+	NamespaceBucketPoolLease = "ironcore-bucketpool-lease"
+)
+
 const (
 	VolumeVolumePoolRefNameField     = "spec.volumePoolRef.name"
 	VolumeVolumeClassRefNameField    = "spec.volumeClassRef.name"

api/storage/v1alpha1/common.go

@@ -43,6 +43,11 @@ const (
 // VolumePoolConditionType is a type a VolumePoolCondition can have.
 type VolumePoolConditionType string
 
+const (
+	// VolumePoolReady means the volume pool is healthy and ready to accept volumes.
+	VolumePoolReady VolumePoolConditionType = "Ready"
+)
+
 // VolumePoolCondition is one of the conditions of a volume.
 type VolumePoolCondition struct {
 	// Type is the type of the condition.
@@ -55,6 +60,8 @@ type VolumePoolCondition struct {
 	Message string `json:"message"`
 	// ObservedGeneration represents the .metadata.generation that the condition was set based upon.
 	ObservedGeneration int64 `json:"observedGeneration,omitempty"`
+	// LastUpdateTime is the last time this condition was updated.
+	LastUpdateTime metav1.Time `json:"lastUpdateTime,omitempty"`
 	// LastTransitionTime is the last time the status of a condition has transitioned from one state to another.
 	LastTransitionTime metav1.Time `json:"lastTransitionTime,omitempty"`
 }