Helm charts

Let’s explore Helm charts: what they are, how they work, and the key files you’ll find inside a chart.

Helm is a command-line tool that simplifies installing, upgrading, rolling back, and uninstalling applications on Kubernetes. As an operator you declare the desired end state (for example, “run three replicas of nginx”); Helm determines how to render templates and apply the Kubernetes API operations to reach that state. A chart is the instruction set Helm uses to produce Kubernetes manifests. A chart typically includes:

One or more template files that render Kubernetes resources.
A values.yaml file for default, configurable values.
A Chart.yaml file that contains chart metadata.

Templates use Helm’s templating language to consume values from values.yaml (or values supplied on the CLI) and render standard Kubernetes manifests. Example: a Service and a Deployment template in a single file. Notice the templating expression {{ .Values... }} used to inject values from values.yaml.

# templates/service-and-deployment.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

---
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

And a simple values.yaml that pairs with the template above:

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

To install this chart locally:

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

For additional Helm documentation and best practices, see the official Helm docs: https://helm.sh/docs/. Chart metadata — Chart.yaml Every chart contains a Chart.yaml file describing the chart. Important fields include apiVersion, name, version, appVersion, description, type, and dependencies. Below is a real-world example from a WordPress chart:

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

apiVersion in Chart.yaml refers to the chart API version (not the Kubernetes resource apiVersion). Use apiVersion: v2 for charts targeting Helm 3. Helm 3 charts can use newer features such as dependencies and library charts.

Chart.yaml fields — quick reference

Field	Purpose	Example
`apiVersion`	Chart API version; controls chart features and Helm compatibility	`apiVersion: v2`
`name`	Chart name	`name: wordpress`
`version`	Chart version (chart-maintainer-managed)	`version: 12.1.27`
`appVersion`	Version of the application deployed by the chart (informational)	`appVersion: 5.8.1`
`description`	Short human-readable description of the chart	`description: Web publishing platform...`
`type`	`application` for deployable apps, `library` for helper charts	`type: application`
`dependencies`	List of dependent charts pulled from repositories	Example block in the WordPress `Chart.yaml` above
`keywords`, `maintainers`, `home`, `icon`	Optional metadata used for discovery and attribution	`maintainers: [{ email: containers@bitnami.com, name: Bitnami }]`

Chart directory layout A typical chart directory looks like this:

hello-world-chart/
  templates/      # Template files (rendered with values)
  values.yaml     # Configurable defaults for the chart
  Chart.yaml      # Metadata for the chart
  README.md       # Human-readable chart documentation (optional)
  LICENSE         # License (optional)
  charts/         # Local copies of dependency charts (optional)

Dependencies Dependencies let you compose charts from other pre-built charts (for example, WordPress + MariaDB). Use the dependencies section in Chart.yaml to declare external charts and conditions to enable/disable them. When working with dependencies locally, use:

helm dependency update ./hello-world-chart

This command downloads or updates the charts/ directory with required dependencies so they are included at render/install time. Best practices and next steps

Keep values that change per-environment in values.yaml and override them with helm upgrade --install -f production-values.yaml or --set on the CLI.
Use helm template to render charts locally and inspect the generated Kubernetes manifests without applying them.
Validate rendered manifests with kubectl apply --dry-run=server -f - to ensure they are accepted by the API server.
Version charts independently of the application using the version field in Chart.yaml.

Useful links

Helm documentation: https://helm.sh/docs/
Helm chart best practices: https://helm.sh/docs/topics/chart_best_practices/
Bitnami charts repository (example): https://charts.bitnami.com/bitnami
Kubernetes documentation: https://kubernetes.io/docs/

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