Back to insights

Argo CD app of apps: from an empty cluster to platform services

Argo CD can run your whole platform from Git. Getting Argo CD itself onto a bare cluster is the step the GitOps guides tend to skip.

A view through FlowFactor's office towards the open workspace, with colleagues talking

Your cluster exists and nothing is running on it. You want Argo CD to manage what goes on there, which is a sound plan right up to the moment you realise Argo CD is itself software that has to be installed, pointed at a repository and handed a credential to read it. It cannot do that for itself.

‍

On the internal developer platform we built on OVHcloud in 2026, the infrastructure pipeline takes that first step and then gets out of the way. This article covers the handover: how the pipeline installs Argo CD and gives it the keys, how the app of apps pattern takes over the platform services from there, and where the secrets come from when they cannot sit in Git.

‍

Part 3 of six. You don't need the other parts to follow this one.

‍

Where does Terraform stop and Argo CD start?

‍

Terraform provisions the cluster and its supporting infrastructure. Argo CD manages the platform software described in Git.

‍

After Terraform creates the OVHcloud resources, the pipeline makes its generated kubeconfig available to the bootstrap jobs. The handover has three steps:

‍

  1. Supply the credentials the platform services need.
  2. Install Argo CD if it is not already present.
  3. Apply the root Application pointing to the platform repository.

‍

When installing Argo CD, the job waits for its Application custom resource definition and server deployment before continuing. Applying the root Application then gives Argo CD the repository location it needs to begin reconciliation.

‍

This gives changes a clear home. Node-pool settings belong to Terraform. Harbor or monitoring configuration belongs to the GitOps repository.

‍

Our article on building a CI/CD pipeline discusses the push-versus-pull choice behind this arrangement. Here, CI establishes the initial connection; Argo CD manages the tracked configuration afterwards.

‍

Managing services through a root Application

‍

The app of apps pattern uses a parent Application to manage manifests that include other Argo CD Applications. Each child Application describes a service and where to obtain its configuration.

‍

We point the root at the platform repository's manifests/ directory and enable recursive discovery.

‍

apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
  name: root-manifests
  namespace: argocd
spec:
  source:
    repoURL: "https://gitlab.com/your-org/idp-platform/cluster_infrastructure.git"
    path: manifests
    directory:
      recurse: true
  syncPolicy:
    automated:
      prune: true
      selfHeal: true

‍

The repository URL and path identify the source. Recursive discovery includes manifests in subdirectories, so the service definitions do not all need to sit at the same level.

‍

Under the root are Applications for Harbor, GitLab Runner, SonarQube, monitoring, authentication and certificate management. The configuration also includes the MCP servers used by the AI agents.

‍

Adding a service starts with committing its Application definition and configuration. Argo CD processes the change through the existing structure.

‍

The registry, the delivery tools and the agent backends all have to be running before anyone can onboard an application onto this platform.

‍

What do prune and selfHeal change?

‍

The root's automated-sync settings determine how it responds when Git and the cluster differ.

‍

prune: true allows Argo CD to remove tracked resources that are no longer declared. Without pruning, deleting their configuration from Git does not automatically remove the live resources.

‍

selfHeal: true allows reconciliation of supported changes made directly to tracked live resources back to the desired configuration.

‍

These settings belong to the root Application in the excerpt. The child Applications have their own sync policies.

‍

When do ApplicationSets become relevant?

‍

ApplicationSets generate Applications from templates and generator inputs. App of apps manages explicit child Application manifests.

‍

ApproachHow Applications are definedWhat you maintain
App of appsA parent manages child Application manifestsThe child definitions and their configuration
ApplicationSetsA controller generates Applications from templates and inputsThe shared template and generator inputs

‍

The Argo CD bootstrap documentation presents ApplicationSets alongside app of apps, and the ApplicationSet documentation describes generators such as registered clusters and Git directories or files.

‍

We implemented app of apps in this experiment. For a single cluster with a fixed set of platform services, explicit child Applications are easy to read and review. ApplicationSets pay off when you generate many similar Applications, for example across clusters or teams.

‍

Supplying secrets without committing their values

‍

The bootstrap reads credentials from masked GitLab CI variables and creates or updates Kubernetes Secrets. The platform manifests reference those Secrets without containing their values.

‍

Argo CD needs access to the private repository. Harbor needs admin credentials, while the runner, authentication integration and monitoring services have their own credentials.

‍

The bootstrap repeatedly uses this pattern:

‍

kubectl create secret generic harbor-admin-credentials \
  --namespace harbor \
  --from-literal=HARBOR_ADMIN_PASSWORD="${HARBOR_ADMIN_PASSWORD}" \
  --dry-run=client -o yaml | kubectl apply -f -

‍

The first command renders the Secret definition. Piping it into kubectl apply creates the resource if absent or updates it if it already exists. A later bootstrap run can therefore use the same command.

‍

We use the same mechanism for the GitLab runner token, OAuth credentials, SonarQube and database passwords, Grafana credentials and the alerting webhook. These values are supplied outside the GitOps repository and Terraform-managed Kubernetes Secret resources.

‍

After injecting repository credentials, the pipeline restarts Argo CD's repository server and waits for the rollout before applying the root Application.

‍

For a separate implementation with a dedicated secret store, our Vault and External Secrets Operator article shows how an operator retrieves values from Vault.

‍

From bootstrap to platform services

‍

CI supplies credentials and installs Argo CD. The root Application establishes the repository entry point, and child Applications manage the services.

‍

You can follow that chain from the infrastructure pipeline to the root manifest and individual service definitions in the GitOps directory.

‍

In part 4, we examine how those services support application delivery: the runner, Harbor, SonarQube, monitoring and platform access.

‍

Is your GitOps setup working the way you intended? Get a second opinion.

‍

The environment we built this on is no longer running. The code is public, so you can read the architecture and the decisions behind it.

‍

The full series

‍

  1. AI platform engineering on OVHcloud: an internal developer platform experiment
  2. OVHcloud Managed Kubernetes with Terraform: from state to cluster
  3. Argo CD app of apps: from an empty cluster to platform services
  4. Harbor container registry and GitLab CI: from build to Kubernetes
  5. Golden paths: what should an AI agent be allowed to change?
  6. Google ADK agents for app onboarding: where human review fits

Cis Verbruggen

Related items

CI/CD Pipelines

Google ADK agents for app onboarding: where human review fits

read more
Two FlowFactor engineers looking at a laptop together in a glass-walled office

CI/CD Pipelines

Golden paths: what should an AI agent be allowed to change?

read more
Two FlowFactor engineers in a meeting room with laptops on the table

CI/CD Pipelines

Harbor container registry and GitLab CI: from build to Kubernetes

read more
Three FlowFactor engineers at a meeting table with laptops open