Skip to content
Tutorials Center
My learning

Topics

Lesson 1 of 38 ยท Getting Started

What Is Helm? The Package Manager for Kubernetes

Learn what Helm is, which problems it solves for Kubernetes deployments, how templates and values work together, and when Helm is the right tool.

Kubernetes describes everything with YAML: Deployments, Services, ConfigMaps, Ingresses. A real application needs a dozen of these files, and the same application usually runs in several places (a laptop, a test cluster, production) with small differences in image tag, replica count or host name. Copying the files and editing them by hand does not scale. Helm is the tool that fixes this.

Helm is the package manager for Kubernetes. It bundles the YAML of an application into a chart, lets you customize it with values, installs it as a named release, and remembers every version so you can upgrade and roll back. If you know apt, npm or pip, the idea is familiar: one command installs a whole application together with everything it needs.

Helm and Kubernetes cannot run on this site, so the YAML and helm commands in this course are read-only. The TryIt blocks are small Python programs that reproduce what Helm does (templating, merging values, tracking revisions) so you can experiment with the logic. Each one is labelled as a stand-in.

The problem Helm solves

Imagine a small web app with a Deployment, a Service and an Ingress. Without Helm you keep three files, and every environment needs its own copy:

YAML
# deployment.yaml (staging copy)
apiVersion: apps/v1
kind: Deployment
metadata:
  name: shop-staging
spec:
  replicas: 1
  selector:
    matchLabels: {app: shop-staging}
  template:
    metadata:
      labels: {app: shop-staging}
    spec:
      containers:
        - name: shop
          image: registry.example.com/shop:1.4.2

Production differs only in the name, the replica count and maybe the tag. Multiply that by ten services and five environments and you maintain hundreds of nearly identical lines. A tag bump means editing many files; a forgotten edit means a broken environment.

Helm replaces the copies with one template and a small values file per environment. The values fill in the blanks.

Three ideas to remember

Helm in three ideas

Chart A package of templates plus defaults
Values Settings that fill the templates
Release One installed copy of a chart

Chart + values = release

1 / 2

A chart template is a YAML file with placeholders written in Go template syntax:

YAML
replicas: {{ .Values.replicaCount }}
image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"

A values file supplies the numbers and strings:

YAML
replicaCount: 3
image:
  repository: registry.example.com/shop
  tag: "1.4.2"

When you run helm install, Helm combines the two, produces plain Kubernetes manifests and sends them to the cluster. The cluster never sees a template, only ordinary YAML.

A first stand-in: values fill a template

The program below is not Helm; it is a 10-line imitation of the substitution step so you can see the idea without a cluster. It looks up dotted names such as .Values.image.tag in a nested dictionary.

Python Stand-in: render one template with values

Press Run (or Ctrl + Enter) to see the result here.

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with input()), it gets the next line from this box.

Change replicaCount or the tag and run it again. That is the entire trick, scaled up with conditionals, loops, helper functions and a lot of conventions.

One chart, many environments

The real benefit shows when the same template serves several environments. In Helm you keep one chart and one small values file per environment, then pick the file at install time with -f.

Python Stand-in: three environments from one template

Press Run (or Ctrl + Enter) to see the result here.

Program input ยท what you'd type while the program runs

Type the answers before you press Run, one per line. Each time the program reads a line (with input()), it gets the next line from this box.

Notice that dev only states what is special about it. Everything else comes from the chart's defaults. That layering, covered in Values and Overrides, is central to Helm.

What Helm does not do

Helm is a packaging and release tool. It is not a replacement for Kubernetes itself, and it has limits worth knowing early:

  • It does not build container images. Your CI system does that; Helm only references an image name and tag.
  • It templates text. It does not understand Kubernetes semantics, so a typo in a field name is only caught by the API server (or a linter, see the Testing chapter).
  • It manages objects it created. Changes made behind its back with kubectl edit can be overwritten at the next upgrade.
  • It is one option among several. Kustomize patches plain YAML without templates and is built into kubectl; many teams use Helm for third-party software and Kustomize or Helm for their own apps. GitOps tools such as Argo CD and Flux can drive Helm charts from Git.

If you can describe your application as "this YAML, with a few numbers changed per environment", Helm is probably more than you need. It pays off when you have conditionals, many resources, third-party charts, or a team that needs versioned, rollback-able releases.

Helm 3 and what changed from Helm 2

You will meet old blog posts that mention Tiller, a server component that Helm 2 installed in your cluster. Helm 3 removed it. Today Helm is a single client program that talks to the Kubernetes API with your own credentials from kubeconfig, so Kubernetes RBAC decides what you may do. Release information is stored as Secrets in the release's namespace. This course teaches the model that Helm 3 introduced and Helm 4 keeps: the commands and chart format shown here work in both, and the few differences are called out where they matter.

Check your understanding

Quick check ยท 4 questions

of 4 answered You scored / 4 ยท perfect!

  1. 1. What is a Helm chart?

    A chart is the package: templates, default values and metadata. A running copy of it is a release.
  2. 2. What does Helm send to the Kubernetes API server?

    Helm renders templates with values on the client and submits ordinary manifests.
  3. 3. Which is NOT something Helm does for you?

    Image building belongs to your CI pipeline; Helm only references the image.
  4. 4. Why did Helm 3 remove Tiller?

    Tiller ran with broad permissions in the cluster. Helm 3 is client-only and respects your RBAC rights.

Summary

  • Helm packages Kubernetes YAML as charts, customizes them with values and installs them as releases.
  • One template plus small per-environment values files replaces many near-identical manifests.
  • Helm records every change as a revision, so upgrades and rollbacks are one command.
  • Helm 3 is a client-only tool; it does not build images and it only templates text.

Next: Helm Concepts: Charts, Releases, Repositories and Revisions