How to Deploy Applications on Kubernetes Using Helm Charts Step by Step

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:

my-release is the name of the deployment
./myapp is the chart directory

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.