Running Helm?

Helm charts stuck or values sprawl? We clear the backlog.

Helm starts tidy and ends with fourteen values files per environment, a chart that imports three subcharts you cannot find the source for, and a release wedged in pending-upgrade since last quarter. We bring the chart tree back to something a new engineer can read in an afternoon, and we unstick the releases without resetting history.

  • Since 2015Fixing technology
  • FreeEstimates
  • US teamReal engineers

helm-upgrade.log

still failing

What it is

Helm at a glance

Helm is the package manager for Kubernetes: it bundles related manifests into a chart, substitutes values into templates, and tracks what it has installed as a named release in the cluster. The project started at Deis in 2016 and now lives under the Cloud Native Computing Foundation. Helm 3, released in 2019, removed the server-side Tiller component and pushed everything into the client.

A chart is a directory with templates, a Chart.yaml metadata file, a default values.yaml, and optionally subcharts under charts/. Running helm install or helm upgrade renders the templates with the supplied values and applies the result to the cluster, while Helm records a release secret in the target namespace so it can roll back later. The dominant workflows today are either plain Helm from a CI job, Argo CD with Helm as the templating engine, or Flux using HelmReleases as custom resources.

Type
Package manager and templating tool for Kubernetes
First released
2016 (Helm 1); Helm 3 in November 2019
License
Apache 2.0, open source
Maintained by
The Helm community under the CNCF
Typically used for
Packaging Kubernetes manifests, installing off-the-shelf charts, parameterizing deployments across environments

The honest version

Helm pros and cons

No technology is all upside. This is where Helm earns its place and where it tends to cause trouble.

Where Helm is strong

  • The default way to install Kubernetes softwareIngress controllers, cert-manager, Prometheus, Postgres operators and nearly every CNCF project ship a chart. Bringing them in with helm install is faster than copying raw manifests.
  • Templating with real functionsGo templates plus the Sprig function library can express conditionals, loops, defaults and merging logic that plain manifests cannot.
  • Release history and rollbackEvery release is a snapshot. helm rollback goes back to a known good revision without needing to remember what the previous manifests were.
  • Values files per environmentA single chart, four values files, four environments. Changes land in one place rather than being copied across directories.
  • Argo CD and Flux both understand itHelm charts fit into either GitOps controller without a conversion step, which keeps the workflow consistent across teams.
  • OCI registry support is production-readyCharts can be pushed to Docker Hub, GHCR, ECR or Harbor as OCI artifacts, so the chart distribution problem reuses the container registry you already have.

Where Helm bites

  • Go template errors are miserable to debugA missing value nested three levels deep produces a line number but not a clear explanation. Engineers who have not written Helm before spend hours on things that would be a one-line schema check in other tools.
  • Values sprawl is the default outcomeWithout a convention, teams end up with per environment, per region and per cluster values files that overlap and contradict each other. Finding which value is actually in effect is non-trivial.
  • Releases get stuck in pending statesAn interrupted upgrade leaves a release in pending-upgrade or pending-install. The next upgrade refuses to run until the state is manually cleared, which is not obvious from the error.
  • Chart dependencies are often unversioned in practiceCharts pin to major versions or to the latest stable, and transitive chart upgrades sneak breaking changes into otherwise unchanged repos.
  • Immutable field changes break upgradesChanging a label selector, a StatefulSet volume name, or any immutable Kubernetes field forces a delete-and-recreate that Helm does not handle gracefully on its own.
  • Helm 2 to Helm 3 remnants still existOlder clusters have Tiller secrets, abandoned release names, or charts written against the Helm 2 template dialect that need manual migration before they can be managed again.

Sound familiar?

Common Helm problems we fix

The Helm problems that bring people to us, and what you have once each one is fixed.

another operation is in progress

Release is stuck in pending-upgrade

An upgrade was interrupted by a CI timeout or a disconnected kubectl, leaving the release half-applied. Every subsequent attempt bails out with the same message.

Release unstuck, history intact

nil pointer evaluating .Values.image.tag

Template renders fail on missing values

A nested value in a subchart that the parent never set, or a required field that was renamed in a later chart version. The render dies and takes the deploy with it.

Templates render on every environment

field is immutable

Upgrade refuses to patch a resource

A selector or volume claim name that changed in the chart. Kubernetes rejects the patch and Helm has no built-in path to delete and recreate without data loss.

Resource migrated without downtime

release has no deployed releases

Rollback target is gone

Release history was trimmed below the point you wanted to roll back to, or the last successful revision was marked failed by a liveness probe. There is nowhere to roll back to.

History and probes aligned with real health

YAML parse error in configmap.yaml

Generated YAML is invalid

A template that produced unindented keys because a conditional branch dropped a leading space, or a multiline string that was not quoted. The chart renders but Kubernetes rejects the output.

Templates produce valid YAML every time

context deadline exceeded on --wait

Helm install hangs on readiness

A deployment whose readiness probe never passes, often because of a misconfigured health check path, or a pod stuck on an image pull. helm install --wait eventually times out with no clear reason.

Readiness probes that mean what they say

Chart.lock out of sync

Subchart versions drift from the lockfile

A Chart.yaml edited without rerunning helm dependency update, so CI pulls one version and local renders another. Behaviour differs between environments for no obvious reason.

Lockfile and chart in agreement

cannot overwrite table with non table

Values merge in ways you did not intend

An environment values file overriding a map with a scalar, or a list that gets replaced when the engineer expected it to be extended. Helm merges values with rules that are not always intuitive.

Values merge to a predictable shape

What we do

Helm help, from one stuck release to the whole chart library

Come to us for one wedged release, or hand us the whole chart repository.

Rescue
Releases stuck in pending-upgrade, templates that will not render, or chart dependencies that broke after an upstream bump. We unstick first and document after.
Chart hygiene
Values files consolidated, schema validation added, subcharts pinned, and a layout a new engineer can learn in an hour.
Upgrades and rollbacks
Chart upgrades rehearsed against a staging cluster, immutable field migrations planned, and rollbacks tested before a release night actually needs one.
OCI chart registries
Pushing charts to ECR, GHCR or Harbor with proper signing and provenance, replacing ad-hoc index files and S3 buckets.
GitOps integration
Argo CD or Flux set up to pull your charts with sensible sync windows, drift detection, and a clear path from a merge to a deploy.
Managed Tech
Charts kept current with upstream, release history pruned safely, and a team on hand when an upgrade decides to argue at the wrong moment.

How it works

From first message to fixed

  1. Look Free estimate

    Tell us what's going wrong. We look at it, then tell you plainly what's wrong and what it will cost.

  2. Fix

    We fix the cause, not the symptom. If something is down, getting it back up comes first.

  3. Harden

    Backups, monitoring, updates and access, so the same problem can't quietly come back.

  4. Hand back or stay on

    You get a plain-language write-up. Or we stay on for hosting, upkeep and new work.

Often found together

Running Helm alongside something else?

We work on the whole stack, so the problem can be wherever it actually is.

Questions

Helm questions

Something else? Call+1 737 727 7327

Why is my Helm release stuck in pending-upgrade?

A previous helm upgrade was interrupted mid-run, usually because a CI job timed out or a kubectl session was disconnected. The release state in the cluster is left marked pending, and subsequent upgrades refuse to proceed. The fix is to either roll back to the last deployed revision or, when that is not available, to patch the release secret directly, which is best done with a backup and a careful plan.

Should we use Helm or plain Kubernetes manifests with Kustomize?

Helm earns its keep when you consume off-the-shelf charts or need runtime value substitution. Kustomize earns its keep when the manifests are mostly static with overlays. In practice many teams run both: Helm for third-party software, Kustomize for their own services. Picking one for everything is rarely worth the fight.

How do we handle immutable field changes in a chart upgrade?

Kubernetes blocks the patch, so the migration has to delete the resource and recreate it. For stateless services that is fine with a quick rolling window. For StatefulSets, PVCs and anything with persistent data, the plan has to preserve the data, usually by snapshotting the volume, deleting the resource, and reattaching the volume to the recreated one.

Can Helm charts live in a container registry like ECR?

Yes, Helm has supported OCI registries as a first-class chart store for several releases. Pushing to ECR, GHCR or Harbor avoids running a separate chart museum and reuses the IAM and signing you already have for images. The one catch is that older tooling may still expect an index.yaml and will not find it.

How do we stop values file sprawl across environments?

Start with a base values.yaml that carries the real defaults, and keep environment files as small as possible, ideally just the parts that actually differ. A schema file (values.schema.json) catches typos and shape drift at render time, which is where most of the sprawl pain actually bites.

How much does Helm help cost?

An estimate is free. Describe the chart, the error and the cluster target, and we return a scoped quote before any changes are drafted.

Free estimate

Helm giving you trouble?

Tell us what you're running and what's going wrong. A person reads it and comes back with an estimate.

  • No charge to find out what it will take
  • If it's urgent, say so

Replies come from a person. By sending, you authorize us to email you back. No marketing.