Smørfugl Smørfugl, smoerfugl.dk

Using ArgoCD in Kubernetes for a Better Experience

ArgoCD has revolutionized how we deploy and manage applications in Kubernetes clusters. As a continuous delivery tool specifically designed for Kubernetes, ArgoCD implements GitOps principles to provide a declarative, version-controlled approach to application deployment. Having worked with ArgoCD in production environments managing hundreds of microservices, I can attest to its transformative impact on deployment workflows and operational efficiency.

Why Choose ArgoCD?

GitOps-Native Approach ArgoCD treats Git as the single source of truth for your deployments. This means your application state is declaratively defined in Git repositories, making rollbacks, audits, and change tracking straightforward. Every deployment is traceable, and your infrastructure state becomes as version-controlled as your application code.

Visual Application Management One of ArgoCD’s standout features is its intuitive web UI that provides real-time visualization of your applications and their health status. You can see the relationship between different Kubernetes resources, track deployment progress, and quickly identify issues without diving into command-line tools.

Automated Synchronization ArgoCD continuously monitors your Git repositories and automatically synchronizes the desired state with your Kubernetes cluster. This eliminates the need for manual deployments and reduces human error, especially crucial when managing multiple environments and numerous microservices.

Multi-Cluster Management For organizations running multiple Kubernetes clusters, ArgoCD excels at centralized management. You can deploy to different clusters from a single ArgoCD instance, making it ideal for managing development, staging, and production environments consistently.

Installing ArgoCD

Getting ArgoCD up and running in your Kubernetes cluster is straightforward. Here’s a step-by-step guide:

1. Create ArgoCD Namespace

kubectl create namespace argocd

2. Install ArgoCD

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

3. Access the ArgoCD Server

By default, ArgoCD server is not exposed externally. You can access it using port-forwarding:

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

Alternatively, for production environments, configure an Ingress or LoadBalancer service.

4. Get Initial Admin Password

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

5. Login via CLI (Optional)

argocd login localhost:8080
argocd account update-password

Basic Usage and Application Deployment

Creating Your First Application

Once ArgoCD is installed, you can create applications either through the web UI or declaratively using YAML manifests. Here’s an example application configuration:

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: my-app
  namespace: argocd
spec:
  project: default
  source:
    repoURL: https://github.com/myorg/my-app-manifests
    targetRevision: HEAD
    path: k8s
  destination:
    server: https://kubernetes.default.svc
    namespace: my-app
  syncPolicy:
    automated:
      prune: true
      selfHeal: true
    syncOptions:
    - CreateNamespace=true

Repository Structure

For optimal ArgoCD integration, organize your Git repository with clear separation between application code and Kubernetes manifests:

my-app/
├── src/                    # Application source code
├── k8s/                    # Kubernetes manifests
│   ├── deployment.yaml
│   ├── service.yaml
│   └── configmap.yaml
└── helm/                   # Helm charts (alternative to raw manifests)
    ├── Chart.yaml
    ├── values.yaml
    └── templates/

Managing Applications

ArgoCD provides several ways to trigger deployments:

  • Automatic Sync: ArgoCD continuously monitors Git and applies changes automatically
  • Manual Sync: Trigger deployments manually through the UI or CLI
  • Webhooks: Configure Git webhooks for immediate synchronization on commits

Best Practices for GitOps with ArgoCD

1. Separate Application and Infrastructure Repositories

Maintain clear separation between application code and deployment configurations. This allows different teams to manage their respective domains while maintaining proper access controls.

2. Use Application Sets for Multiple Environments

For managing applications across multiple environments or clusters, leverage ArgoCD’s ApplicationSet feature:

apiVersion: argoproj.io/v1alpha1
kind: ApplicationSet
metadata:
  name: my-app-set
spec:
  generators:
  - list:
      elements:
      - cluster: dev
        url: https://dev-cluster
      - cluster: prod
        url: https://prod-cluster
  template:
    metadata:
      name: 'my-app-'
    spec:
      source:
        repoURL: https://github.com/myorg/my-app
        targetRevision: HEAD
        path: 'environments/'
      destination:
        server: ''

3. Implement Progressive Deployment

Structure your repositories to support progressive deployment strategies:

  • Use separate branches or directories for different environments
  • Implement automated promotion between environments
  • Configure appropriate sync policies for each environment (automatic for dev, manual for production)

4. Monitor and Alert

Set up proper monitoring for your ArgoCD instance:

  • Monitor application health and sync status
  • Configure alerts for sync failures or application health issues
  • Use ArgoCD’s Prometheus metrics for operational insights

5. Security Considerations

  • Use RBAC to control access to applications and projects
  • Implement proper Git repository access controls
  • Regularly rotate ArgoCD admin credentials
  • Consider using external secret management tools for sensitive data

Troubleshooting Common Issues

Sync Failures

When applications fail to sync, check:

  • Kubernetes resource quotas and limits
  • RBAC permissions for ArgoCD service account
  • Resource conflicts or naming collisions

Resource Drift

If resources show as “OutOfSync” despite recent synchronization:

  • Check for manual changes made directly to the cluster
  • Verify that all resources are properly defined in Git
  • Consider enabling self-healing in sync policies

Conclusion

ArgoCD transforms Kubernetes application management by bringing GitOps principles to the forefront of your deployment strategy. Its declarative approach, combined with powerful visualization and automation capabilities, makes it an essential tool for any organization serious about Kubernetes operations.

The benefits become even more pronounced in complex environments with multiple clusters and numerous microservices. By treating Git as the source of truth and automating the synchronization process, ArgoCD reduces operational overhead while improving deployment reliability and audit capabilities.

Whether you’re just starting with Kubernetes or looking to improve your existing deployment processes, ArgoCD provides a robust, scalable solution that grows with your organization’s needs. The investment in learning and implementing ArgoCD pays dividends in operational efficiency and deployment confidence.