January 11, 2025 13 min to read

Understanding Helm - The Kubernetes Package Manager

Simplify and streamline your Kubernetes application deployments

Overview

Helm is the package manager for Kubernetes, providing functionality to package, share, and use software built for Kubernetes. Think of it as apt/yum/homebrew for Kubernetes - a tool that simplifies the installation and management of applications and services.

What is Helm?

Helm uses a package format called a chart, which is a collection of files describing a related set of Kubernetes resources. A single chart might be used to deploy something simple, like a memcached pod, or something complex, like a full web app stack with HTTP servers, databases, caches, and more.

Charts are easy to create, version, share, and publish — making them valuable for streamlining deployments in a Kubernetes environment.

Key Components

Helm supports chart repositories that can be used to store and share Helm charts. The distributed community helm chart repository is located at Artifact Hub.

Artifact Hub is a web-based application that enables you to find, install, and publish packages and configurations for CNCF projects, including publicly available decentralized Helm charts.

Getting Started with Helm

Installation

Before installing Helm, ensure you have the following prerequisites:

• A Kubernetes cluster (local like Minikube or remote)
• kubectl configured to communicate with your cluster
• Appropriate permissions to install applications in your cluster

Installation Methods

wget https://get.helm.sh/helm-v3.12.0-linux-amd64.tar.gz
tar -zxvf helm-v3.12.0-linux-amd64.tar.gz
sudo mv linux-amd64/helm /usr/local/bin/helm

curl -fsSL -o get_helm.sh https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3
chmod 700 get_helm.sh
./get_helm.sh

# macOS with Homebrew
brew install helm

# Windows with Chocolatey
choco install kubernetes-helm

# With Snap
sudo snap install helm --classic

You can check the installation method according to your OS in the official installation guide.

Verify Installation

helm version

Configuring Helm

After installation, you may want to add repositories to find and use existing charts:

# Add the official Stable charts repository
helm repo add stable https://charts.helm.sh/stable

# Add Bitnami repository (popular maintained charts)
helm repo add bitnami https://charts.bitnami.com/bitnami

# Update repo information
helm repo update

# List configured repositories
helm repo list

Understanding Helm Charts

Chart Structure

A chart is organized as a collection of files inside a directory. The directory name is the name of the chart.

    mychart/
      ├── Chart.yaml            # Metadata about the chart
      ├── values.yaml           # Default configuration values
      ├── values.schema.json    # Optional JSON Schema for validating values
      ├── charts/               # Directory containing dependency charts
      ├── crds/                 # Custom Resource Definitions
      ├── templates/            # Kubernetes manifest templates
      │   ├── NOTES.txt         # Usage notes displayed after installation
      │   ├── deployment.yaml   # Kubernetes deployment manifest template
      │   ├── service.yaml      # Kubernetes service manifest template
      │   ├── _helpers.tpl      # Template helpers and named templates
      │   └── ...               # Other resource templates
      └── README.md             # Optional readme file

Basic Chart Files

apiVersion: v2
name: my-application
description: A Helm chart for a Kubernetes application
type: application
version: 1.0.0         # Chart version
appVersion: "2.3.4"    # Application version
dependencies:
  - name: mongodb
    version: 13.6.4
    repository: https://charts.bitnami.com/bitnami
    condition: mongodb.enabled
maintainers:
  - name: Your Name
    email: your.email@example.com

replicaCount: 2

image:
  repository: nginx
  pullPolicy: IfNotPresent
  tag: "1.21.6"

service:
  type: ClusterIP
  port: 80

resources:
  limits:
    cpu: 100m
    memory: 128Mi
  requests:
    cpu: 50m
    memory: 64Mi

mongodb:
  enabled: true
  auth:
    rootPassword: "password"

apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ include "mychart.fullname" . }}
  labels:
    {{- include "mychart.labels" . | nindent 4 }}
spec:
  replicas: {{ .Values.replicaCount }}
  selector:
    matchLabels:
      {{- include "mychart.selectorLabels" . | nindent 6 }}
  template:
    metadata:
      labels:
        {{- include "mychart.selectorLabels" . | nindent 8 }}
    spec:
      containers:
        - name: {{ .Chart.Name }}
          image: "{{ .Values.image.repository }}:{{ .Values.image.tag | default .Chart.AppVersion }}"
          imagePullPolicy: {{ .Values.image.pullPolicy }}
          ports:
            - name: http
              containerPort: 80
              protocol: TCP

Chart Templating

Helm uses Go templates to enable dynamic manifest generation. Some key templating features include:

1. Values References: Access configuration with .Values.key.subkey
2. Built-in Objects: Use .Chart, .Release, .Capabilities, etc.
3. Functions and Pipelines: quote, indent, toYaml, etc.
4. Control Structures: if/else, with, range
5. Named Templates: Create reusable components with define and template

Example template with control flow:

apiVersion: v1
kind: ConfigMap
metadata:
  name: {{ .Release.Name }}-configmap
data:
  {{- if eq .Values.environment "production" }}
  log-level: "error"
  {{- else }}
  log-level: "debug"
  {{- end }}
  
  {{- with .Values.config }}
  database-url: {{ .dbUrl | quote }}
  timeout: {{ .timeout | default 30 }}
  {{- end }}
  
  settings: |
    {{- range $key, $val := .Values.settings }}
    {{ $key }}: {{ $val | quote }}
    {{- end }}

Helm Commands and Workflow

Common Helm Commands

Typical Helm Workflow

Values Management

Helm allows you to specify values in multiple ways, with the following precedence (highest to lowest):

1. --set flag values (command line)
2. --values / -f flag values (values files specified on command line)
3. Default values in dependent charts
4. Default values in the chart’s values.yaml

Example of layered values:

# Install with custom values file and override specific values
helm install -f prod-values.yaml --set replicaCount=3,image.tag=v1.2.3 my-release ./mychart

Creating and Managing Helm Charts

Creating a New Chart

# Create a chart scaffold
helm create mychart

# The directory structure will be created with default templates

Developing and Testing

# Lint your chart to check for issues
helm lint ./mychart

# Render templates locally without installing
helm template ./mychart

# Install your chart with debug info
helm install --debug --dry-run my-release ./mychart

Packaging and Distributing

# Package chart into .tgz archive
helm package ./mychart

# Create a local chart repository
mkdir -p ./my-helm-repo
mv mychart-0.1.0.tgz ./my-helm-repo
helm repo index ./my-helm-repo --url https://example.com/charts

# Add your repository
helm repo add myrepo https://example.com/charts

Chart Hooks

Helm provides hooks that allow chart developers to intervene at certain points in a release’s lifecycle:

• pre-install: Execute before any resources are installed
• post-install: Execute after all resources are installed
• pre-delete: Execute before any resources are deleted
• post-delete: Execute after all resources are deleted
• pre-upgrade: Execute before any resources are upgraded
• post-upgrade: Execute after all resources are upgraded
• pre-rollback: Execute before any resources are rolled back
• post-rollback: Execute after all resources are rolled back
• test: Execute when the Helm test command is invoked

Example hook:

apiVersion: batch/v1
kind: Job
metadata:
  name: {{ .Release.Name }}-database-init
  annotations:
    "helm.sh/hook": post-install
    "helm.sh/hook-weight": "5"
    "helm.sh/hook-delete-policy": hook-succeeded
spec:
  template:
    spec:
      containers:
      - name: db-init-job
        image: "{{ .Values.initImage.repository }}:{{ .Values.initImage.tag }}"
        command: ["./init-db.sh"]
      restartPolicy: Never

Advanced Helm Concepts

Chart Dependencies

Helm charts can depend on other charts, which is useful for creating complex applications:

# Chart.yaml
dependencies:
  - name: postgresql
    version: 11.6.12
    repository: https://charts.bitnami.com/bitnami
    condition: postgresql.enabled
  - name: redis
    version: 17.0.10
    repository: https://charts.bitnami.com/bitnami
    alias: cache

Managing dependencies:

# Update dependencies
helm dependency update ./mychart

# Build dependencies (download and unpack)
helm dependency build ./mychart

Library Charts

Library charts are special charts that do not create Kubernetes objects directly but provide reusable templates and helpers:

# Chart.yaml for a library chart
apiVersion: v2
name: my-library
type: library
version: 1.0.0

Helm Plugins

Extend Helm’s functionality with plugins:

# Install a plugin
helm plugin install https://github.com/databus23/helm-diff

# Use the plugin
helm diff upgrade my-release bitnami/wordpress

Helm in CI/CD Pipelines

    stages:
      - lint
      - package
      - deploy

    lint-chart:
      stage: lint
      script:
        - helm lint ./charts/my-app

    package-chart:
      stage: package
      script:
        - helm package ./charts/my-app
        - helm repo index .
      artifacts:
        paths:
          - ./*.tgz

    deploy-staging:
      stage: deploy
      script:
        - helm upgrade --install my-app-staging ./charts/my-app 
          --set environment=staging
      environment:
        name: staging

Comparing Helm with Other Kubernetes Deployment Tools

References and Resources

Official Documentation

• Helm Official Documentation
• Helm Hub / Artifact Hub
• Helm Chart Template Guide

Community Resources

• Helm Community on GitHub
• Helm CNCF Project Page
• Argo CD with Helm

Books and In-depth Learning

• “Helm: The Kubernetes Package Manager” by Charles Lowell
• “Cloud Native DevOps with Kubernetes” - Chapter on Helm
• “Kubernetes Patterns” - Application packaging section

Related Tools

• Helmfile - Declarative spec for deploying Helm charts
• Helmsman - Helm charts as code
• Helm Dashboard - Web UI for Helm