The Kubernetes community is no stranger to debates, and few topics spark as much spirited discussion as the choice between Helm and Kustomize. With passionate advocates on both sides, the debate often feels like choosing between two rival camps, each convinced of their tool’s superiority. Some swear by Helm’s powerful templating and ecosystem, while others champion Kustomize’s simplicity and declarative approach. But why not embrace the strengths of both? In this post, we’ll explore Helm and Kustomize, discuss their pros and cons, provide examples, and highlight helmify-kustomize, an innovative tool developed by KoalaOps that bridges the gap and offers the best of both worlds.

What Is Helm?

Helm is often referred to as the “package manager for Kubernetes.” It simplifies the deployment of Kubernetes applications by using reusable, parameterized templates called Helm charts.

Key Features of Helm:

1. Templating System: Uses Go templates to allow dynamic, reusable configurations.

2. Chart Ecosystem: Thousands of prebuilt charts for popular applications like nginx, Prometheus, and PostgreSQL.

3. Release Management: Tracks deployments as “releases,” enabling version control and rollbacks.

4. Dependency Management: Allows bundling and managing interdependent services.

Pros of Helm:

• Quick deployment with minimal setup using prebuilt charts.

• Built-in release/version control.

• Highly parameterized configurations for complex applications.

Cons of Helm:

• Go templates can be difficult to debug and maintain, especially as they often become large and complex.

• The complexity of Helm often leads to specialization, where only a handful of team members are equipped to manage intricate charts and templates.

• Teams frequently centralize a "base chart" as a single source of truth, which can become overly rigid and difficult for developers to adapt to their specific needs, limiting team autonomy.

• Secrets management requires external tools like SealedSecrets or SOPS.

• Tight coupling to Helm’s chart structure.

Example: Deploying a Stateless Application with Helm

helm repo add bitnami https://charts.bitnami.com/bitnami
helm install my-nginx bitnami/nginx \
  --set service.type=ClusterIP

This example demonstrates how Helm simplifies the deployment of stateless applications like nginx. With a single command, you can configure and deploy the application, making it a great option for services that require minimal ongoing management.

What Is Kustomize?

Kustomize is a declarative configuration management tool integrated directly into kubectl. It focuses on overlaying and patching existing YAML manifests.

Key Features of Kustomize:

1. Overlay System: Provides a mechanism to customize YAML manifests for different environments (e.g., dev, prod).

2. No Templating: Uses a purely declarative approach, avoiding logic within YAML files.

3. Resource Generators: Dynamically generate ConfigMaps and Secrets.

4. Targeted Patching: Patches enable targeted replacements or updates in YAML files, acting as a lightweight alternative to templating. This is a cornerstone of Kustomize's overlay system, offering flexibility without the complexity of embedded logic.

Pros of Kustomize:

• Simpler, no need to learn templating languages.

• Easy to manage environment-specific configurations.

• Integrated into native Kubernetes tooling (kubectl apply -k).

Cons of Kustomize:

• No built-in release management or versioning.

• Lacks Helm’s ecosystem of prebuilt charts.

• Can become verbose for larger applications.

Example: Customizing a Deployment with Kustomize

Base Manifest (deployment.yaml):

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 2
  template:
    spec:
      containers:
      - name: my-app-container
        image: my-app:latest

Dev Overlay (kustomization.yaml):

resources:
- ../base
patches:
- op: replace
  path: /spec/replicas
  value: 1
Apply the dev configuration:
kubectl apply -k dev

This approach avoids mixing logic with YAML, making it straightforward to manage.

Helm vs. Kustomize: A Direct Comparison

FeatureHelmKustomizePurposePackage manager for KubernetesDeclarative YAML customizationTemplatingGo templatesNo templatingCommunity EcosystemExtensive prebuilt chartsNo predefined templatesRelease ManagementYesNoIntegrationExternal toolBuilt into kubectlEnvironment ManagementValues files for environmentsOverlays for environmentsComplexityHigh for custom templatesSimple and declarative

Why Helm Templating Can Be Complex

Helm uses Go templates, which introduce logic into YAML files. This flexibility often results in complex configurations. Here’s just one small example of a very basic Kubernetes Deployment where the helm template already becomes tricky to read and modify for non-experts, compared to plain Kubernetes YAMLs:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ .Values.appName }}
spec:
  replicas: {{ .Values.replicas | default 2 }}
  template:
    spec:
      containers:
      - name: {{ .Values.containerName }}
        image: {{ .Values.image.repository }}:{{ .Values.image.tag | default "latest" }}
        env:
        {{- range $key, $value := .Values.env }}
        - name: {{ $key }}
          value: {{ $value }}
        {{- end }}
      {{- if .Values.resources }}
      resources:
        {{- if .Values.resources.requests }}
        requests:
          cpu: {{ .Values.resources.requests.cpu | default "100m" }}
          memory: {{ .Values.resources.requests.memory | default "128Mi" }}
        {{- end }}
        {{- if .Values.resources.limits }}
        limits:
          cpu: {{ .Values.resources.limits.cpu | default "200m" }}
          memory: {{ .Values.resources.limits.memory | default "256Mi" }}
        {{- end }}
      {{- end }}

In this example:

• Logic includes conditional statements (if/else) for resource limits and requests.

• Default values are provided using functions like default.

• Iterations over environment variables (range) introduce additional complexity.

This level of flexibility allows for highly customizable configurations but makes debugging and maintenance challenging for teams. While this approach is powerful, it mixes YAML with programming logic, making debugging and maintenance harder.

Helmify-Kustomize: Bridging Helm and Kustomize

At KoalaOps, we developed helmify-kustomize, an open-source tool to bridge the gap between Kustomize and Helm, allowing you to leverage the best of both tools. This tool automates the process of converting multiple Kustomize overlays into a single Helm chart, simplifying Kubernetes configuration management at scale. You can explore the tool and contribute to its development on GitHub.

Why We Built It

At KoalaOps, we noticed a clear trend among our customers:

• Many preferred using Helm for external tools and cluster add-ons, appreciating its rich ecosystem and robust release management.

• For internal development workflows, however, Kustomize’s simplicity and declarative nature were favored.

However, customers consistently asked for features that neither tool could fully address on its own, such as:

• Versioning support for Kustomize configurations.

• A way to avoid "Helm complexity hell" while retaining its conveniences for deployment.

To address these needs, we created helmify-kustomize—a tool that allows teams to enjoy the strengths of both tools without compromising on usability or functionality.

Our vision for helmify-kustomize was to combine these strengths seamlessly. By leveraging Kustomize to handle intricate internal configurations and Helm to manage external deployments, we empower teams to:

• Use Kustomize for their own code where agility and clarity are paramount. This allows individual teams greater independence to modify their Kubernetes resources without being blocked by the cons of Helm charts that are mentioned above.

• Use Helm for external tools and cluster add-ons, leveraging its robust release management and community chart ecosystem. This approach ensures alignment with the standardized workflows and deployment processes required by SREs and DevOps, maintaining stability and operational consistency.

Benefits of Helmify-Kustomize:

helmify-kustomize enables teams to seamlessly use Kustomize for its simplicity and declarative nature while leveraging Helm’s robust ecosystem and release management capabilities. This parallel usage allows developers to retain the independence and clarity of Kustomize for internal configurations, while aligning with Helm’s standardized workflows for production deployments.

• Leverages Kustomize internally for flexibility and independent management of Kubernetes resources.

• Uses Helm externally for stability, ensuring compatibility with standardized deployment workflows and offering robust release management.

• Access to Helm’s Tooling Ecosystem: Enables use of Helm’s features like release management and community charts.

Example Workflow

Starting Point (Kustomize Overlays):

kustomize/
  base/
    deployment.yaml
  overlays/
    dev
      kustomization.yaml
    prod
      kustomization.yaml

After Conversion (Helm Chart):

chart/
  Chart.yaml
  templates/
    deployment.yaml
  values.yaml

Who Should Use Helmify-Kustomize?

• Organizations seeking simplicity and control: Ideal for unifying Kubernetes configurations without sacrificing flexibility or consistency.

• Developers combining tools: Perfect for those who value Kustomize’s clarity and Helm’s powerful templating and release management.

• Teams managing diverse needs: Enables agile internal configurations while standardizing external deployments.

Conclusion

With helmify-kustomize, KoalaOps resolves the tradeoff between Helm and Kustomize by seamlessly combining their strengths. Teams gain the simplicity and flexibility of Kustomize for internal configurations, alongside Helm’s robust ecosystem and release management for production workflows.

This unified approach allows developers the freedom to adapt Kubernetes resources while ensuring consistency and reliability in deployment workflows. By bridging these tools, we empower teams to deliver efficiently and effectively. Explore how helmify-kustomize can streamline your Kubernetes management with ease and precision.