DevOps Tools Introduction #11: Kubernetes Package Management

Kubernetes consists of many layers and features, with a correspondingly complex declarative set of administration rules. Although it’s important to understand Kubernetes itself, DevOps candidates should also master the most common open source projects that have jumped into the complexity gap to make Kubernetes administration easier. The LPI DevOps Tools Engineer certification expects you to have some familiarity with Helm, Kustomize, Flux CD, and Argo CD.

Helm

One of the most important tools to know for managing Kubernetes applications is Helm, a package manager that simplifies the definition, installation, and lifecycle management of applications.
Installing Helm is simple and straightforward, with multiple options depending on your system and preferences. On Debian-based and Red Hat-based Linux distributions, the easiest method is to use the official installation script, which automates the entire setup.

What is a Chart?

The fundamental building block in Helm is the Chart, a structured collection of files that describe a set of Kubernetes resources. It includes templates, default configurations, and metadata required to deploy an application consistently across environments.

A Release represents a deployed instance of a Chart within a Kubernetes cluster. Each time a Chart is installed, Helm creates a new Release, assigning it a unique name and tracking its state. This allows multiple instances of the same application to coexist, each with potentially different configurations.

Values define how a Chart is customized during deployment. These are typically stored in a file named values.yaml, which provides default parameters for the Chart templates.

Users can override these values at installation or upgrade time, enabling flexible configuration without modifying the underlying templates. This separation of templates and values is central to Helm’s design, promoting reuse and consistency.

Installation, Upgrading, and Uninstalling Software using Helm

Helm provides a straightforward workflow for managing application lifecycles. The helm install command deploys a Chart into a cluster, creating a new Release.

After setting up Helm, the next step is to add a Chart repository. You can explore available repositories on Artifact Hub, which hosts a wide collection of ready-to-use Helm Charts. Then add a repository to your search options through:

$ helm repo add bitnami \
https://charts.bitnami.com/bitnami

Once the repository is added, you can search for available Charts within it:

$ helm search repo bitnami

To deploy an application using Helm, use the helm install command. One of the simplest approaches is to install a Chart from the Bitnami repository.

First, update your local repository index to ensure you have the latest Chart definitions:

$ helm repo update

Then install a Chart using a generated Release name. During installation, Helm renders the templates using the provided values and applies the resulting Kubernetes manifests. The following example installs the MySQL database engine:

$ helm install bitnami/mysql

This process downloads the selected Chart, renders its templates with default values, and deploys the application into your Kubernetes cluster as a new Release.

To upgrade an existing application, use helm upgrade. This command incrementally applies changes, such as updating container images, modifying configurations, or enabling new features. Helm maintains a revision history for each Release, which enables rollback to previous states if needed.

To inspect deployed applications, helm list provides an overview of all Releases within a namespace or across the cluster. This helps administrators track the current state and identify deployed components.

When an application is no longer needed, helm uninstall removes the Release and its associated Kubernetes resources. This ensures a clean removal without leaving orphaned objects in the cluster.

The helm site provides a handy cheat sheet for quick reference.

Specifying Custom Values with values.yaml

Customization in Helm is primarily achieved through the values.yaml file. This file defines default configuration parameters such as replica counts, image versions, service types, and resource limits. By editing this file or providing alternative values during deployment, users can tailor the application to specific environments like development, staging, or production.

Overrides can be supplied directly via command-line flags or through additional YAML files. This mechanism allows teams to maintain a base configuration while applying environment-specific adjustments. The templating engine processes these values dynamically, injecting them into Kubernetes manifests at deployment time.

This approach promotes modularity and reduces duplication, as the same Chart can be reused across multiple contexts with different configurations.

Kustomize

Kustomize is another tool for managing Kubernetes configurations, following a different philosophy from that of Helm. Instead of templating, Kustomize focuses on layering and patching existing YAML manifests. It allows users to define a base configuration and apply overlays to modify specific fields without altering the original files.

Kustomize is built into Kubernetes through the standard kubectl command, making it readily available without additional installation. It is particularly useful for teams that prefer declarative configuration management without introducing the extra conceptual layer of a templating language.

While Helm emphasizes packaging and parameterization, Kustomize emphasizes composition and transformation. Both tools can coexist in modern workflows, depending on the use case.

Flux CD and Argo CD

Flux CD and Argo CD are GitOps tools that automate the deployment and synchronization of Kubernetes resources based on Git repositories. They extend the concepts of Helm and Kustomize by introducing continuous delivery practices.

In a GitOps model, the desired state of the cluster is stored in version-controlled repositories. Flux CD and Argo CD continuously monitor these repositories and reconcile the cluster state to match the declared configuration. This ensures consistency, traceability, and automated recovery from drift.

Argo CD provides a rich user interface and detailed visibility into application states, while Flux CD is more lightweight and integrates deeply with Kubernetes primitives. Both tools support Helm Charts and Kustomize configurations, enabling flexible deployment strategies.

By combining Helm with GitOps tools, teams can achieve fully automated, reproducible, and auditable application delivery pipelines.

As you deepen your understanding of Kubernetes application management and the common tools used to perform it, the official Learning Material for the DevOps Tools Engineer certification can serve as a valuable reference. It is freely available and provides structured coverage of topics such as Charts, Releases, Values, and application lifecycle management, helping to reinforce and organize your studies.

<< Read the previous article of this series | Start the series from the beginning >>