Introduction
Kubernetes has become the standard platform for deploying and managing containerized applications. While Kubernetes provides powerful features for scaling, networking, and managing workloads, writing and managing Kubernetes YAML files manually can become complex for real-world applications. This is where Helm becomes extremely useful.
Helm is often called the package manager for Kubernetes. It allows developers and DevOps engineers to package applications into reusable Helm Charts that define Kubernetes resources such as Deployments, Services, ConfigMaps, and Ingress configurations. Using Helm charts makes Kubernetes deployments easier, more repeatable, and more manageable across environments such as development, staging, and production.
In this guide, we will walk through deploying applications on Kubernetes using Helm Charts step by step. The article explains Helm concepts, installation steps, chart structure, and how to deploy and manage applications using Helm.
What Is Helm in Kubernetes
Helm is an open-source tool that simplifies Kubernetes application deployment. Instead of manually creating multiple YAML configuration files, Helm allows developers to bundle them into a single package called a Helm Chart.
A Helm Chart contains all the Kubernetes configuration files required to deploy an application. It also supports templating, allowing developers to reuse the same configuration with different values across environments.
For example, a Helm chart can deploy:
Kubernetes Deployments
Kubernetes Services
ConfigMaps
Secrets
Ingress controllers
This approach makes Kubernetes deployments more consistent and easier to manage.
Key Concepts of Helm
Understanding the core components of Helm helps developers use it effectively.
Helm Chart
A Helm Chart is a package that contains all the Kubernetes resource definitions required to run an application inside a Kubernetes cluster.
Helm Repository
A Helm repository is a collection of Helm charts stored and shared online. Developers can download charts from repositories such as Bitnami or Artifact Hub.
Helm Release
A release is a running instance of a Helm chart deployed inside a Kubernetes cluster.
For example, you can deploy the same chart multiple times with different configurations.
Helm Values
Values files allow developers to customize Helm chart configurations without modifying the main templates.
Prerequisites for Deploying Applications with Helm
Before deploying applications using Helm, make sure the following tools are installed.
Kubernetes cluster (Minikube, Kind, or cloud Kubernetes service)
kubectl command line tool
Helm CLI
Docker container image for the application
You can verify Helm installation using:
helm version
Step 1: Install Helm
Helm can be installed using a package manager or by downloading the binary.
For Linux or macOS:
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash
After installation, verify Helm using:
helm version
This confirms that Helm is correctly installed on your system.
Step 2: Create a Helm Chart
Helm provides a command to create a new chart template.
helm create myapp
This command generates a folder structure containing templates and configuration files.
Typical chart structure:
myapp/
Chart.yaml
values.yaml
charts/
templates/
templates/deployment.yaml
templates/service.yaml
Each template file defines a Kubernetes resource.
Step 3: Understand Helm Chart Files
Helm charts include several important files.
Chart.yaml
This file contains metadata about the chart such as version, description, and chart name.
Example:
apiVersion: v2
name: myapp
version: 0.1.0
appVersion: "1.0"
values.yaml
This file contains configurable values used in templates.
Example:
replicaCount: 2
image:
repository: nginx
tag: latest
Developers can modify these values without changing template files.
Templates Folder
The templates folder contains Kubernetes YAML definitions written using Helm templating syntax.
Example Deployment template:
apiVersion: apps/v1
kind: Deployment
metadata:
name: {{ .Release.Name }}
spec:
replicas: {{ .Values.replicaCount }}
Helm dynamically replaces these variables during deployment.
Step 4: Package the Helm Chart
Helm charts can be packaged into distributable files.
helm package myapp
This creates a compressed chart file that can be shared or stored in repositories.
Step 5: Deploy the Application Using Helm
To deploy an application using Helm, run the following command.
helm install my-release ./myapp
Here:
Helm will create Kubernetes resources based on the templates inside the chart.
Step 6: Verify Deployment
You can check whether the application has been deployed successfully.
kubectl get pods
To see Helm releases:
helm list
This displays all deployed Helm applications inside the Kubernetes cluster.
Step 7: Upgrade an Application Using Helm
One major advantage of Helm is easy upgrades.
If you modify values.yaml or templates, upgrade the deployment using:
helm upgrade my-release ./myapp
Helm will apply only the required changes without recreating the entire deployment.
Step 8: Rollback a Deployment
Helm also allows rolling back to previous versions if something goes wrong.
Check release history:
helm history my-release
Rollback command:
helm rollback my-release 1
This restores the application to a previous working state.
Benefits of Using Helm for Kubernetes Deployments
Helm significantly improves the Kubernetes deployment workflow.
Simplifies complex Kubernetes configurations
Enables reusable and shareable application packages
Supports version control for deployments
Makes upgrades and rollbacks easier
Reduces configuration duplication across environments
Because of these benefits, Helm is widely used in modern cloud-native DevOps pipelines.
Real World Example of Helm Deployment
Consider a microservices-based e-commerce application deployed on Kubernetes. Each microservice requires multiple Kubernetes resources such as Deployments, Services, ConfigMaps, and Secrets.
Without Helm, developers would have to maintain dozens of YAML files manually. Using Helm charts, all configuration files are packaged into a reusable chart. The DevOps team can deploy the entire application using a single Helm command while still customizing environment-specific values.
Conclusion
Helm simplifies Kubernetes application deployment by packaging Kubernetes configurations into reusable charts. It helps developers manage complex infrastructure, maintain consistent deployments, and easily upgrade or roll back applications. By using Helm charts, organizations can automate their Kubernetes deployment workflow, reduce configuration errors, and improve DevOps productivity when managing containerized applications at scale.