Helm Tutorial – Helm Basics

What is Helm

Helm is a package manager for Kubernetes, which is an open-source platform for automating deployment, scaling, and management of containerized applications. Helm helps you manage Kubernetes applications. Think of it like apt/yum/homebrew for Kubernetes.

Helm uses a packaging format called charts. A chart is a collection of files that describe a related set of Kubernetes resources. A single chart might define everything necessary to run a web application, a database backend, or a distributed data processing framework.

Helm makes it easier to design, distribute and deploy applications onto Kubernetes clusters. You can also roll back to an older version of your application, if needed, making the process of application deployment smoother and safer.

Why do We Need Helm?

Let’s assume we’re deploying a simple web application which involves a front-end service, a back-end service, and a database.

In a typical Kubernetes setup without Helm, you would have to manually create and manage a set of YAML manifest files for each component of your application. For example:

# kubectl apply -f frontend-deployment.yaml
# kubectl apply -f frontend-service.yaml
# kubectl apply -f backend-deployment.yaml
# kubectl apply -f backend-service.yaml
# kubectl apply -f database-pvc.yaml
# kubectl apply -f database-deployment.yaml
# kubectl apply -f database-service.yaml

Then if you want to update your application, you have to manually update the relevant YAML files and re-apply them. Also, rolling back changes would mean keeping track of what was deployed and manually reverting to previous versions.

With Helm, the entire application can be packaged as a single chart, which is a collection of all these YAML files structured in a specific way. Once you’ve created your chart (let’s call it fox-app), you can deploy the entire stack with a single command:

# helm install fox-app ./fox-app-chart

As you can see, Helm serves a crucial role in a Kubernetes environment by simplifying many complex aspects of deploying and managing applications.

Here are common reasons why we need Helm:

Simplifies Deployment

Helm makes it easier to deploy applications onto a Kubernetes cluster. Without Helm, you would need to create, organize, manage, and track each Kubernetes manifest file for each module of the application. With Helm, the process becomes more straightforward, as it bundles these manifests into a single, versioned entity known as a chart.

Reusable Charts

Helm charts can be reused for standard deployments across different environments, reducing duplication and potential errors.

Versioning and Release Management

Helm has built-in versioning and release management system, enabling easy updates and rollbacks, improving the efficiency and reliability of deployments.

Sharing

Helm charts can be shared across teams, creating a way to distribute packages of pre-configured Kubernetes resources, which leads to consistent and repeatable deployments.

Managing Dependencies

Helm charts can manage dependencies that your application relies on. For example, if your application depends on a specific version of a database, that can be specified in the Helm chart.

Complex Applications

For complex applications with multiple components, Helm becomes even more essential as it allows all components to be grouped together and managed as one entity.

Label your resources

Labels can be used to find your resources created by Helm releases instantly. The easiest way to define labels is using the helpers.tpl file.

Use Helm functions to simplify

Helm functions simplify operations inside template files. We typically combine it with pipelines, and you can control flow in your Helm templates.

Community Support

Helm has a vibrant community which contributes charts for many popular applications, so often you do not need to create charts from scratch but can leverage the work done by the community.

Helm Architecture and Components

Helm is a tool divided into two distinct components:

Helm Client

This is a command-line interface used by end users. Its responsibilities include:

• Facilitating local chart development
• Managing chart repositories
• Overseeing releases
• Interacting with the Helm library
• Uploading charts for installation
• Requesting the upgrade or removal of existing releases

Helm Library

This component interacts with the Kubernetes API server and carries out the execution of all Helm operations. Its capabilities include:

• Merging a chart and its configuration to construct a release
• Installing charts into Kubernetes and providing the resultant release object
• Upgrading and uninstalling charts via interaction with Kubernetes

By being standalone, the Helm library encapsulates Helm’s logic and makes it accessible to various clients.

Helm Charts Best Practices

Following are some of the best practices to be followed when developing a helm chart.

• Document your chart by adding comments and a README file as documentation is essential for ensuring maintainable Helm charts.
• We should name the Kubernetes manifest files after the Kind of object i.e deployment, service, secret, ingress, etc.
• Put the chart name in lowercase only and if it has more than a word then separate out with hyphens (-)
• In values.yaml file field name should be in lowercase.
• Always wrap the string values between quote signs.
• Use Helm version 3 for simpler and more secure releases. Check this document for more details

Limitations of Helm charts

As with any new tool, there is a learning curve involved with Helm. It’s not easy to create and deploy your first chart.

Charts are also an extra piece of code that you have to manage and take care of. This includes the overhead to manage, maintain, and store in a chart repository. Helm can be excessive for simpler deployments.

Maintaining charts alone may not be a significant issue, but using charts managed by others can be. Are you comfortable using charts managed by third parties? What if the chart uses an old image with known vulnerabilities? Keep these factors in mind before using Helm.

In addition, troubleshooting issues on an application with a lot of Kubernetes resources can be difficult with Helm.

Refer more about helm installation and how to create a chart on https://foxutech.com/what-is-helm/.