Skip to content
Edouard Topin's Blog
VKS: deploy, troubleshoot and operate an application with TOP Dev / Series 05/05

GitOps on VKS with Argo CD: Verify the Release and Service Result

Follow a reviewed Git change through Argo CD reconciliation, then verify the VKS service response and application boundaries.

Edouard Topin
8 min read
TOP annotates his notebook during a standing change review with his colleague beside a small shared screen.

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.

CI tests and builds an image into a registry; a reviewed Git change selects its digest and settings; Argo CD reconciles the workload API; a separate check verifies the menu request. Evidence includes commit, digest and result.

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.

Application team reviews its config; platform team owns Argo Application and AppProject plus destination credentials; Kubernetes applies RBAC and admission, and the namespace has platform policies. Separate external-secret authority remains outside Git.

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.

Demo configuration change: ConfigMap v1 to v2, Pod template annotation, rollout, then v2 response. Updating the subPath-mounted ConfigMap does not reload NGINX.

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.

Standing at the coffee corner, TOP shows the order confirmation to the colleague who reported the problem.

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.

TOP finally enjoys his well-earned coffee, eyes closed and both hands around a steaming mug; his colleague shares the break beside the restocked coffee machine.

Get the next one by email

New articles and series, sent when they are published. No other mail.

One click to unsubscribe, any time.

Back to blog
Share

Related articles

  1. 7 min read

    Cilium Default-Deny and DNS: TOP Troubleshoots the Festival Running Order

    Trace DNS and HTTP failures in a disposable Cilium lab as TOP helps a festival stage manager restore the running-order app.

  2. 11 min read

    From factory to shop: GitOps and rolling updates with TOP

    Magical Unicorn is packaged but missing from the menu. Follow TOP through Git, Argo CD and VKS to replace a release while the shop serves.

  3. 12 min read

    What's new in VCF 9.1.1: the Day-2 release

    VCF 9.1.1 adds multi-tenant model sharing, an AI operations assistant, VKS observability, native GitOps, EVPN improvements, and a safer upgrade path.

Follow along

New articles, thoughts, and updates.