> ## Documentation Index
> Fetch the complete documentation index at: https://notes.kodekloud.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Demo GitOps Delivery with ArgoCD UI

> Walkthrough of using Argo CD web UI to create, sync, and auto-reconcile Kubernetes applications from Git, including manifest and Helm examples and drift detection

Argo CD is a leading GitOps continuous delivery tool in the cloud-native ecosystem. The core idea is simple and powerful: declare the desired cluster state in Git, then let Argo CD continuously watch that repository and reconcile your Kubernetes cluster to match it. Any drift is detected and corrected automatically.

This guide walks you through the Argo CD web UI to build a mental model of how Argo CD operates, and also demonstrates equivalent CLI checks. You will:

* Inspect Argo CD controllers and pods.
* Create Applications from a Git repo (manifest- and Helm-based).
* Sync Applications, observe Argo CD applying manifests, and watch drift detection and reconciliation.
* See how to enable Auto-Sync (self-heal) for Helm-based apps.

## Prerequisite

Ensure Argo CD controllers are deployed and running in the `argocd` namespace:

```bash theme={null}
kubectl get pods -n argocd
```

Example output:

```bash theme={null}
NAME                                                       READY   STATUS    RESTARTS   AGE
argocd-application-controller-0                             1/1     Running   0          7m26s
argocd-applicationset-controller-f869b9f85-zgfdm            1/1     Running   3          7m27s
argocd-dex-server-656bfff4b5-tcmhp                          1/1     Running   0          7m27s
argocd-notifications-controller-9669744c8-kkqwg             1/1     Running   0          7m27s
argocd-redis-7c7678cd79-kf8mf                               1/1     Running   0          7m27s
argocd-repo-server-779879c89d-w7fxl                         1/1     Running   0          7m26s
argocd-server-5c54c9fdd4-tpqnf                              1/1     Running   0          7m26s
```

If you installed Argo CD using the official manifests, the default admin user is `admin`. The initial admin password is typically the name of the `argocd-server` pod (or a password you set). In this demo we used `admin123` for convenience — replace that with your real initial password.

Access the Argo CD Web UI and sign in with your admin credentials.

## Create a Manifest-Based Application (guestbook)

An Argo CD Application object connects a Git source to a destination cluster/namespace. We'll create a manifest-based frontend application named `web-frontend` that points at the argoproj example repo.

1. In the Argo CD UI click "New App".
2. Name: `web-frontend`.
3. Project: `default`.
4. Sync policy: choose `Manual` for an interactive demo.
5. Source: set repository to `https://github.com/argoproj/argocd-example-apps.git`, revision `HEAD`, and path `guestbook`.
6. Destination: use the in-cluster API server `https://kubernetes.default.svc` and namespace `applications` (Argo CD can also create this namespace for you).

Below is the repo folder we'll use (guestbook):

![A dark-mode GitHub repository page for argo/argocd-example-apps showing the guestbook folder and files (guestbook-ui-deployment.yaml, guestbook-ui-svc.yaml). The top shows a recent commit message "fix: invalid image for guestbook."](https://mintcdn.com/kodekloud-c4ac6d9a/8pYzlc1aD6cgTw8b/images/Prep-Course-Certified-Cloud-Native-Platform-Engineering-CNPE/GitOps-and-Continuous-Delivery/Demo-GitOps-Delivery-with-ArgoCD-UI/argocd-guestbook-ui-deployment-svc-fix.jpg?fit=max\&auto=format\&n=8pYzlc1aD6cgTw8b\&q=85\&s=d5ee6aeaea54b3f03dd8ce105fe91ea6)

The Create Application form should look like this (repo, path, revision, destination):

![A screenshot of the Argo CD web UI showing the "Create Application" form. It displays SOURCE fields (repo URL https://github.com/argoproj/argocd-example-apps.git, revision HEAD, path "guestbook") and DESTINATION fields (cluster URL https://kubernetes.default.svc).](https://mintcdn.com/kodekloud-c4ac6d9a/8pYzlc1aD6cgTw8b/images/Prep-Course-Certified-Cloud-Native-Platform-Engineering-CNPE/GitOps-and-Continuous-Delivery/Demo-GitOps-Delivery-with-ArgoCD-UI/argocd-create-application-guestbook.jpg?fit=max\&auto=format\&n=8pYzlc1aD6cgTw8b\&q=85\&s=12c008a60d71799586348b05e7a6a63a)

Before creating the Application, ensure the `applications` namespace exists (or allow Argo CD to auto-create it). After creating the Application, it will appear in the Applications list. Initially it will be OutOfSync because the cluster does not yet have the resources defined in Git.

![Screenshot of the Argo CD web UI showing the "Applications" view with a single "web-frontend" application card marked Missing / OutOfSync. The left sidebar shows navigation (Applications, Settings, Documentation) and the card includes details and action buttons for Sync, Refresh, and Delete.](https://mintcdn.com/kodekloud-c4ac6d9a/8pYzlc1aD6cgTw8b/images/Prep-Course-Certified-Cloud-Native-Platform-Engineering-CNPE/GitOps-and-Continuous-Delivery/Demo-GitOps-Delivery-with-ArgoCD-UI/argocd-web-frontend-outofsync.jpg?fit=max\&auto=format\&n=8pYzlc1aD6cgTw8b\&q=85\&s=e2c134acc901436982738eadd11d5990)

## Inspect and Sync the Application

Click the application to open the resource tree. The tree shows Service, Deployment, ReplicaSet and Pods that are declared in Git. Yellow / OutOfSync indicates the resources are missing or differ from the cluster.

Click "Sync" → "Synchronize" to have Argo CD apply the manifests. Argo CD will create the namespace (if requested) and apply the resources.

After syncing, Argo CD should report the application as Synced and Healthy. Verify cluster resources:

```bash theme={null}
kubectl get namespaces
kubectl get all -n applications
```

Example output:

```bash theme={null}
NAME              STATUS   AGE
applications      Active   9m35s
argocd            Active   9m45s
default           Active   103m

# resources in applications namespace
NAME                                READY   STATUS    RESTARTS   AGE
pod/guestbook-ui-6595f948db-5xgzh   1/1     Running   0          26s

NAME                 TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)   AGE
service/guestbook-ui ClusterIP   172.20.182.60   <none>        80/TCP    26s

NAME                            READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/guestbook-ui    1/1     1            1           26s

NAME                                    DESIRED   CURRENT   READY   AGE
replicaset.apps/guestbook-ui-6595f948db 1         1         1       26s
```

## Drift Detection and Reconciliation

Argo CD continuously compares the live cluster state with the desired state in Git. To demonstrate drift detection, make a manual change on the cluster: scale the `guestbook-ui` Deployment to 5 replicas.

```bash theme={null}
kubectl scale deployment guestbook-ui -n applications --replicas=5
```

Verify the cluster now shows 5 replicas:

```bash theme={null}
kubectl get all -n applications
```

Example output:

```bash theme={null}
NAME                                    READY   STATUS    RESTARTS   AGE
pod/guestbook-ui-6595f948db-2jbqq       1/1     Running   0          5s
pod/guestbook-ui-6595f948db-4ckxg       1/1     Running   0          5s
pod/guestbook-ui-6595f948db-5xgzh       1/1     Running   0          78s
pod/guestbook-ui-6595f948db-5zlx8       1/1     Running   0          5s
pod/guestbook-ui-6595f948db-rpnp8       1/1     Running   0          5s

NAME                                    READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/guestbook-ui            5/5     5            5           78s

NAME                                    DESIRED   CURRENT   READY   AGE
replicaset.apps/guestbook-ui-6595f948db 5         5         5       78s
```

Click "Refresh" in the Argo CD UI — the application will move to OutOfSync. Click "Diff" to see the exact difference between live and desired states; the diff will show `replicas: 5` on the cluster vs `replicas: 1` in Git.

To view resource status and the tree while OutOfSync:

![A screenshot of the Argo CD web UI showing the "web-frontend" application details tree with resource boxes (service, deployment, replica set and multiple pods). Status panels at the top show sync and health information (OutOfSync / Sync OK) and a left sidebar lists filters and health/status counts.](https://mintcdn.com/kodekloud-c4ac6d9a/8pYzlc1aD6cgTw8b/images/Prep-Course-Certified-Cloud-Native-Platform-Engineering-CNPE/GitOps-and-Continuous-Delivery/Demo-GitOps-Delivery-with-ArgoCD-UI/argocd-web-frontend-resources-status.jpg?fit=max\&auto=format\&n=8pYzlc1aD6cgTw8b\&q=85\&s=4e5962a1ddf0d9987b4c7469febc393f)

Click "Sync" again to reconcile. Argo CD will apply the desired manifests and scale the Deployment back to 1 replica. Confirm on the cluster:

```bash theme={null}
kubectl get all -n applications
```

Example output after reconciliation:

```bash theme={null}
NAME                                READY   STATUS    RESTARTS   AGE
pod/guestbook-ui-6595f948db-5xgzh   1/1     Running   0          2m15s

NAME                 TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)   AGE
service/guestbook-ui ClusterIP   172.20.182.60   <none>        80/TCP    2m15s

NAME                            READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/guestbook-ui    1/1     1            1           2m15s

NAME                                    DESIRED   CURRENT   READY   AGE
replicaset.apps/guestbook-ui-6595f948db 1         1         1       2m15s
```

Argo CD has self-healed the drift and the app is Synced and Healthy again.

## Creating a Helm-Based Application

Argo CD supports multiple generators: raw manifests, Kustomize, Helm charts, and many more. As an example, create a backend application from a Helm chart in the same example repository.

The repo contains a Helm chart for the guestbook:

![A dark-mode GitHub repository page for "argoproj/argocd-example-apps" showing the helm-guestbook directory and a list of files and folders (e.g., templates, Chart.yaml, values.yaml).](https://mintcdn.com/kodekloud-c4ac6d9a/8pYzlc1aD6cgTw8b/images/Prep-Course-Certified-Cloud-Native-Platform-Engineering-CNPE/GitOps-and-Continuous-Delivery/Demo-GitOps-Delivery-with-ArgoCD-UI/argocd-example-apps-helm-guestbook.jpg?fit=max\&auto=format\&n=8pYzlc1aD6cgTw8b\&q=85\&s=adda3a5fb9a86f8e087d534974bbacc9)

Create a new Application in Argo CD:

* Name: `web-backend`
* Sync policy: enable Auto-Sync (self-heal), enable Prune Resources, and optionally Auto-Create Namespace.
* Source: `https://github.com/argoproj/argocd-example-apps.git`
* Path: `applications-helm/guestbook` (Argo CD auto-detects the chart as Helm)
* Destination: same cluster, namespace `applications-helm` (or let Argo CD create it)

Argo CD's UI exposes Helm values so you can override chart settings (for example set `replicaCount: 2`) before syncing the app.

![A screenshot of the Argo CD web UI showing the application creation/settings panel for an app named "web-backend." The sync policy options (Enable Auto-Sync, Prune Resources, Self Heal, Auto-Create Namespace) are visible and checked, with a dark navigation sidebar on the left.](https://mintcdn.com/kodekloud-c4ac6d9a/8pYzlc1aD6cgTw8b/images/Prep-Course-Certified-Cloud-Native-Platform-Engineering-CNPE/GitOps-and-Continuous-Delivery/Demo-GitOps-Delivery-with-ArgoCD-UI/argocd-web-backend-sync-settings.jpg?fit=max\&auto=format\&n=8pYzlc1aD6cgTw8b\&q=85\&s=e5bcd7de9a4abbec3be7474bc473c3ee)

Once created, Argo CD will deploy the Helm chart and keep it reconciled automatically. The resource tree will display Service, Deployment, ReplicaSet and Pods for the Helm release:

![A screenshot of the Argo CD web UI showing the "web-backend" application with status indicators (Healthy, Synced) and sync details at the top. Below is a visual resource tree/graph showing a service, deployment, replica set, and two running pods for the web-backend-helm-guestbook.](https://mintcdn.com/kodekloud-c4ac6d9a/8pYzlc1aD6cgTw8b/images/Prep-Course-Certified-Cloud-Native-Platform-Engineering-CNPE/GitOps-and-Continuous-Delivery/Demo-GitOps-Delivery-with-ArgoCD-UI/argocd-web-backend-resource-tree.jpg?fit=max\&auto=format\&n=8pYzlc1aD6cgTw8b\&q=85\&s=43c8fd2f20dbba7a4461e6d3e984aaca)

Verify pods on the cluster:

```bash theme={null}
kubectl get pods -n applications-helm
```

Example output:

```bash theme={null}
NAME                                                READY   STATUS    RESTARTS   AGE
web-backend-helm-guestbook-67d79cf59d-rllnd         1/1     Running   0          17s
web-backend-helm-guestbook-67d79cf59d-x4q7z         1/1     Running   0          17s
```

## Quick Reference: What an Argo CD Application Maps To

| Component | Purpose | Example / Notes |
| - | - | - |
| Source | Git repository and path containing manifests or chart | `https://github.com/argoproj/argocd-example-apps.git`, path `guestbook` |
| Destination | Cluster API and namespace where resources are applied | `https://kubernetes.default.svc`, namespace `applications` |
| Sync Policy | How and when Argo CD applies changes | Manual (interactive) or Auto-Sync (self-heal, prune) |
| Health & Sync Status | Visual indicators in the UI for desired vs live state | `Synced` / `OutOfSync`, `Healthy` / `Degraded` |

## Useful Links and References

* Argo CD official docs: [https://argo-cd.readthedocs.io/](https://argo-cd.readthedocs.io/)
* argoproj example apps repo: [https://github.com/argoproj/argocd-example-apps](https://github.com/argoproj/argocd-example-apps)
* Kubernetes docs: [https://kubernetes.io/docs/](https://kubernetes.io/docs/)

If you enable Auto-Sync with "Auto-Prune" and "Self Heal", Argo CD will automatically remove resources not declared in Git and reconcile live state to match Git. Use these options only when your Git repo is the single source of truth.

## Summary

In this walkthrough you learned how to:

* Inspect Argo CD controllers and pods and log into the web UI.
* Create Argo CD Applications from a Git repository (manifest-based).
* Sync Applications and observe Argo CD applying manifests to the cluster.
* Trigger drift manually and watch Argo CD detect and reconcile differences.
* Create a Helm-based Application and enable Auto-Sync for self-healing.

You can perform similar operations using the Argo CD CLI (argocd) and automate these patterns in CI/CD pipelines or GitOps workflows.

> **[Watch Video](https://learn.kodekloud.com/user/courses/prep-course-certified-cloud-native-platform-engineer-cnpe/module/dff5382b-dbe7-4cac-bd2b-d5a47028945e/lesson/e3b88945-2390-4aad-9959-16c8512e6322)**


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.