An Introduction to Helm: Architecture, Components, and Benefits

Helm has become an essential part of the Kubernetes ecosystem, providing a package manager that streamlines the creation and deployment of Kubernetes resources.

What is Helm?

Helm is a Kubernetes package manager that enables users to define, install, and upgrade complex applications with a single command. It offers a user‑friendly design and a large repository of ready‑to‑use Helm Charts.

Key Concepts

Helm uses Helm Charts to manage the lifecycle of application deployments, ensuring consistency across environments. Users can create their own charts or use third‑party charts from public repositories such as Artifact Hub, Bitnami, Harbor, and Chart Museum.

Helm Charts

A Helm Chart is a collection of files that describe the resources and dependencies required to deploy an application on Kubernetes. Charts are modular and version‑controlled, and they are rendered using a values.yaml file to generate the necessary manifests. Dependencies are stored in the charts directory as subcharts.

Chart Structure

charts: directory for subcharts (dependencies).

templates: Golang templates merged with values.yaml data.

templates/NOTES.txt: plain‑text usage notes.

crd: Custom Resource Definitions installed during Helm install.

Chart.yaml: metadata such as version, name, keywords.

LICENSE: license file for the chart.

README.md: human‑readable description of the chart.

requirements.yaml: dependency configuration.

values.yaml: default configuration values.

values.schema.json: JSON schema for values.yaml.

Helm Releases

A release represents an instance of a chart deployed to a Kubernetes cluster, consisting of all the created Kubernetes objects such as Deployments, Services, and Ingress rules.

Helm Chart Repository

Chart repositories are HTTP servers that host index.yaml and chart packages, allowing Helm clients to add and access multiple repositories via helm repo add. Popular repositories include Artifact Hub, Bitnami, Harbor, and Chart Museum.

Chart Version

Each chart must have a version number following the SemVer2 specification. The version is defined in Chart.yaml and used by commands such as helm package.

Chart Dependency

Charts can depend on other charts, which can be declared in the dependencies field of Chart.yaml or placed manually in the charts directory.

dependencies:
  - name: apache
    version: 1.2.3
    repository: https://example.com/charts
  - name: mysql
    version: 3.2.1
    repository: https://another.example.com/charts

Example of placing dependencies in the charts directory:

wordpress:
  Chart.yaml
  # ...
  charts/
    apache/
      Chart.yaml
      # ...
    mysql/
      Chart.yaml
      # ...

Release Version

Each release starts with version 1. Subsequent upgrades or rollbacks increment the version, providing a history useful for tracking changes.

Helm Rollback

The command helm rollback <RELEASE> [REVISION] [flags] allows rolling back to a previous release version, which receives a new version number.

Helm SDK

The Helm SDK consists of Go libraries that interact directly with the Kubernetes API server to install, upgrade, query, and delete resources, enabling developers to embed Helm functionality into their applications.

Helm Architecture

The architecture diagram (not shown) illustrates how Helm uses charts and values.yaml files to manage deployments in a Kubernetes cluster. It also shows how the AWS Observability team builds and maintains Helm charts in a public repository, which users can download and deploy seamlessly.

Why Use Helm?

Compared with alternatives like Kustomize, Tanka, and Carvel, Helm offers greater maturity, a larger ecosystem of publicly available charts, and several key advantages:

Simplicity: a single command can define, install, upgrade, and rollback complex applications.

Reusability: charts package pre‑configured resources that can be shared across projects.

Configurability: values files allow the same chart to be deployed to multiple environments.

Consistency: standardized packaging ensures uniform deployments across clusters.

Scalability: easy to adjust application size via values.yaml.

Community: a large, active community provides extensive resources and best practices.