Table of contents
A colleague proposes exposing the selected menu release clearly. In a short standing review, TOP and his colleague examine the Git diff on the team’s shared screen. TOP notes the intended change and the checks that will connect the Argo CD revision to the service response.
GitOps helps us track the plan that was delivered. We still need to check the resources actually applied and the response received. The service incident is nearing resolution.
We have deployed a small service and defined maintenance evidence. GitOps connects those checks to a durable desired state. It does not remove the need for them.
Revised on 27 October 2026, this final episode explains Argo CD on an authorized workload cluster. Repository URLs, SSO groups and platform choices in the examples are fictional values to adapt. No multi-tenant production deployment or end-to-end VKS execution is claimed here.
Keep the executable artifact and the delivery plan distinct
CI tests and packages application code. A registry holds the resulting image. A configuration repository describes which image and settings an environment should use. Argo CD compares that desired configuration with Kubernetes resources and applies approved changes through the target API.
Argo CD does not need to build the image to reconcile its Deployment. A new image in a registry also does not, by itself, change the declared image digest in Git. Make the promotion step explicit: a reviewed configuration change selects the artifact to deliver.
For our menu fixture, the executable remains the digest selected in episode three. A small change to the fixed response can illustrate configuration promotion. For a real application release, promote the image produced and verified by CI. Keep artifact provenance and environment approval associated, but separate enough to understand what changed.
Build, desired state, reconciliation and service acceptance are distinct stages. The diagram does not imply that a green sync runs a business test.
The OpenGitOps principles describe declarative, versioned, pulled and continuously reconciled desired state. A Git history records configuration changes. It is complemented by approvals, controller events and request evidence when we need to explain what actually ran at a particular time.
Bootstrap one controlled destination
The platform team installs and operates Argo CD using a reviewed, pinned distribution and supported configuration. Start with its installation guide, then configure trusted TLS, enterprise sign-in, scoped repository credentials and the destination’s Kubernetes permissions.
A quick Helm command with two replica values is not a complete high-availability design. Placement, component architecture, backing services, capacity, upgrades and recovery need their own review. The Argo CD security overview is part of that work, not a later polish step.
Our first destination is coffee-demo on the same authorized workload cluster as Argo CD. The platform already created the namespace and its policies. The application repository contains only its deployable application objects. Cluster creation on the Supervisor stays a separate platform-owned workflow.
coffee-deploy/
environments/
dev/
workload.yaml
production/
workload.yaml
This small structure is a teaching choice. Production promotion must define who can edit each environment and how changes are reviewed. A directory name alone is not an access-control mechanism; protected branches and approval rules must implement the intended ownership.
Give the project narrow permissions
An AppProject restricts allowed sources, destinations and resource kinds within Argo CD. In this example, it allows one repository and one namespace, with the three kinds needed by the fixture:
apiVersion: argoproj.io/v1alpha1
kind: AppProject
metadata:
name: coffee
namespace: argocd
spec:
sourceRepos:
- https://git.example.net/apps/coffee-deploy.git
destinations:
- server: https://kubernetes.default.svc
namespace: coffee-demo
clusterResourceWhitelist: []
namespaceResourceWhitelist:
- { group: apps, kind: Deployment }
- { group: '', kind: ConfigMap }
- { group: '', kind: Service }
The repository URL is illustrative. Replace it with the exact approved repository, and provision its credentials outside this file. The project is created by the platform team. Application authors do not receive permission to edit it or resources in argocd. Review the actual Argo CD RBAC, project settings and destination credentials together. Projects.
This example does not permit Namespace, RoleBinding, NetworkPolicy or cluster-scoped resources. Adding an application PDB would require deliberately allowing that kind too. Broaden the contract for a demonstrated need rather than copying wildcards from a general-purpose bootstrap example.
An AppProject does not create a strong isolation boundary on its own. Kubernetes RBAC, admission/security policy, network controls and the controller’s permissions still determine what can happen on the target. Decide whether a shared controller and cluster satisfy the tenant trust model.
Read the first diff before automating sync
The platform creates the Application after replacing the fictional source URL:
apiVersion: argoproj.io/v1alpha1
kind: Application
metadata:
name: coffee-dev
namespace: argocd
spec:
project: coffee
source:
repoURL: https://git.example.net/apps/coffee-deploy.git
targetRevision: main
path: environments/dev
destination:
server: https://kubernetes.default.svc
namespace: coffee-demo
This example follows a protected main branch and configures no automated sync. The selected commit is visible in Argo CD. Review the diff, confirm source, path, destination and affected objects, then perform the authorized synchronization. Do not leave the same objects under a second competing delivery controller.
The workload.yaml from episode three is a possible starting point. Argo CD must have read access to the source and the required target permissions. Its custom resources require the installed Argo CD CRDs. A schema-valid Application with an unreachable repository still cannot deliver anything.
For a first change, edit the fixture’s response from v1 to v2 in the ConfigMap and change a version annotation on the Deployment’s Pod template. That template change triggers replacement Pods which read the new configuration. The fixture mounts the configuration with subPath and NGINX does not automatically reload it; simply editing a ConfigMap must not be presented as proof that running processes adopted its content.
# Deployment excerpt; preserve the other fields from workload.yaml.
spec:
template:
metadata:
annotations:
demo-release: "v2"
During rollout, v1 and v2 may coexist. Repeated responses can differ until convergence. After completion, verify the intended response, Pod template revision and actual image. The example changes configuration, so its image digest is intentionally unchanged.
Add automation with an explicit stop and recovery plan
Automated synchronization, self-healing and pruning are separate choices. Pruning can remove resources absent from desired state. Self-healing can undo an emergency manual change. Decide who may enable them, how a planned pause works and how changes resume afterward. See automated sync policy.
For a configuration regression, a reviewed Git revert can restore the desired application definition. It does not reverse a destructive database migration or reconstruct deleted data. If automatic sync is enabled, a manual attempt to keep a different state may be reconciled away; coordinate recovery with the source of truth and the documented automation controls.
An App-of-Apps root that can create Applications is powerful administrative infrastructure. Keep it platform-owned and review its repository accordingly. For multiple clusters, an ApplicationSet can generate Applications from selected cluster information. Generation is not proof that all resulting Applications have synchronized or that a rollout across the fleet was safe. ApplicationSet cluster generator.
Sync waves order resources within the relevant synchronization operation. They do not automatically create a global dependency scheduler across independent Applications. Operators, CRDs and external prerequisites need explicit readiness and rollout design. Sync phases and waves.
The indicator is green and the menu response has the expected release. TOP also verifies the separate order identifier through the API. At the coffee corner, he has the user colleague read the confirmation. A green sync alone proves neither the write nor coffee delivery.
Secrets need both delivery and consumption
Keep real credentials out of the application repository. External Secrets Operator is one possible mechanism for reconciling authorized external secret values into Kubernetes Secrets. Its identity, store permissions, resource scope and rotation policy need a platform design. ESO overview.
A refreshed Kubernetes Secret does not automatically mean every running process reloaded it. Environment variables are read at process creation; file-based credentials depend on how they are mounted and consumed. Plan the application’s reload or restart behavior and test the intended rotation end to end. The static fixture has no credential, so its success proves none of those mechanisms.
Before declaring a release complete, keep four related observations: reviewed Git commit, selected artifact/configuration, actual reconciled resources and useful service response. For production, enforce SSO/authorization; the local lab does not implement SSO. Add intended identity and data checks for the real application. Investigate OutOfSync or degraded resources, but also a green state with the wrong business result.
That completes this five-part VKS journey. For a deeper delivery story, continue with TOP Platform’s build-to-release series. Here we keep TOP Dev’s question: what does our software need from its environment, and which observation tells us it received it?
This revision draws on the linked Broadcom, Kubernetes, Argo CD, OpenGitOps, NGINX and Velero/ESO documentation. Thanks to their authors and maintainers for making the mechanisms and their limits inspectable; the TOP scenes and the menu exercise are original teaching material.
The service is restored and the replenishment request has an identifier TOP can read back. A few days later, the beans arrive. TOP brings his empty mug over; his colleague points to the machine’s button. “Deployment is automatic. Your espresso still needs one click.” A few minutes later, TOP finally savours his well-earned coffee.

Get the next one by email
New articles and series, sent when they are published. No other mail.



