Integrating Helm Charts with Custom Operator Logic

Combine Helm templates with Operator reconciliation loops to manage complex stateful applications that require dynamic configuration and lifecycle orchestration.

In this lesson, you will learn how to leverage Helm’s templating power inside your custom Operators to reconcile complex, stateful applications that standard controllers struggle to manage.

Why Combine Helm and Operators?

While custom controllers are excellent for reacting to state changes, writing thousands of lines of Go code to manage nested Kubernetes manifests (like Deployments, Services, and PersistentVolumes) is error-prone. Helm is purpose-built for templating these resource sets. By embedding a Helm chart within your Operator’s reconciliation loop, you get the best of both worlds: the declarative simplicity of Helm charts and the intelligent, programmatic lifecycle management of a custom Operator.

The Reconciliation Strategy

Instead of using client.Create for every resource in your reconciliation logic, your Operator acts as a "Helm Controller." You can use the Helm SDK or the controller-runtime to trigger a Helm install/upgrade based on your Custom Resource (CR) state.

Consider a scenario where your Operator manages a distributed database. You define a Database CR, and when the Reconcile function triggers, it dynamically injects the CR’s status into the Helm chart's values.yaml file:

func (r *DatabaseReconciler) Reconcile(ctx context.Context, req ctrl.Request) (ctrl.Result, error) {
    // 1. Fetch the Custom Resource
    db := &myv1alpha1.Database{}
    r.Get(ctx, req.NamespacedName, db)

    // 2. Map CR fields to Helm values
    helmValues := map[string]interface{}{
        "replicaCount": db.Spec.Size,
        "storageClass": db.Spec.Storage,
    }

    // 3. Trigger Helm release management
    // The Operator ensures the Helm release matches the desired CR state
    err := r.helmManager.UpgradeRelease(db.Name, "my-db-chart", helmValues)
    return ctrl.Result{}, err
}

When to Use This Pattern

This approach is ideal for complex stateful applications where the configuration depends on cluster-specific data or runtime metrics. By using Helm, you keep your manifests maintainable and versioned, while your Operator provides the "glue" that triggers upgrades, handles rollbacks, or performs pre-flight checks that Helm alone cannot handle during an automated deployment.

Key Takeaway: Integrating Helm charts into your Operator allows you to use Helm’s templating engine to manage complex resources while keeping your reconciliation logic focused on higher-level orchestration and state validation.