Operator Pattern

A Custom Resource Definition extends the Kubernetes API, allowing users to define their own resource types. For an Operator, the CRD defines the desired state of the application it manages. This object becomes the primary interface for users, encapsulating complex application configuration into a declarative spec.

• Example: A Database CRD with fields for replicas, storageSize, and version.
• The API server stores and serves these objects, providing standard features like kubectl get and RBAC.

The custom controller is the core automation engine. It implements a reconciliation control loop that continuously observes the state of both the custom resources and the underlying Kubernetes objects (like Pods, Services). Its job is to drive the actual state toward the desired state declared in the CR.

• It watches for events (create, update, delete) on relevant resources.
• It contains the domain logic (e.g., how to provision, scale, backup, or upgrade the application).
• It is typically deployed as a Pod within the cluster.

The reconciliation loop is the fundamental pattern executed by the controller. It is a non-blocking, event-driven process that ensures system stability.

1. Observe: Fetch the current state of the custom resource and any related Kubernetes or external resources.
2. Analyze: Compare the observed state against the desired state specified in the custom resource's spec.
3. Act: If a difference (a drift) is detected, execute imperative actions—like creating a Deployment, updating a ConfigMap, or running a backup job—to converge the states.

This loop makes the system self-healing and declarative.

Finalizers are keys on a Kubernetes object that block its deletion. Operators use them to implement pre-deletion hooks, ensuring orderly cleanup of external resources before the custom resource is removed from the API server.

• Example: Before deleting a Database CR, the operator must first delete the associated cloud storage volumes and snapshots.
• The controller removes its finalizer only after cleanup is complete, allowing Kubernetes garbage collection to proceed.

This prevents orphaned resources and is critical for managing stateful applications.

The status subresource of a custom resource is a dedicated field for the operator to write observed state, separate from the user-provided spec. This is where operators communicate the health and phase of the managed application.

• Conditions: A standard pattern within status is an array of conditions (e.g., type: Ready, status: "True", lastTransitionTime, reason, message).
• This allows users and other automation tools to query the operational state: kubectl get database -o jsonpath='{.status.conditions}'.
• It provides a clear, machine-readable history of state transitions.

State Reconciliation is the continuous control loop process by which a controller observes the actual state of the system and takes corrective actions to drive it toward the declared desired state.

• Declarative Model: The user declares the desired end state (in the spec).
• Observe-Diff-Act: The controller observes reality, computes a diff, and executes imperative actions.
• Self-Healing: This loop enables automated recovery from failures, pod crashes, or node outages.

Declarative Configuration is a paradigm where a user specifies the desired end state of a system, and the orchestration platform is responsible for continuously reconciling the actual state to match that declared specification.

• Contrast with Imperative: The user says "what" (run 3 replicas) not "how" (run 1, then scale to 3).
• Kubernetes Native: All Kubernetes objects (Deployments, Services, CRDs) are managed declaratively.
• Operator Foundation: Operators apply this paradigm to complex applications, encoding the "how" within the controller's logic.

A Custom Controller is a software component that implements the control logic for one or more Custom Resource Definitions. It is the imperative brain that gives an operator its domain-specific intelligence.

• Domain Knowledge Encoder: Contains the operational know-how for a specific application (e.g., how to backup a database, upgrade an Edge AI model).
• Client Libraries: Typically built using the controller-runtime library and the client-go Kubernetes Go client.
• Watches and Queues: Efficiently watches for changes to relevant resources and processes them via a work queue.