ArgoCD App-of-Apps Pattern

ArgoCD's app-of-apps for cross-cluster deployment.

Idea

The ArgoCD app-of-apps pattern is a way to manage many ArgoCD applications. A single root Application points at a directory of child Applications; syncing the root cascades to the children; the discipline is composable.

What the pattern looks like:

• One root Application object.: The root is a normal ArgoCD Application. Its source is a directory in git that contains other Application manifests.
• Points at a directory of other Applications.: The directory has child Application YAML files. Each child Application points at its own source; the children are independent in terms of their content but managed together.
• Single point of entry.: The team manages the root Application. Syncing the root creates or updates the child Applications; the children then sync their content; the cascade is automatic.
• Cascading sync.: The root's sync triggers child syncs. The team's deployment of a new environment is one operation; ArgoCD handles the rest.
• Per-environment roots.: Different environments have different roots. Production root manages production children; staging root manages staging children; the pattern scales.

The idea is composable. The team's Applications are organized hierarchically; the discipline scales.

Benefits

The benefits are real. Bootstrap, disaster recovery, and consistency all benefit from the pattern.

• Bootstrap whole environment from one application.: A new cluster needs many applications installed. The app-of-apps pattern lets the team apply one root Application; ArgoCD creates and syncs all the children; the bootstrap is one operation.
• Disaster recovery.: When recovering from a disaster, re-applying the root recovers everything. The children are recreated; the cascade restores the cluster's full application set.
• Re-apply root, everything follows.: The discipline turns disaster recovery into a single operation. The team's recovery is fast; the operations are bounded.
• Consistency.: The root manages the children. Adding a new application means adding it to the root's directory; the discipline is consistent.
• Reviewability.: Changes to the application set go through the root's git. PRs are visible; reviews happen; the discipline is auditable.

The benefits compound for teams managing many applications. The pattern's value scales with size.

Avoid

The pattern has limits. Deeply nested apps-of-apps-of-apps becomes hard to debug; the discipline is keeping the hierarchy shallow.

• Deeply nested apps-of-apps-of-apps.: Some teams nest the pattern multiple levels. Root of roots of roots; each level adds complexity; the cascade becomes hard to reason about.
• Two levels is plenty.: The discipline limits to two levels typically. Root manages applications directly; rare cases warrant three levels; beyond that is over-engineering.
• Beyond that, debugging is hard.: When applications are not syncing correctly, the deep nesting makes investigation harder. The team's discipline keeps the hierarchy navigable.
• ApplicationSets as alternative.: ArgoCD's ApplicationSets generate Applications dynamically. For some patterns, ApplicationSets are simpler than nested app-of-apps; the team picks the right tool.
• Document the structure.: The team's app-of-apps structure is documented. New engineers understand; debugging is faster; the discipline is preserved.

ArgoCD app-of-apps is one of those GitOps patterns that pays off when used at the right level. Nova AI Ops integrates with GitOps tooling, surfaces deployment patterns, and supports the team's GitOps discipline.