Happy Helming

Deploy apps with Helm and ArgoCD

Helm is essentially a package manager for Kubernetes. Think npm for JavaScript, brew for Mac, pip for Python etc. So what it does, it packages all of your Kubernetes manifests into a single package that can be used to share and deploy an application. This can be done manually or through GitOps.

The idea is that you start writing Helm charts from scratch or from existing Kubernetes manifests. Either way, to help with the kick-off, you can run the following command that will provide you with some boilerplate and folder structure:

helm create <name>

This will result in the following directory structure, assuming we name it foo:

foo/
    ├── .helmignore   # Contains patterns to ignore when packaging Helm charts.
    ├── Chart.yaml    # Information about your chart
    ├── values.yaml   # The default values for your templates
    ├── charts/       # Charts that this chart depends on
    └── templates/    # The template files
        └── tests/    # The test files

All of the Kubernetes manifests (e.g. deployment.yaml, service.yaml, pvc.yaml etc.) go into the templates directory.

So how do you write the Helm chart? Well, it's essentially replacing the hard values with variables and defining those variables inside the values.yaml. For example, if you have replicas set to 3 in your deployment.yaml, then you could replace the number 3 with the following:

kind: Deployment
...
  replicas: {{ .Values.replicaCount }}

And then in the values.yaml you would write:

replicaCount: 3

Once that's done, we can verify if there are any errors by doing a dry-run with the following command:

helm install -f values.yaml --dry-run foo .

Assuming there are no errors and you've executed this command from the same directory as your values.yaml, then you would see the output of all of your Kubernetes manifests.

Helm with ArgoCD

Now we want to deploy the application using GitOps with ArgoCD. Let's also assume that we already have everything in place to deploy the application with ArgoCD, then we can actually create the application in ArgoCD. Since we're doing this through GitOps, we have to go to our repository, and for this example we'll navigate to our repo in GitLab, and there we have the ArgoCD repository. Inside the repository we can create a directory that will hold all of our applications, and this is also known as the app of apps pattern in ArgoCD.

You can find a template for each child app of app of apps from the official ArgoCD documentation here.

This file is essentially telling ArgoCD where to look for the helm chart that is stored in a different repo. One thing to remember is to also configure or connect said repo, i.e. the repo in which your helm chart is located. You can do this by going in ArgoCD to settings > repositories.

And that's basically a brief overview of how it works.

So to summarize, you'll write and push your helm chart to a specific Git repository. This can be written from scratch (after running the helm create command) or from existing Kubernetes manifests. Then you do a dry-run to check for any potential errors. If there are no errors, then proceed to writing the application manifest, which is in your ArgoCD repo or the app of apps. Once you've pushed your commit, then ArgoCD will pick up this change and start deploying (hopefully) your application. Happy helming!