Helm and Charts: Simplifying Kubernetes Management

As a seasoned Linux administrator, you’re well-versed with the convenience and efficiency brought by package managers like apt, yum, or zypper.

These tools have been indispensable in managing software packages, handling dependencies, and streamlining installations and updates on Linux systems.

Transitioning into the Kubernetes ecosystem, you’ll find a parallel tool that brings similar benefits to managing containerized applications: Helm.

Table of Contents

Introducing Helm

Helm is often referred to as the package manager for Kubernetes, designed to simplify the deployment and management of applications on Kubernetes clusters.

Just as apt or yum allow you to manage software packages on Linux, Helm enables you to manage Kubernetes “packages” known as charts.

Understanding Helm Charts

A Helm chart is the fundamental unit in the Helm ecosystem, analogous to a package in the Linux world.

However, instead of containing binaries and libraries, a chart is a collection of YAML files that describe a related set of Kubernetes resources. These resources might include deployments, services, persistent volumes, and more, which together constitute an application.

Charts are designed to be shareable and reusable. You can find a plethora of community-driven charts for common software stacks and applications in public Helm repositories, akin to Linux package repositories.

Why Helm Matters for Kubernetes Management

Kubernetes, while powerful, introduces complexity when it comes to deploying and managing applications, especially as the number and intricacy of services grow. Helm addresses this challenge by:

Simplifying Deployments: Helm allows you to package all necessary Kubernetes resources into a single chart. Deploying an application then becomes as simple as running helm install, significantly reducing the potential for human error and streamlining the deployment process.
Managing Dependencies: Just as Linux package managers handle software dependencies, Helm charts can include dependencies on other charts, ensuring that all components of your application are deployed with the correct configurations and versions.
Facilitating Updates and Rollbacks: Helm tracks each deployment as a “release”. This enables you to easily upgrade your application to a new version of a chart, or roll back to a previous version, providing a straightforward way to manage application updates.
Customization through Values: Helm charts are designed to be customizable. A values.yaml file within a chart specifies default configuration values, which can be overridden at installation time. This allows you to deploy the same chart across different environments (development, staging, production) with environment-specific configurations, all without altering the chart itself.

Getting Started with Helm

To begin your journey with Helm, you’ll first install the Helm CLI on your workstation. The process is as familiar as installing any Linux package:

Download the Helm binary for your platform.
Unpack the binary and move it to a location in your PATH.

With Helm installed, you can start exploring available charts in public repositories, such as the Helm Hub, and install them on your Kubernetes cluster. You can also create your own charts for your applications, packaging all necessary Kubernetes resources and configurations.

Creating a Helm chart in Kubernetes is a structured way to package and deploy applications or services within your Kubernetes cluster. Here’s a step-by-step guide to help you create your first Helm chart:

Step 1: Install Helm

First, ensure Helm is installed on your system. You can download it from the Helm releases page and follow the installation instructions for your operating system.

Step 2: Create a New Helm Chart

Open your terminal.
Use the helm create command to generate a new chart skeleton. Replace mychart with your desired chart name:
```
helm create mychart
```
This command creates a new directory named mychart containing the basic structure of a Helm chart.

Step 3: Explore the Chart Structure

Navigate to the mychart directory. Inside, you’ll find several files and directories:

Chart.yaml: Contains metadata about your chart, such as the name, version, and a description.
values.yaml: Stores default configuration values for your chart. These values can be overridden when you install or upgrade the chart.
templates/: Contains template files for Kubernetes resources like Deployments, Services, and Ingresses. Helm will combine these templates with values from values.yaml to generate Kubernetes manifests.
charts/: A directory for chart dependencies. If your chart depends on other Helm charts, they can be placed here.
.helmignore: Specifies files and patterns to ignore when packaging the chart, similar to .gitignore in Git.

Step 4: Customize Your Chart

Modify Chart.yaml: Update this file with details about your chart. Ensure you provide a meaningful name, description, and version.
Configure values.yaml: Define parameters specific to your application or service in this file. For example, you might specify image names, tag versions, resource limits, or service ports.
Edit Templates: Go to the templates/ directory and edit or add templates for the Kubernetes resources your application requires. Use Helm’s templating syntax to reference values from values.yaml. For instance, you might modify templates/deployment.yaml to define the deployment strategy, replicas, and container specifications for your application.

Step 5: Test Your Chart

Before deploying, it’s a good practice to validate your chart for any syntax errors or issues:

helm lint mychart

You can also preview the generated Kubernetes manifests without applying them:

helm template mychart

Step 6: Install Your Chart

Deploy your chart on your Kubernetes cluster to see it in action:

helm install my-release mychart

This command installs your chart and assigns it a release name (my-release in this example).

Once your chart is ready and tested, you can package it into a versioned archive file for distribution:

helm package mychart

This command creates a .tgz file containing your chart, which can then be shared or uploaded to a Helm chart repository for others to use.

Conclusion

For a Linux administrator stepping into the Kubernetes arena, Helm offers a familiar paradigm for managing applications. Just as package managers like apt and yum have streamlined software management on Linux, Helm provides a powerful, efficient way to manage Kubernetes applications through charts.

Embracing Helm in your Kubernetes strategy not only simplifies application deployment and management but also leverages your existing skills in package management, making your transition to Kubernetes smoother and more intuitive.

Notes:

Rancher is an open-source container management platform that simplifies Kubernetes cluster management across any infrastructure. It provides a user-friendly interface for deploying and managing Kubernetes clusters and supports Helm for application deployment. Rancher adds value with its extensive catalog of Helm charts, comprehensive security features, and multi-tenancy support.