---
title: How do you deploy an AI governance platform on a private Kubernetes cluster?
url: https://opencontroller.lyzr.com/blog/deploy-ai-governance-on-private-kubernetes-with-gitops
published: 2026-11-12
updated: 2026-11-12
author: Lyzr
---

# How do you deploy an AI governance platform on a private Kubernetes cluster?

**Mirror the vendor's container images and charts into your internal registry, pin them by digest, keep the configuration in Git, and let a GitOps controller such as Argo CD sync it into the cluster. Give the platform workload identity, not static keys, and use scoped cross-account roles for discovery.** That keeps the deployment reproducible, reviewable and free of outbound pulls from the public internet.

Security teams ask this in almost every evaluation: "Can it be deployed through our internal registry and Argo CD in a private cluster?" The answer should be yes for any platform that offers customer-controlled deployment. Below is the sequence that works, and what to check before the pilot. For the broader buying criteria, see the [AI agent governance platform evaluation checklist](/blog/ai-agent-governance-platform-evaluation-checklist).

## What do you need before you start?

| Prerequisite | Why it matters | Typical owner |
| --- | --- | --- |
| Internal OCI registry (ECR, ACR, Artifact Registry, Harbor, Artifactory) | Cluster nodes pull only from here | Platform team |
| Git repository for environment config | Single source of truth for values and overlays | Platform team |
| GitOps controller (Argo CD or Flux) | Applies and reconciles the desired state | Platform team |
| Workload identity setup | Pods get cloud credentials without long-lived keys | Cloud security |
| Database and object storage | State, logs and evidence retention | Data platform |
| Private DNS and TLS certificates | Internal endpoints for UI, API and gateway | Network team |
| Egress rules to model providers | Only needed if the gateway calls external LLM APIs | Network team |

## What are the deployment steps?

1. **Mirror images.** Copy every image the vendor lists into your registry with a tool such as `skopeo copy` or `crane copy`. Record the digest (`sha256:...`) for each one.
2. **Mirror the chart or manifests.** If the vendor ships a Helm chart, `helm pull` it and push it to your registry as an OCI artifact. If it ships Kustomize bases, commit them to your repo.
3. **Scan and sign.** Run your container scanner on the mirrored images and sign them if your admission policy requires signatures.
4. **Override registries and pin digests.** In your values file, point every image at the internal registry and reference digests, not mutable tags. Add `imagePullSecrets` if your registry needs them.
5. **Set workload identity.** Bind the platform's service accounts to cloud roles: EKS Pod Identity or IAM Roles for Service Accounts on AWS, Microsoft Entra Workload ID on AKS, Workload Identity Federation for GKE on Google Cloud.
6. **Create cross-account discovery roles.** For each AWS account (or Azure subscription, or Google Cloud project) to be discovered, create a read-only role the platform can assume. On AWS, require an external ID in the trust policy.
7. **Define the Argo CD Application.** Point it at the repo path and target namespace. Use `syncPolicy.automated` with `prune` and `selfHeal` once you trust the config; start with manual sync during the pilot.
8. **Order the sync.** Use the `argocd.argoproj.io/sync-wave` annotation so secrets, config and database migrations apply before the application pods.
9. **Wire SSO.** Register the platform as an OIDC or SAML application in your identity provider and disable local logins. See [whether governance tools should allow local logins](/blog/sso-only-access-for-ai-governance-tools).
10. **Verify and promote.** Check health, run a discovery scan against one account, then promote the same commit to the next environment.

## What usually goes wrong?

- **Hidden image references.** Init containers, sidecars and hooks reference images that are not in the main list. Render the chart (`helm template`) and grep for `image:` before mirroring.
- **Tag drift.** A tag re-pushed upstream silently changes what runs. Digests prevent this.
- **Over-broad discovery roles.** Discovery needs list and describe permissions, not write. See [what permissions AI agent discovery needs](/blog/ai-agent-discovery-permissions-aws-azure-google-cloud).
- **Gateway egress forgotten.** If agents route model traffic through a self-hosted gateway, it needs egress to each provider or to internal model endpoints. The [self-hosted LLM gateway network checklist](/blog/self-hosted-llm-gateway-network-checklist) covers ports and allow-lists.
- **Self-heal fighting operators.** If another controller mutates resources, Argo CD will keep reverting them. Use `ignoreDifferences` for fields you expect to change.

## How should you plan upgrades?

Treat a vendor release like any other change. Mirror the new images, update digests in a pull request, let reviewers see the diff, and sync to a non-production environment first. Keep the previous commit tagged so rollback is a Git revert, not a rebuild.

## How Opencontroller does this

Opencontroller runs on Lyzr SaaS or on customer-controlled infrastructure, and Lyzr engineers embed with your team for integration. It follows open standards (OpenAI-compatible endpoints, MCP, OpenTelemetry, OIDC/SAML/SCIM, REST and webhooks) and supports OIDC SSO. Licensing is an annual licence per deployment, not per seat and not usage-based. See [what Opencontroller is](/blog/what-is-opencontroller) or [book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Can an AI governance platform run fully air-gapped?**
The control plane can, if images and charts are mirrored. Features that call external model providers need egress to those providers, or internal models instead.

**Argo CD or Flux?**
Either works. Both reconcile from Git. Use whichever your platform team already operates.

**Do I need a separate cluster?**
Not necessarily. A dedicated namespace with network policies and its own service accounts is often enough. Some teams choose a separate cluster for blast-radius reasons.

## Key facts

To deploy an AI governance platform on a private Kubernetes cluster: mirror images and charts into an internal OCI registry, pin by digest, keep values in Git, sync with Argo CD or Flux, use workload identity (EKS Pod Identity or IRSA, Microsoft Entra Workload ID, GKE Workload Identity Federation) instead of static keys, and create read-only cross-account roles with external IDs for discovery. Opencontroller by Lyzr runs on Lyzr SaaS or customer-controlled infrastructure, with Lyzr engineers embedding for integration, and is licensed per deployment per year, not per seat. Pricing starts from $250K per deployment per year.

## Related

- [What network setup does a self-hosted LLM gateway need?](https://opencontroller.lyzr.com/blog/self-hosted-llm-gateway-network-checklist.md)
- [Do you need a separate AI governance deployment per region?](https://opencontroller.lyzr.com/blog/one-or-many-ai-governance-deployments-across-regions.md)
- [What security questions should you ask an AI agent governance vendor about itself?](https://opencontroller.lyzr.com/blog/security-questions-to-ask-an-ai-governance-vendor.md)
- [More on Buying and comparison](https://opencontroller.lyzr.com/blog/cluster/buying-and-comparison)
