Helm charts

Helm is a CLI tool for packaging, configuring, and deploying applications on Kubernetes. Instead of manually applying multiple manifests, you declare the desired end state — for example, “install this application” — and Helm calculates and executes the sequence of Kubernetes API operations required to reach that state.

Key concepts

Chart: A packaged set of Kubernetes resources and templates that describe an application.
Release: A deployed instance of a chart in a Kubernetes cluster.
Template: A text file (usually YAML) with placeholders that Helm renders into concrete Kubernetes manifests using values.
values.yaml: Default configuration values for the chart that feed templates.
Chart.yaml: Chart metadata (name, version, dependencies, etc.).

How charts work

You provide configuration via values.yaml or command-line overrides.
Helm renders templates by replacing placeholders with those values.
Helm installs, upgrades, rolls back, or uninstalls the resulting manifests as a release in the cluster.

Example chart files Below is a minimal illustrative example showing common chart files: a Service template, a Deployment template that references values.yaml, the values.yaml file itself, and Chart.yaml metadata. service.yaml:

# service.yaml
apiVersion: v1
kind: Service
metadata:
  name: hello-world
spec:
  type: NodePort
  ports:
    - port: 80
      targetPort: http
      protocol: TCP
      name: http
  selector:
    app: hello-world

deployment.yaml:

# deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-world
spec:
  replicas: {{ .Values.replicaCount }}
  selector:
    matchLabels:
      app: hello-world
  template:
    metadata:
      labels:
        app: hello-world
    spec:
      containers:
        - name: hello-world
          image: "{{ .Values.image.repository }}"
          ports:
            - name: http
              containerPort: 80
              protocol: TCP

values.yaml:

# values.yaml
replicaCount: 1
image:
  repository: nginx

Chart.yaml:

# Chart.yaml
apiVersion: v2
appVersion: "1.16.0"
version: 0.1.0
name: hello-world
description: A web application
type: application

Install the chart:

helm install hello-world ./hello-world-chart

Render templates locally (no cluster change):

helm template hello-world ./hello-world-chart

Chart.yaml — important fields

Field	Purpose	Example
`apiVersion`	Chart YAML format version used by Helm (affects supported fields).	`v2`
`name`	Chart name used by Helm and chart repositories.	`hello-world`
`version`	Chart package version (chart lifecycle).	`0.1.0`
`appVersion`	Informational: the version of the application the chart deploys.	`1.16.0`
`type`	Chart type — `application` or `library`.	`application`
`dependencies`	Declare other charts this chart depends on (Helm resolves and installs them).	see example below
`description`, `keywords`, `maintainers`, `home`, `icon`	Optional metadata to help users and tooling discover and use the chart.	`description: A web application`

Set apiVersion: v2 for charts targeting Helm 3. Helm 3 uses apiVersion: v2 to support features like chart dependencies and the type field; using the correct apiVersion ensures Helm interprets the chart format correctly.

Dependencies example When an application needs other services (for example, WordPress needing a database), list those other charts as dependencies instead of copying manifests. This allows you to enable, disable, or configure the dependent charts via your values.yaml.

apiVersion: v2
appVersion: 5.8.1
version: 12.1.27
name: wordpress
description: Web publishing platform for building blogs and websites.
type: application
dependencies:
  - condition: mariadb.enabled
    name: mariadb
    repository: https://charts.bitnami.com/bitnami
    version: 9.x.x
keywords:
  - application
  - blog
  - wordpress
maintainers:
  - email: containers@bitnami.com
    name: Bitnami
home: https://github.com/bitnami/charts/tree/master/bitnami/wordpress
icon: https://bitnami.com/assets/stacks/wordpress/img/wordpress-stack-220x234.png

Directory layout A minimal chart directory typically looks like this:

hello-world-chart
  templates/    # Template files (Service, Deployment, ConfigMap, etc.)
  values.yaml   # Default configuration values
  Chart.yaml    # Chart metadata

Additional files commonly found in charts:

LICENSE — Chart license.
README.md — Human-readable documentation and usage examples.
charts/ — Vendored or packaged chart dependencies for offline use.

Best practices (quick)

Keep templates idempotent and declarative.
Use values.yaml for user-configurable parameters; avoid hard-coding values in templates.
Use helpers (in _helpers.tpl) for reusable template logic and consistent naming.
Version charts following semantic versioning and increment appVersion when the packaged application changes.
Test charts with helm lint and render templates with helm template before installing.

References

Helm documentation: https://helm.sh/docs/
Kubernetes documentation: https://kubernetes.io/docs/
Bitnami charts repository: https://charts.bitnami.com/bitnami

This covers the essentials: what charts are, how templates and values.yaml interact, and how Chart.yaml metadata and dependencies are used. Topics such as advanced templating functions, helper templates, library charts, and CI/CD integration are outside the scope of this article.

Introduction

Core Concepts

Scheduling

Logging & Monitoring

Application Lifecycle Management

Cluster Maintenance

Security

Storage

Networking

Design and Install a Kubernetes Cluster

Install "Kubernetes the kubeadm way"

Troubleshooting

Helm Basics (2025 Updates)

Kustomize Basics (2025 Updates)

Other Topics

Mock Exams

Watch Video