Kubernetes Operator Patterns for Stateful Workloads

Why Operators?

Kubernetes excels at stateless workloads. But databases, message queues, and ML training jobs require domain-specific orchestration knowledge. Operators encode this knowledge as code.

The Reconciliation Loop

Every operator centers around the reconciliation pattern:

func (r DatabaseReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
    var db v1alpha1.Database
    if err := r.Get(ctx, req.NamespacedName, &db); err != nil {
        return ctrl.Result{}, client.IgnoreNotFound(err)
    }
// Desired state
    desired := r.buildDesiredState(&db)
// Current state
    current, err := r.getCurrentState(ctx, &db)
    if err != nil {
        return ctrl.Result{}, err
    }
// Reconcile diff
    actions := r.computeActions(desired, current)
    for _, action := range actions {
        if err := action.Execute(ctx); err != nil {
            return ctrl.Result{RequeueAfter: 30  time.Second}, err
        }
    }
return ctrl.Result{}, nil
}

Key Patterns

Level-triggered, not edge-triggered — React to current state, not events

Idempotent operations — Every reconciliation should be safe to repeat

Status subresource — Separate spec (desired) from status (observed)

Finalizers — Clean up external resources on deletion

These patterns ensure your operator behaves correctly even in the face of restarts, network partitions, and concurrent modifications.