# argocd-cm: change polling interval
data:
timeout.reconciliation: 180s
ArgoCD
Topics in this category
ArgoCD
GitOps Principles
The reconciliation loop continuously compares desired (Git) vs live (cluster) state and acts on differences. ArgoCD polls Git on an interval (default ~3 minutes) and can react instantly to webhooks; it also watches cluster resources. Reconciliation computes the diff, updates sync/health status, and applies changes if auto-sync is enabled.
Real-world example
A Git webhook triggers ArgoCD to reconcile immediately on merge instead of waiting for the next poll cycle.
Sync & Health
Applications
GitOps Principles
Because the entire desired state is in Git, recovering a cluster means installing ArgoCD and pointing it at the same Git repos; it rebuilds all applications to match. This makes clusters reproducible and reduces recovery time. Combined with backups of stateful data and cluster-level bootstrap (App of Apps), whole environments can be recreated declaratively.
Real-world example
After losing a cluster, the team provisions a new one, installs ArgoCD, applies the root app, and the platform rebuilds from Git.
App of Apps
Multi-cluster
GitOps Principles
Declarative configuration states the desired end state ('there should be 3 replicas') and lets the system converge to it; imperative issues step-by-step commands ('scale to 3 now'). GitOps is declarative: you commit the desired state and the agent makes it so, which is idempotent, reproducible, and self-correcting versus one-off imperative commands.
# Declarative desired state
spec:
replicas: 3
# vs imperative: kubectl scale deploy/app --replicas=3
Real-world example
The repo declares 3 replicas; whether the cluster had 1 or 5, ArgoCD converges it to 3.
Applications
Sync & Health
GitOps Principles
Every change is a reviewed, attributable Git commit, giving a complete audit trail and enforced approvals via branch protection. Cluster credentials stay inside the cluster (pull model), reducing exposure. Policy checks and CI can gate merges, and drift detection ensures only approved state persists—supporting compliance evidence and least-privilege access.
Real-world example
Auditors trace every production change to a signed, reviewed pull request, satisfying change-management controls.
RBAC
Applications
GitOps Principles
GitOps excels for declarative Kubernetes config but adds friction for imperative or highly dynamic actions, secret handling needs extra tooling, and Git becomes a critical dependency. Debugging can require understanding reconciliation timing, and very large fleets need patterns (ApplicationSets) to avoid sprawl. It's not ideal for one-off tasks or non-declarative systems.
Real-world example
The team keeps ad-hoc database migrations in a controlled Job with hooks rather than forcing every imperative action through GitOps.
Sync Waves & Hooks
Applications
GitOps Principles
A single source of truth is the one authoritative record of desired state. GitOps uses Git because it provides versioning, history, code review, access control, and rollback out of the box, and it's a familiar developer tool—making desired state auditable and collaborative.
Real-world example
Every environment's desired state lives in Git, so 'what should be running' is always answerable from one place.
Applications
Sync & Health
GitOps Principles
Continuous reconciliation is an agent repeatedly comparing desired state (Git) to actual state (cluster) and correcting differences, rather than applying changes only once. It keeps the system converged over time and detects drift automatically.
Real-world example
Even with no new commits, ArgoCD keeps checking and correcting the cluster so it never quietly diverges from Git.
Sync & Health
Applications
GitOps Principles
Because every change is a Git commit with author, timestamp, and review, Git history is a complete, tamper-evident audit trail of who changed what and when. Branch protection enforces approvals, satisfying change-management and separation-of-duties requirements.
Real-world example
An auditor reconstructs the entire change history of production from Git logs and merged pull requests.
RBAC
Applications
GitOps Principles
IaC is codifying infrastructure declaratively; GitOps is an operating model that uses IaC plus Git as the source of truth and an agent that continuously reconciles. All GitOps uses IaC, but not all IaC is GitOps—IaC run manually via a pipeline isn't GitOps without pull-based continuous reconciliation.
Real-world example
Terraform applied by hand is IaC; the same declarations reconciled continuously by an in-cluster agent is GitOps.
Applications
Multi-cluster
GitOps Principles
For cloud resources outside Kubernetes, use operators that reconcile external state from CRDs (e.g., Crossplane, cloud provider operators). ArgoCD then manages those CRs in Git like any manifest, extending GitOps to databases, queues, and cloud infra via Kubernetes-native controllers.
Real-world example
An S3 bucket is declared as a Crossplane CR in Git; ArgoCD syncs it and Crossplane provisions the real bucket.
Applications
Multi-cluster
GitOps Principles