How to Deploy Helm Charts With Argo CD | Harness Blog

• Integrating Argo CD with Helm charts enables automated, auditable, and policy-driven Kubernetes deployments, eliminating manual intervention and reducing configuration drift.
• Adopting GitOps best practices improves deployment reliability, security, and compliance without slowing developer velocity.
• Optimizing your CI/CD pipeline with Harness CI accelerates build times, reduces infrastructure costs, and ensures supply chain security, creating a seamless workflow from artifact creation to environment promotion.

‍

Modern Kubernetes deployments demand speed, reliability, and consistency, without sacrificing security or control. That’s exactly where Argo CD and Helm charts shine. Together, they enable a GitOps-driven workflow that eliminates manual deployments, prevents configuration drift, and scales cleanly across environments.

In this guide, we’ll walk through how to deploy Helm charts using Argo CD, explain how GitOps works in practice, and show how tools like Harness CI and GitOps can further optimize your delivery pipeline.

Argo CD & Helm Chart: A Powerful GitOps Combination

GitOps is a modern continuous delivery (CD) approach that uses Git as the single source of truth for application configuration and deployment. In a GitOps workflow, a GitOps agent operates between the Git repository and the target environment, such as Kubernetes, where applications are deployed. The agent continuously monitors Git and ensures the live environment matches the desired state defined in code.

At a high level, GitOps works by:

• Tracking all configuration and application changes in Git
• Continuously comparing the desired state (Git) with the actual state (Kubernetes)
• Automatically reconciling differences when changes are detected

For example, if a developer updates a YAML file to scale a Kubernetes deployment from two pods to four, the GitOps agent detects the change, compares the two states, and applies the update to the cluster. This reconciliation process keeps environments consistent, auditable, and predictable.

Argo CD and Kubernetes form a strong foundation for a well-designed GitOps strategy. Argo CD functions as a true GitOps controller by continuously syncing Kubernetes clusters with configurations stored in Git. When paired with Helm, the workflow becomes even more efficient.

Together, Argo CD and Helm provide:

• Automated, Git-driven deployments
• Simplified application packaging with Helm charts
• Continuous synchronization and drift detection via Argo CD

This cloud-native combination helps enterprises accelerate software delivery while maintaining control and reliability. Kubernetes has become the de facto container orchestration platform for modern applications, but Kubernetes alone is not enough. To fully unlock its potential, teams must adopt a cloud-native deployment model like GitOps.

By integrating tools such as Argo CD and Helm into the software development lifecycle, organizations can:

• Deploy applications faster and more consistently
• Reduce manual intervention and configuration drift
• Improve visibility, traceability, and rollback capabilities

While Argo CD enables true GitOps workflows, Helm streamlines Kubernetes application deployments. Together, they create a powerful and scalable delivery model that helps teams move quickly without sacrificing stability or governance.

What is Argo CD?

Argo CD is a declarative, GitOps-based continuous delivery tool that helps you deploy applications from Git, manage their lifecycle, and keep your environment in sync. 

By choosing Argo CD, you can keep your deployments up to date and ensure that your application always follows the desired state. 

Argo CD allows you to define your applications and their environments as code and then deploy and update them on any Kubernetes cluster.

What is a Helm Chart?

While Kubernetes has become the de facto container orchestration platform for modern cloud-native enterprises, it comes with a steep learning curve. Configuring and deploying applications on Kubernetes can be complex and time-consuming, especially for teams new to the ecosystem. This is where Helm and Helm Charts make a significant difference.

Helm is an open-source package manager for Kubernetes that simplifies application deployment and management. A Helm Chart is a collection of pre-configured Kubernetes resources that define how an application should be deployed. Together, Helm and Helm Charts automate much of the deployment process, allowing teams to deploy and manage applications on Kubernetes quickly and reliably.

At a high level, Helm and Helm Charts help by:

• Automating Kubernetes application deployments
• Reducing the complexity of managing Kubernetes manifests
• Providing a repeatable and standardized deployment process

Argo CD Versus Helm 

Both Argo CD and Helm are popular open-source tools for managing and deploying cloud-native applications, but they have some major differences. Let's take a look at the three main differences between Argo CD and Helm.

1. Application Deployment

The first difference between Argo CD and Helm is how they deploy applications. Argo CD is a CD tool/platform that can be used to deploy applications to multiple environments. 

Helm is a package manager that can be used to deploy applications to a single environment. Hence, Argo CD is better suited for more complex deployments, and Helm is better suited for simple deployments.

2. Application Management

The second difference is how they manage applications. Argo CD is a GitOps-based tool, which means that it uses Git as a single source of truth and uses it as a focal point to store and track application configurations and manifests. 

This makes observability easier, and you can roll back to previous versions if needed. Helm considers Helm charts as a focal point to manage and deploy applications, and the changes must be tracked manually.

3. Scaling Applications

The third difference is how they scale applications. Argo CD is designed to scale horizontally and can easily be deployed to multiple clusters. 

With Helm, you can only deploy to a single cluster. Argo CD is well suited for large-scale deployments, and Helm is well suited for small-scale deployments.

How to Use Argo CD with Helm Charts

Now that we’ve covered Argo CD and Helm individually, let’s walk through how to use Argo CD with Helm charts to deploy applications in a GitOps-driven workflow.

To get started, you’ll need to complete the following steps:

• Set up a Kubernetes cluster and ensure it is up and running.
• Create a dedicated namespace to store all Argo CD–related resources.

Next, prepare your local environment:

• Install the Argo CD command-line interface (CLI) on your local machine.
• Use the Argo CD CLI to interact with the Argo CD instance and manage applications.

Once your local setup is complete, deploy Argo CD to your cluster:

• Deploy the Argo CD manifests to your Kubernetes cluster.
• Access the Argo CD UI using your preferred method (in this tutorial, we use port forwarding).
• Log in to the Argo CD UI using the default username and password, which we’ll show later in the tutorial.

After Argo CD is up and running, configure Helm:

• Install the Helm CLI on your local machine to interact with Helm charts.
• Connect Helm to your Argo CD instance and configure Argo CD to work with Helm charts.

Finally, deploy your applications:

• Use Argo CD to deploy applications defined by Helm charts.
• Manage updates, rollbacks, and synchronization directly through Argo CD.

By combining Argo CD with Helm charts, you can streamline application deployments, maintain consistency across environments, and fully embrace a GitOps approach for managing Kubernetes workloads.

Tutorial

For this tutorial, the only prerequisite is to have access to a Kubernetes cluster. You can also use Minikube or Kind to get a one-node cluster.

First, create a namespace: 

kubectl create namespace argocd

Apply the manifest file to the namespace created: 

kubectl apply -n argocd -f https://raw.githubusercontent.com/argoproj/argo-cd/stable/manifests/install.yaml

Make sure all your pods are running properly inside the namespace:

kubectl get pods -n argocd

Now, let’s expose our ArgoCD server UI through port forwarding:

kubectl port-forward svc/argocd-server -n argocd 8080:443

Once you do that, you can now see the ArgoCD UI on https://localhost:8080/

CD login in screen">

Now, you need a username and password to log in. By default, the Username is ‘admin’ and the password can be generated using the following command:

kubectl -n argocd get secret argocd-initial-admin-secret -o jsonpath="{.data.password}" | base64 -d; echo

You will get an output to use as your password. Once you have the username (admin) and the password, login to ArgoCD.

CD UI">

Also, make sure you can use Argo CD locally via CLI, hence install the Argo CD CLI: 

brew install argocd

Now, you can login and talk to your Argo CD via CLI:

argocd login localhost:8080

It will ask you for the username and password. Set both, and the login will be successful.

Deploying Application via Helm to Argo CD

Reference the Argo CD example repo to deploy a guestbook application via Helm.

Let’s create an application on ArgoCD.

argocd app create helm-guestbook --repo https://github.com/argoproj/argocd-example-apps.git --path helm-guestbook --dest-server https://kubernetes.default.svc --dest-namespace default

You should see the application getting created:

application 'helm-guestbook' created

Let’s check the status of the application created:

argocd app get helm-guestbook

‍

‍

You can see that both Service and Deployment are in OutOfSync status. Let’s sync the application with the following command:

argocd app sync helm-guestbook

CD application">

‍

You can now see that the health status of our Service is Healthy and Deployment is Progressing. The Deployment will take some time and becomes Healthy.

You can verify the created application on Argo CD by going to the UI.

‍

CD Helm Chart">

Here you can see that the status is Healthy and Synced.

By doing the port-forward, you can easily access your deployed application:

kubectl port-forward svc/helm-guestbook 9090:80 

Let’s access our application at https://localhost:9090/.

Deploying Helm Charts with Argo CD

Let us use Argo CD to deploy Helm Charts.

Go to settings in the Argo CD UI and add Repositories.

‍

CD Settings">

‍

Add the following details and connect.

‍

‍

You should see your added repository in the list.

‍

‍

Now, click on create a new application. We will deploy NGINX Helm chart on Argo CD.

Make sure to specify the required details.

‍

‍

Once you click on create, you should be able to see your application on the Argo CD dashboard.

At first, the application will be out of sync. Once we synchronize the application, it will update and show as healthy.

‍

CD dashboard">

‍

Click on ‘Sync’ and then ‘Synchronize’

‍

‍

Now, if you go back and see, your application should show Healthy and Synced status. 

‍

CD helm chart application">

‍

GitOps Using Harness

Harness provides native GitOps functionality that manages Argo CD which lets you deploy services by syncing the Kubernetes manifests in your source repos with your target clusters. First, you set up Harness GitOps by installing a GitOps Agent in your environment. Next, you define how to manage the desired and target state in a GitOps Application in Harness. The GitOps Agent performs the sync operations defined in the Application and reacts to events in the source and target states.

‍

Try this Harness GitOps using one of your Kubernetes clusters. 

First, you will need to sign up for a Free Harness Account and navigate to the GitOps tab.

Navigate to Deployments > GitOps from the side menu.

Navigate to GitOps > Settings > GitOps Agents.

One by one, you will connect all the required GitOps settings shown below.

Once everything is connected and verified, you can start deploying applications via Harness GitOps. By taking the famous guestbook example, once the deployment is done, you should see your Harness GitOps dashboard as shown below:

You can follow this simple Harness GitOps tutorial to see how intuitive and simple it is to deploy applications via Harness GitOps. 

Let’s Do GitOps

GitOps is a modern software delivery approach that has a bright future ahead. If you are working with Kubernetes-related deployments, there are many GitOps benefits. GitOps accelerates your software deployment speed focusing on a rich developer experience. Combined with DevOps best practices, GitOps gives wings to your software delivery.

Looking for a GitOps continuous delivery tool? Request a demo of Harness CD & GitOps today!