Introduction
Helm is a package manager for Kubernetes that helps you manage and deploy applications using charts—collections of templates that define Kubernetes resources. While Helm provides a vast library of pre-built charts, there are times when you need to create a custom chart to suit your specific application needs.
In this guide, we’ll walk through the process of creating a custom Helm chart from scratch. You’ll learn how to:
- Set up the chart structure
- Define your Kubernetes resources
- Customize the chart using
values.yaml
- Deploy the chart to your Kubernetes cluster
Prerequisites
Before you start, you should have:
- A Kubernetes cluster up and running
- Helm installed on your local machine
- kubectl configured to access your cluster
Step 1: Create a New Helm Chart
Start by creating a new Helm chart using the helm create
command:
helm create my-custom-chart
This command will generate a directory structure for the chart:
my-custom-chart/
├── Chart.yaml
├── values.yaml
├── charts/
├── templates/
│ ├── deployment.yaml
│ ├── _helpers.tpl
│ ├── hpa.yaml
│ ├── ingress.yaml
│ ├── service.yaml
│ ├── serviceaccount.yaml
│ └── tests/
└── .helmignore
Key Files and Directories:
Chart.yaml
: Metadata about the chart, such as its name and version.values.yaml
: Default values for your chart, which can be customized during deployment.templates/
: Contains Kubernetes resource templates that Helm will render._helpers.tpl
: A helper template for reusable code (like label formatting).
Step 2: Customize the Chart
Let’s customize this chart to suit a simple Node.js web application deployment.
Editing Chart.yaml
First, edit the Chart.yaml
file to reflect your application’s metadata:
name: my-custom-chart
version: 0.1.0
description: A Helm chart for deploying a custom Node.js application
maintainers:
- name: Your Name
email: your.email@example.com
Editing values.yaml
In the values.yaml
file, we define the default values that can be overridden during deployment. Here's an example configuration:
# Application name and image
app:
name: my-node-app
image:
repository: node
tag: 16-alpine
pullPolicy: IfNotPresent
# Service configuration
service:
type: ClusterIP
port: 80
# Resources
resources:
requests:
memory: "64Mi"
cpu: "100m"
limits:
memory: "128Mi"
cpu: "200m"
# Replicas
replicaCount: 2
In this example:
- We define the application’s Docker image (
node:16-alpine
). - The service type is set to
ClusterIP
, exposing port80
. - Resource requests and limits are defined to manage pod resource consumption.
- The default number of replicas is set to
2
.
Step 3: Customize the Deployment Template
Next, we’ll modify the deployment.yaml
template to suit our Node.js application. This is where Kubernetes manifests are defined using Helm template syntax.
Open templates/deployment.yaml
and edit it as follows:
apiVersion: apps/v1
kind: Deployment
metadata:
name: { { include "my-custom-chart.fullname" . } }
labels:
app: { { include "my-custom-chart.name" . } }
spec:
replicas: { { .Values.replicaCount } }
selector:
matchLabels:
app: { { include "my-custom-chart.name" . } }
template:
metadata:
labels:
app: { { include "my-custom-chart.name" . } }
spec:
containers:
- name: { { .Values.app.name } }
image: "{{ .Values.app.image.repository }}:{{ .Values.app.image.tag }}"
ports:
- containerPort: 80
resources:
requests:
memory: { { .Values.resources.requests.memory } }
cpu: { { .Values.resources.requests.cpu } }
limits:
memory: { { .Values.resources.limits.memory } }
cpu: { { .Values.resources.limits.cpu } }
Key Points:
{{ .Values }}
references the values defined invalues.yaml
.{{ include }}
is used to call helper functions defined in_helpers.tpl
.- The container’s image, resources, and replicas are all pulled from
values.yaml
.
Step 4: Customize the Service Template
Next, open templates/service.yaml
and edit the file to define how the application will be exposed.
apiVersion: v1
kind: Service
metadata:
name: { { include "my-custom-chart.fullname" . } }
labels:
app: { { include "my-custom-chart.name" . } }
spec:
type: { { .Values.service.type } }
ports:
- port: { { .Values.service.port } }
targetPort: 80
selector:
app: { { include "my-custom-chart.name" . } }
Here, the service type and port are pulled from values.yaml
.
Step 5: Test the Chart Locally
Before deploying to your cluster, you can test the chart rendering using the following command:
helm template my-custom-release ./my-custom-chart
This will output the Kubernetes manifests as they would be rendered, without actually deploying them.
Step 6: Deploy the Chart to Kubernetes
Now that your custom chart is ready, you can deploy it to your Kubernetes cluster.
To install the chart:
helm install my-custom-release ./my-custom-chart --namespace my-namespace
This will create a Helm release named my-custom-release
in the my-namespace
namespace.
To see the status of the release:
helm status my-custom-release --namespace my-namespace
Step 7: Update the Chart
If you need to change values or update the chart, you can modify values.yaml
or pass in new values via the --set
flag.
For example, to increase the number of replicas:
helm upgrade my-custom-release ./my-custom-chart --set replicaCount=4 --namespace my-namespace
Step 8: Roll Back Changes
If something goes wrong with the deployment, you can easily roll back to a previous version of the release:
helm rollback my-custom-release 1 --namespace my-namespace
This command reverts the release to revision 1
.
Conclusion
Creating a custom Helm chart allows you to package your Kubernetes applications in a reusable and flexible way. By leveraging templates and configuration files like values.yaml
, you can easily manage complex applications and scale them across environments.
With this guide, you should now be able to:
- Structure and customize your Helm chart
- Define Kubernetes resources as templates
- Deploy and manage your application using Helm
Helm's flexibility and power make it an essential tool in modern Kubernetes-based environments. Happy charting!
Breakdown of the Content:
- Introduction: What is Helm, and why you might need a custom chart.
- Step-by-Step Guide:
- Create the chart using
helm create
. - Modify
Chart.yaml
andvalues.yaml
to customize metadata and default values. - Customize
deployment.yaml
andservice.yaml
for your specific use case. - Test the chart locally with
helm template
. - Deploy the chart using
helm install
. - Update and upgrade the chart with new values.
- Roll back changes if something goes wrong.
- Create the chart using
- Conclusion: A summary of the power of Helm and what you learned.