Helm: The Kubernetes Package Manager for Simplified Application Deployment on Ubuntu EKS

What is Helm?

Helm is a package manager for Kubernetes that helps you manage Kubernetes applications. It simplifies the deployment and management of applications on Kubernetes by using a packaging format called charts. Helm allows you to define, install, and upgrade even the most complex Kubernetes applications. Think of it as the “apt” or “yum” for Kubernetes.

Application is running with several components and objects in K8S

Issues Before Helm:

• Complexity and Error-Prone Management: Managing Kubernetes resources like Deployments, StatefulSets, PersistentVolumes (PVs), PersistentVolumeClaims (PVCs), Services, and others individually through separate YAML files resulted in complexity and increased the chance of configuration errors. This approach led to verbose and repetitive configurations, making updates and versioning challenging.

Separe YAML files for separte objects

• Lack of Unified Definition and Flexibility: Each resource, such as Deployments, Services, or StatefulSets, was defined and managed separately, with no unified representation of the entire application. This lack of a cohesive application definition made templating and reusability difficult, as values were hardcoded and not easily adaptable across different environments.

• Operational Overhead and Dependency Issues: Managing the full application lifecycle — including updates, rollbacks, and deletions — was manual and error-prone. Executing multiple kubectl commands for different resources added operational overhead. Additionally, managing dependencies and ensuring the correct order of creation and deletion of resources like PVs, PVCs, and Services was complex and cumbersome.

After Helm

Centralized Management:

• Helm introduces a single package management system for Kubernetes applications, enabling users to bundle multiple Kubernetes resources into a single package called a Helm chart.
• This simplifies the deployment process by allowing users to manage their entire application as one unit instead of dealing with individual configuration files.

Templating and Reusability:

• Helm charts support templating, allowing users to define parameterized configurations. This means you can reuse the same chart for different environments (e.g., development, testing, production) with minimal changes.
• Templating reduces duplication and makes it easier to maintain and update applications.

helm install : one click you can install all the objects

helm uninstall : one click you can uninstall all the objects

Dependency Management:

• Helm charts can define dependencies on other charts, making it easier to manage complex applications with multiple interconnected components.
• Dependency management ensures that all required services are installed and configured correctly.

Community and Ecosystem:

• The Helm community provides a repository of pre-built charts for common applications, enabling users to quickly deploy popular software stacks without creating configurations from scratch.
• This accelerates the deployment process and ensures best practices are followed.

Version Control and Rollbacks:

• Helm maintains a history of releases, making it easy to track changes and roll back to previous versions if something goes wrong.
• This version control capability enhances reliability and reduces downtime during updates or changes.

Installing Helm on Ubuntu:

Follow the official document as well:

https://helm.sh/docs/intro/install/

# Add the Helm GPG key
curl https://baltocdn.com/helm/signing.asc | gpg --dearmor | sudo tee /usr/share/keyrings/helm.gpg > /dev/null# Install apt-transport-https package

# Install apt-transport-https Package:
sudo apt-get install apt-transport-https --yes

# Add the Helm repository
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/helm.gpg] https://baltocdn.com/helm/stable/debian/ all main" | sudo tee /etc/apt/sources.list.d/helm-stable-debian.list

# Update package list:
sudo apt-get update

# install Helm:
sudo apt-get install helm

# Verify Helm Installation:
helm version --client

Helm Commnads:

Commonly used Helm commands that are helpful in day-to-day Kubernetes management:

# Checks your Helm chart for issues before deploying.
helm lint

# Renders your Helm chart templates locally and displays the output, useful for debugging.
helm template

# Simulates installing the chart without actually deploying it, allowing you to verify changes.
helm install my-chart . --dry-run

# Provides a list of all available Helm commands and options.
helm --help

# Updates an existing release with a new version of the chart, essential for maintaining and upgrading applications.
helm --help

# Lists all Helm releases in the current namespace, useful for tracking deployed applications.
helm list

# Retrieves the values used for a specific release, allowing you to review or modify configuration settings.
helm get values RELEASE_NAME

# Deletes a Helm release from the cluster, removing the associated Kubernetes resources.
helm delete RELEASE_NAME

# Rolls back a release to a previous version, useful for reverting to a stable state if an update causes issues.
helm rollback RELEASE_NAME REVISION

# Adds a Helm chart repository, enabling you to download charts from different sources.
helm repo add REPO_NAME REPO_URL

# Updates the local cache of chart repositories, ensuring you have the latest versions available.
helm repo update

# Packages a Helm chart into a .tgz file, which can be shared or uploaded to a repository.
helm package CHART_PATH

# Pushes a packaged chart to a Helm repository, facilitating distribution and deployment.
helm push CHART_PATH REPO_NAME

# These commands provide a comprehensive set of tools for managing the lifecycle of Kubernetes applications using Helm, from initial deployment to updates and troubleshooting.

Overall, Helm simplifies Kubernetes application management by centralizing configurations, supporting reusable templates, providing version control, managing dependencies, and leveraging community resources. This results in more efficient and reliable deployments, reducing the complexity and potential for errors.