What Are Kubernetes Helm Charts?
Kubernetes Helm charts are the ‘packages’ of the Kubernetes world, similar to apt, yum, or homebrew for operating systems, or Maven, Gradle, and npm for programming languages. They are bundles of pre-configured Kubernetes resources.
Helm uses a packaging format called charts. A chart is a collection of files that describe a related set of Kubernetes resources. Charts are created as files laid out in a particular directory tree. They can be packaged into versioned archives to be deployed.
Helm charts allow for the simple creation, versioning, sharing, and publishing of applications that are designed to run on Kubernetes clusters. The use of Helm and Helm charts simplifies the process of defining, installing, and upgrading Kubernetes applications.
What Is a Helm Chart Repository?
A Helm chart repository is a location where packaged charts can be stored and shared. Think of it as a library of applications ready to be deployed on Kubernetes. The repository indexes these packages so that they can be searched using Helm tooling. Technically, Helm repositories are HTTP servers that store packaged charts for distribution.
By default, Helm uses a public chart repository named stable
, but you can configure it to use your own chart repository. This is especially useful for teams developing their own applications, as it allows them to store their charts in a central place and share them with others.
Tips from the expert
Itiel Shwartz
Co-Founder & CTO
In my experience, here are tips that can help you better use Helm charts:
Use Helmfile for managing Helm charts
Helmfile simplifies managing multiple Helm charts by allowing you to define them declaratively.
Automate Helm chart testing
Use tools like Helm test or Chart Testing to automate the testing of your Helm charts before deploying them.
Utilize Helm secrets
Securely manage sensitive data in your Helm charts using Helm secrets for better security practices.
Create reusable templates
Design Helm templates to be reusable across multiple charts, reducing duplication and maintenance effort.
Use version constraints
Specify version constraints in your Chart.yaml
to ensure compatibility with Kubernetes versions.
The Helm Deployment Process
Deploying applications using Helm involves pulling chart definitions from a repository, customizing them via configuration files, and then deploying the resulting application stack to a Kubernetes cluster:
- Creating or selecting Helm chart: The chart includes all the necessary components like deployments, services, and ingress rules that describe how the application should be deployed and managed.
- Defining a values.yaml file: You configure a YAML deployment using the
values.yaml
file. This file overrides default configuration values within the chart to tailor the application deployment to specific requirements, such as setting environment variables, configuring resource limits, or defining service ports. - Installing the chart: After configuring the deployment, the
helm install
command is used to deploy the application to the Kubernetes cluster. This command takes the Helm chart, combines it with the configuration specified in the values.yaml file, and applies it to the cluster, resulting in the creation or update of Kubernetes resources. - Post-deployment: Helm provides commands like
helm list
to view active releases,helm upgrade
to apply updates, andhelm rollback
to revert to a previous version of the deployment.
Structure of a Helm Chart
Chart Directory
The chart directory is the top-level directory, with the same name as the chart, which contains all the files and directories that make up the chart. This directory is the most important one as it’s where all the chart resources are stored.
Within this directory, you’ll find a collection of files and directories that define the chart. These include the Chart.yaml
file, a templates
directory, and a values.yaml
file.
Templates Directory
The templates directory is where Kubernetes resources are defined as templates. These templates are standard Kubernetes manifest files, but with the addition of templating directives from the Go templating language.
This directory contains files that will be transformed into Kubernetes manifest files when the chart is deployed. The templates directory is flexible and can contain Kubernetes manifest files for any type of resource that is supported.
values.yaml
The values.yaml
file is a simple, easy-to-read file that is used to customize the behavior of the chart. This file is written in YAML format and contains default configuration values for the chart.
These values can be overridden by the user during installation or upgrade, allowing for extensive customization of the chart’s behavior. In essence, the values.yaml
file enables users to tailor deployments to their specific needs.
Here is an example of a values.yaml file:
# Default values for my-application. # This is a YAML-formatted file. # Declare variables to be passed into your templates. replicaCount: 1 image: repository: nginx pullPolicy: IfNotPresent # Overrides the image tag whose default is the chart appVersion. tag: "" service: type: ClusterIP port: 80 resources: limits: cpu: 100m memory: 128Mi requests: cpu: 100m memory: 128Mi
This file sets default values for a hypothetical application. It specifies the number of replicas (1), the image to be used (in this case, nginx), the service type and port, and resource limits and requests for the application to be deployed.
Chart.yaml
chart.yaml
is a mandatory file that holds meta-information about the chart. It includes details like the chart’s name, its version and description. Here is an example of a chart.yaml
file:
apiVersion: v2 name: my-application description: A Helm chart for Kubernetes # A chart can be either an 'application' or a 'library' chart. type: application # Chart version, should be incremented upon changes. version: 0.1.0 # Application version this chart installs. appVersion: "1.16.0"
This file defines the chart’s name (my-application), its description, the type of chart (application or library), the version of the chart, and the version of the application that the chart is installing.
How to Create and Use Helm Charts in Kubernetes
Install Helm
Before we start with the installation process, it’s worth noting that Helm is compatible with macOS, Windows, and Linux. For the purpose of this tutorial, we’ll be using a Linux system. To install Helm, open your terminal and run the following commands:
curl https://baltocdn.com/helm/signing.asc | sudo apt-key add - sudo apt-get install apt-transport-https --yes echo "deb https://baltocdn.com/helm/stable/debian/ all main" | sudo tee /etc/apt/sources.list.d/helm-stable-debian.list sudo apt-get update sudo apt-get install helm
Once you’ve run these commands, you can verify your Helm installation by running helm version
. If Helm is successfully installed, you should see the version of your Helm client printed in the terminal.
Initialize a Helm Chart Repository
To initialize a Helm chart repository, we first need to add the official Helm charts repository, stable
. We can do this by running the following command in our terminal:
helm repo add stable https://charts.helm.sh/stable
Once we’ve added the stable repository, we can update our list of charts by running helm repo update
. This command will fetch the latest versions of all the charts from the stable repository.
After we’ve updated our repository, we can search for charts using the helm search repo
command. For instance, if we want to search for all charts related to MySQL, we can run helm search repo mysql
.
Install an Example Chart
Now, let’s install an example chart to see Helm in action. For this tutorial, we’ll be using the WordPress chart from the Bitnami public repository. WordPress is a popular open-source content management system, and you can use Helm to automatically deploy it in your Kubernetes cluster.
To install the WordPress chart, run the following command in your terminal:
helm install my-wordpress oci://registry-1.docker.io/bitnamicharts/wordpress
This command will create a new deployment of WordPress in your Kubernetes cluster. Helm will download the WordPress chart from the repository, generate a set of Kubernetes resources based on the values defined in the chart, and apply these resources to your cluster.
Once the command has completed, you can check the status of your deployment by running helm status my-wordpress
. This command will print detailed information about your deployment, including the status of each individual Kubernetes resource that was created by the chart.
Related content: Read our guide to Kubernetes helm tutorial (coming soon)
Visualizing and Managing Helm Charts With Komodor
Komodor’s platform streamlines the day-to-day operations and troubleshooting process of your Kubernetes apps. Specifically when it comes to Helm Charts, Komodor’s platform provides you with a visual dashboard to view the installed Helm charts, see their revision history and corresponding k8s resources. It also allows you to perform simple actions such as rolling back to a revision or upgrading to a newer version.
At its core, the platform gives you a real-time, high-level view of your cluster’s health, configurations, and resource utilization. This abstraction is particularly useful for routine tasks like rolling out updates, scaling applications, and managing resources. You can easily identify bottlenecks, underutilized nodes, or configuration drift, and then make informed decisions without needing to sift through YAML files or execute a dozen kubectl commands.
Beyond just observation, Komodor integrates with your existing CI/CD pipelines and configuration management tools to make routine tasks more seamless. The platform offers a streamlined way to enact changes, such as scaling deployments or updating configurations, directly through its interface. It can even auto-detect and integrate with CD tools like Argo or Flux to support a GitOps approach! Komodor’s “app-centric” approach to Kubernetes management is a game-changer for daily operational tasks, making it easier for both seasoned DevOps engineers and those new to Kubernetes to keep their clusters running smoothly, and their applications maintaining high-availability.
To learn more about how Komodor can make it easier to empower you and your teams to manage & troubleshoot K8s, sign up for our free trial.
Related content: Read our guide to helm dashboard