Discovering the Helm Package Manager for Deployments

As your microservice-based application grows, you need to create, update, and maintain a huge variety of Kubernetes objects required to run your application. Your new application needs a Deployment object and Services to load balance traffic. Fortunately, you can package all manifests tied to your application into one unit and deploy, update, and delete them all at once.

Helm is a package manager for Kubernetes. It is also an open-source project that is part of the Cloud Native Computing Foundation (CNCF). Helm is a tool that simplifies the installation and management of Kubernetes applications.

You've already learned that Deployments allow for deploying your application and managing its release lifecycle. With Helm, you can package all the Kubernetes objects that are required to run your application into one unit, such as Deployments, Services, and so on. These packages are called Helm charts. You can then deploy, update, and delete all these resources at once.

Many Helm charts are already available in the Helm Hub. You can also create Helm charts and publish them in the Helm Hub. Or, you use own Helm charts only in your environment.

Click the buttons below to discover more details about each component.

To work with Helm, you must install the Helm CLI on your machine. Follow the instructions in the Helm documentation.

Helm charts are packages of pre-configured Kubernetes resources. A chart contains all the resource definitions (manifests) necessary to run an application. Each Helm Chart comes with a standard project layout and file structure.

Click on each blue component of a typical Helm Chart to discover more:

With the Helm CLI, you can install and manage Helm charts.

The Helm CLI has three main subcommands:

• helm install - use this command to install a chart.
• helm upgrade - use this command to upgrade an existing release to a new version of a chart.
• helm delete - use this command to delete a release.

Project "Kyma" uses Helm. With Helm, you can create and install charts in a Kyma cluster, like in any other Kubernetes environment.

Unlike the deployment manifest that you have used in the previous lesson, Helm charts use templates. These templates are the same as the manifests themselves. The only difference is that the templates are not static. They can be parameterized. This means that you can use variables in the templates. These variables can be defined in the values.yaml file. The usage of variables makes it possible to reuse the same templates for different scenarios, such as development, testing, and production, or to change the application's configuration without the need to change the template itself.

To see a complete guide on how to use Helm and to explore all its features, go to the Helm documentation.

Let's take a look at an example Helm chart. We want to use Helm to create the hello-kyma application we created in the previous lesson. You can also access the chart in your GitHub Repository.

You can create a Helm chart for your application by running the following command:helm create hello-kyma-chart

This command creates a directory called hello-kyma-chart with sample files as a starting point for your chart. However, a straightforward chart for our application would look like this:

The Chart.yaml file contains information about the chart, such as the name, version, description, etc.

123456789101112
apiVersion: v2
name: hello-kyma-chart
description: A Helm chart for the Hello Kyma example application

# A chart can be either an 'application' or a 'library' chart.
type: application

# This is the chart version.
version: 0.1.0

# This is the version number of the application being deployed.
appVersion: "1.0.0"

The values.yaml file contains the default configuration values for the chart. These values can be used in the templates.

1234
replicaCount: 1

image:
  tag: "1.0.0"

The templates/deployment.yaml file contains the definition of the Kubernetes deployment.

12345678910111213141516171819
apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ .Release.Name }}
spec:
  replicas: {{ .Values.replicaCount }}
  selector:
    matchLabels:
      app: {{ .Release.Name }}
  template:
    metadata:
      labels:
        app: {{ .Release.Name }}
    spec:
      containers:
        - name: hello-kyma
          image: ghcr.io/sap-samples/kyma-runtime-learning-journey/hello-kyma:{{ .Chart.AppVersion }}
          ports:
            - containerPort: 8080

You could dry run this chart before sending it to the cluster by running the following command inside the helm chart folder. This would allow you to see the output of the chart without actually sending it to the cluster.

1
helm template hello-kyma .

If you run this, you will notice that the name hello-kyma will be used for the variables {{ .Release.Name }}.

In this lesson, you learned about Helm and how to use it to create custom charts. You also learned about the structure of a Helm chart and how to use templates in Helm charts.