Introduction to Helmet: Simplifying Kubernetes Deployments with Helm

Authored by Akshay VM

One of our customers, running a web application with over 15+ microservices on Kubernetes, faced growing pains as their application scaled. Managing Helm charts for each microservice became increasingly difficult. What started as a manageable setup turned into a complex web of templates that were hard to update, debug, and maintain. Every microservice needed its own Helm templates, and while these templates were often similar, they still required separate management. This led to a lot of duplicated YAML files with only minor differences.

Making even a small configuration change became a time-consuming task. The team had to update multiple Helm charts individually, and with YAML's nature—where a single indentation error can break the entire deployment—syntax issues became a frequent issue. Debugging these errors across several charts further slowed things down.

As a result, their deployment cycles took longer than they should have. Pushing changes to QA or production required significant effort, delaying the release of new features and updates. The process had become inefficient, and the team spent more time troubleshooting deployments than focusing on moving their application forward.

Managing Kubernetes deployments can be a complex task, especially when dealing with multiple components that require specific configurations. Traditionally, Helm charts are used to manage these components, but as applications scale, Helm charts can become cumbersome to maintain. This is where Helmet comes in — a tool that simplifies deploying Kubernetes components using Helm charts.

What is a Helmet?

Helmet is a library created to streamline Kubernetes deployments by handling the templating of Helm charts. Unlike traditional Helm charts where you manage every component's template individually, Helmet provides a more efficient way of managing configurations across applications.

It was created after identifying a pattern in Helm charts where only a few select configuration options were needed. Instead of duplicating templates for every component, Helmet allows us to keep things DRY (Don’t Repeat Yourself), making the deployment process smoother and less error-prone.

Helmet takes the hassle out of managing Helm charts, making Kubernetes deployments faster and easier

The Problem: Managing Templates in Helm

What is a Helmet?

Helmet is a library created to streamline Kubernetes deployments by handling the templating of Helm charts. Unlike traditional Helm charts where you manage every component's template individually, Helmet provides a more efficient way of managing configurations across applications.

It was created after identifying a pattern in Helm charts where only a few select configuration options were needed. Instead of duplicating templates for every component, Helmet allows us to keep things DRY (Don’t Repeat Yourself), making the deployment process smoother and less error-prone.

By reusing templates, Helmet keeps Kubernetes deployments clean and efficient, even as applications grow

The Problem: Managing Templates in Helm

Helm charts use YAML files to define Kubernetes resources, but these files are prone to syntax errors, especially with incorrect indentations, making them tricky for DevOps teams to troubleshoot. When managing large applications, these errors can slow down the entire deployment process.

With traditional Helm charts, every component in an application requires a set of templates (YAML scripts) to define its configuration. As the number of components grows, so does the complexity of managing these templates.

The Solution: How Helmet Works

Helmet simplifies the process by reducing the need to handle templates manually. It does this by introducing a library of reusable components. Each application’s Helm chart has a dependency on the Helmet library, allowing it to inherit predefined templates instead of creating them from scratch.

While using Helmet, you'll still define your configurations in the values.yaml file, but the variables might differ slightly from those used in traditional Helm charts. The setup involves adding the dependencies in your chart.yaml file and creating a app.yaml in the template directory, which contains the following line

{{ include "helmet.app" . }}        

This tells Helm to include the configurations from Helmet, drastically reducing the need to manage complex YAML templates yourself.

Configuring Helmet with Helm

To use Helmet, follow these basic steps:

1. Add Dependencies: In your chart.yaml, define the dependency on the Helmet library

apiVersion: v2
name: micro-service-1
description: A Helm chart for Kubernetes
type: application
version: 0.1.0
appVersion: "1.16.0"
dependencies:
  - name: helmet
    version: 0.6.5
    repository: https://companyinfo.github.io/helm-charts
    import-values: # <== It is mandatory if you want to import the Helmet default values.
      - defaults        

2. Create Template: In the templates directory, create an app.yaml file containing the Helmet configuration:

akshay@LP-BLR-AVM:/mnt/d/helm/helm-application/micro-service-1/templates$ cat app.yaml{{ include "helmet.app" . }}

3. Customize Values: In the values.yaml, define your application-specific variables, and ensure that they correspond to the ones Helmet expects

Render and Verify: To check your component’s definition, use the following command:

?helm template render -f values.yaml -f values-qa.yaml?.        

5. This command will render the definition file, taking into account the overrides from environment-specific YAML files (like values-qa.yaml), and allow you to verify the configuration.

Deployment

Once you've verified the configuration, you can proceed with deploying your application using Helm. The use of Helmet not only simplifies the templating process but also reduces the chances of errors, making the overall deployment workflow more efficient and reliable.

Benefits of Using Helmet

1. Reduces Configuration Complexity: By leveraging Helmet, you no longer need to manage individual templates for every Kubernetes component. This significantly reduces the amount of YAML code you need to write and maintain
2. Minimizes Errors: YAML files are notoriously error-prone due to strict indentation rules. With Helmet, since most of the templating is handled within the library, there’s less chance of making these types of mistakes, which speeds up the deployment process
3. DRY Principle: Helmet adheres to the Don't Repeat Yourself (DRY) principle by enabling the reuse of templates. This ensures that your Helm charts are clean, easy to understand, and avoid redundant code
4. Faster Deployments: Managing fewer templates and variables directly translates to faster deployments. DevOps teams can focus more on application-specific configurations rather than templating, allowing for quicker iteration and more frequent releases
5. Easier Maintenance: As applications evolve, maintaining multiple Helm charts can become cumbersome. With Helmet, you centralize common configurations, making it easier to apply updates or bug fixes across multiple applications at once

Conclusion

In summary, Helmet simplifies deploying Kubernetes applications by reducing the need to manage complex Helm templates. Offering a library of reusable components enables teams to keep their configurations DRY and reduce potential errors. This streamlined approach not only makes deployments faster but also makes it easier to scale applications without added complexity. For teams looking to optimize their Kubernetes workflows, Helmet provides a powerful tool to manage configurations efficiently, keeping deployments smooth and manageable.

Reference:

https://artifacthub.io/packages/helm/companyinfo/helmet