How to use ArgoCD for pure GitOps deployments

What is GitOps and why you should abandon manual deploys

Managing production servers used to be a stressful task full of blind commands executed in the terminal. With the arrival of Kubernetes, which is a system designed to manage and automate software execution in containers, our daily lives improved, but the risks of configuration errors remained high. This is where GitOps comes in, a methodology where the Git repository becomes the single source of truth for everything running on the server. In practice, this means nobody touches production directly; if you want to change something, you modify a text file in Git and let an automated tool handle the rest.

When we combine this philosophy with advanced tools like reusable packaging and smart templates for Kubernetes, the software delivery process gains impressive consistency. Instead of complex terminal scripts triggered by external CI servers, we rely on a dedicated controller running directly inside the cluster. This model eliminates silent configuration drift, which is that classic problem where the staging server works perfectly, but production fails because someone forgot to manually change a variable.

How ArgoCD monitors and synchronizes your cluster

ArgoCD is a continuous delivery tool built specifically for Kubernetes, acting as a digital bodyguard for your infrastructure. It constantly compares two things: what is written in your Git repository files and what is actually running on the production servers. If someone logs into the cluster and changes a configuration by brute force, ArgoCD notices the discrepancy immediately and alerts you that the system is out of the expected baseline.

In practice, this continuous synchronization ensures that the server reality reflects exactly what developers approved in the code. Before adopting this rigorous automation, many teams faced bottlenecks in build and packaging pipelines that consumed precious time due to a lack of standardization in deliveries. With ArgoCD, the feedback loop shortens dramatically, as any manifest change is reflected in the environment within seconds, whether automatically or through controlled human approval.

Installing ArgoCD on Kubernetes step by step

To bring this architecture to life, we need to install ArgoCD directly into our development or production Kubernetes cluster. The process is straightforward and uses the official manifests provided by the open source project maintainers. Follow the steps below in your command line:

1. Create a dedicated namespace to isolate ArgoCD resources in the cluster:

   kubectl create namespace argocd

2. Apply the official installation manifests directly from the project repository:

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

3. Access the ArgoCD web interface by forwarding the local port to the service:

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

After running these commands, open your browser and access the local address to manage your applications. Keep in mind that the initial password for the admin user is stored in a Kubernetes secret, requiring a quick retrieval command if you are accessing the dashboard for the first time.

Configuring your first application with pure GitOps

With ArgoCD installed and running, the next step is registering the Git repository containing your application configuration files. ArgoCD needs read permission to clone the YAML manifests that describe services, deployments, and network endpoints. We can do this through the graphical interface or by creating a custom resource called Application directly in the cluster.

Maintaining consistency and security during this process is crucial, especially when dealing with sensitive access data. In corporate scenarios, it is common to integrate this continuous delivery layer with external secret vaults and hardened credential stores to prevent key leaks in the repository. ArgoCD integrates seamlessly with these tools, ensuring that the GitOps lifecycle remains completely secure and auditable from end to end.

Final thoughts on resilience and continuous operation

Adopting ArgoCD to manage deployments with pure GitOps radically transforms the operational maturity of any engineering team. Real-time visibility into production status reduces incident resolution time and eliminates the stress associated with traditional software releases. By turning infrastructure into version-controlled code, you gain the peace of mind knowing that any failure can be reverted with a simple history command in Git.

The secret to long-term success lies in the team's discipline never to manually alter resources in the cluster. Over time, this culture of automated reliability frees engineers to focus on creating business value, knowing their technical foundation is protected by a rigorous, transparent, and resilient synchronization cycle.