Skip to main content

Kubernetes Resources

What OLIVE creates in a cluster, and which API groups have to be present before it will sync.

This page exists for four questions an operator has to answer before the first deployment:

  1. Which CRDs must already be installed — a missing one fails as no matches for kind, which reads like a chart bug rather than a missing prerequisite.
  2. Which cluster-scoped objects OLIVE creates — the collision list, and what an OLIVE install could disturb in a cluster that already runs something.
  3. What belongs in an Argo CD AppProject allow-list, since a Kind the project does not permit fails the sync outright.
  4. What OLIVE does not use, so a restricted cluster is not opened up further than it needs to be.
This is a reference, not the source of truth

Chart contents change between releases. The authoritative answer for a given deployment is the rendered output — see Deriving the list yourself at the bottom of this page. Treat the tables here as the shape to expect.


Core Kubernetes resources​

All namespaced, all standard. Nothing here is unusual for a Helm-deployed application.

API groupKindsWhere they come from
v1ConfigMap, Secret, Service, ServiceAccount, LimitRangeThroughout. ServiceAccount in particular: four per tenant in split mode
v1PersistentVolumeClaimCreated by StatefulSet volumeClaimTemplates, not rendered directly — one per storage replica, never reclaimed by an uninstall
apps/v1Deployment, StatefulSetExpress services, auth proxy and Redis are Deployments; CouchDB, SeaweedFS, Vault and Keycloak are StatefulSets
batch/v1Job, CronJobBootstrap and setup Jobs; the scheduler trigger, Vault token renewal, session purge and mesh reconcile CronJobs
networking.k8s.io/v1Ingress, NetworkPolicyOne Ingress per published service; NetworkPolicies from nearly every chart
rbac.authorization.k8s.io/v1Role, RoleBindingThe tenant administrator's namespace Role
NetworkPolicy means the standard one

OLIVE renders networking.k8s.io/v1 NetworkPolicy, not Calico's crd.projectcalico.org/v1 NetworkPolicy. The two share a Kind name and are different resources. Calico enforces the standard one, so nothing needs to change — but an AppProject allow-list or an admission policy written against the Calico group will not match what OLIVE creates.


Cluster-scoped resources​

This is the part that a kubectl api-resources --namespaced=true listing will not show you, and the part that matters most when OLIVE is installed beside something else.

KindCreated byNotes
Namespacetenant-setup, vault-infra, keycloak-infra, kyverno-infraRendered by the charts rather than left to Argo CD's CreateNamespace=true, because that creates them bare — unlabelled, and therefore not enrolled in the service mesh. All carry Prune=false
ClusterRoleservice-mesh-setup; Kyverno and VSO subchartsvault-infra references a ClusterRole it does not create
ClusterRoleBindingvault-infra, service-mesh-setupNames are derived from the Helm release name, not fixed — see the collision note below
CustomResourceDefinitionKyverno and Vault Secrets Operator subchartsOnly when you let those subcharts install them
ValidatingWebhookConfigurationKyverno subchartCluster-wide. Deleting the Kyverno namespace while this lingers leaves a webhook with no backend
MutatingWebhookConfigurationVault agent injectorRequired, and off by default in vault-infra — it has to be switched on. The CouchDB and SeaweedFS pods read their Vault credential from a file the injected agent writes, so without the webhook they start and hang. A single cluster-wide webhook: run exactly one, because two both fire on the same pod and a pod injected by the wrong one gets an agent pointing at the wrong Vault
ImageValidatingPolicy, ValidatingPolicykyverno-infraCluster-scoped. The Namespaced* variants of these Kinds exist in Kyverno but OLIVE does not use them
Coexistence depends on these names

Running OLIVE's Vault beside an existing one works because the cluster-scoped names are derived rather than fixed — the auth-delegator binding follows vault.fullnameOverride, and the cross-namespace binding follows the namespace. A second install that leaves those at defaults collides with the first.

See Infrastructure Charts → HashiCorp Vault.

Cluster-scoped resources OLIVE references but does not create​

These must exist, and providing them is the cluster operator's job. OLIVE names them in values and fails if they are absent or misnamed.

KindReferenced asNotes
ClusterIssuer (cert-manager.io/v1)global.clusterIssuerIssues the tenant and Keycloak certificates. OLIVE creates the Certificate; the issuer is yours
IngressClass (networking.k8s.io/v1)global.ingress.classNametraefik from 1.2.0 onwards — the name used by RKE2's bundled Traefik and by the upstream chart installed as release traefik
StorageClass (storage.k8s.io/v1)global.storageClassName, else the chart's own valuedefault (or empty) leaves storageClassName off the claim, so the cluster's default class is used — see Storage Requirements

Custom resources OLIVE requires​

These CRDs must exist before OLIVE syncs. Each row is a hard prerequisite for the component in the right-hand column.

API groupKinds OLIVE usesProvided byRequired for
secrets.hashicorp.com/v1beta1VaultConnection, VaultAuth, VaultStaticSecretVault Secrets OperatorEverything. Every tenant materialises secrets through these
postgresql.cnpg.io/v1Cluster, Pooler, ScheduledBackupCloudNativePG operatorThe workflow engine's database, and Keycloak's
cert-manager.io/v1Certificatecert-managerTLS for tenant and Keycloak hosts
traefik.io/v1alpha1MiddlewareTraefikRequest buffering, headers and rate limiting on published routes
security.istio.io/v1PeerAuthentication, AuthorizationPolicyIstioOptional — only with serviceMesh.mode ambient or sidecar
policies.kyverno.io/v1ImageValidatingPolicy, ValidatingPolicyKyvernoOptional — only with admission policies enabled
wgpolicyk8s.io/v1alpha2PolicyReportKyvernoOptional, read-only — produced by Kyverno, consumed by you
helm.cattle.io/v1HelmChartConfigRKE2Optional — only to enrol RKE2's bundled Traefik in the mesh (traefikEnrollment.method: helmChartConfig). Does not exist on EKS/AKS; use method: external there
Kyverno: policies.kyverno.io, not kyverno.io

OLIVE uses the policies.kyverno.io/v1 types. It does not use the legacy kyverno.io ClusterPolicy. That type is deprecated but still installed — the chart ships both CRD sets — so the failure mode is not a missing CRD but a cluster that carries only the legacy set: an older Kyverno, or one installed from a chart predating policies.kyverno.io, accepts nothing OLIVE applies.

Verifying before you deploy​

kubectl get crd | grep -E 'secrets.hashicorp.com|cnpg.io|cert-manager.io|traefik.io'

# optional components
kubectl get crd | grep -E 'istio.io|kyverno.io|wgpolicyk8s.io'

What OLIVE does not use​

A typical cluster carries far more CRDs than OLIVE touches. Listing what is not used is as useful as listing what is — it keeps a restricted AppProject narrow and stops an operator provisioning components on OLIVE's behalf that it never asked for.

Present in many clustersOLIVE's position
networking.istio.io — VirtualService, DestinationRule, Gateway, EnvoyFilter, SidecarNot used. OLIVE configures the mesh through security.istio.io only. No L7 routing, no waypoints
telemetry.istio.io, extensions.istio.ioNot used
crd.projectcalico.orgNot used. OLIVE writes standard NetworkPolicy; Calico enforces it
kyverno.io/v1, kyverno.io/v2 — Policy, ClusterPolicy, CleanupPolicyNot used — see the warning above
traefik.io — IngressRoute, TLSOption, ServersTransport, TraefikServiceNot used. OLIVE uses standard Ingress plus Middleware
hub.traefik.io (Traefik Hub)Not used
catalog.cattle.io (Rancher)Not used
monitoring.coreos.com, monitoring.grafana.comNot used. OLIVE exposes metrics endpoints when enabled, but creates no ServiceMonitor, PodMonitor or PodLogs — those are the operator's. The one exception is optional: the bundled Temporal subchart can create ServiceMonitor objects if asked to. See Monitoring and Observability
snapshot.storage.k8s.io, storage-provider CRDsNot used directly. Storage classes and snapshots are the cluster operator's
autoscaling/v2 — HorizontalPodAutoscalerNot created. Scaling is by explicit replica counts in values
policy/v1 — PodDisruptionBudgetNot created

What a tenant namespace actually looks like​

Worth knowing before sizing anything or reading a namespace listing for the first time: in a multi-tenant deployment, a tenant namespace contains far fewer workloads than it does routes.

A representative tenant namespace holds roughly 25 Ingress objects and 25 Service objects, but only about three Deployment objects. Most Express services run once, in the shared runtime pool, and the tenant namespace reaches them through ExternalName Services that resolve across namespaces. What genuinely runs per tenant is the auth proxy, its Redis, the tenant's own storage StatefulSets, its Temporal workers, and its CronJobs.

The consequence for an operator: pod count does not scale with tenant count the way the route count does, which is the point of the shared pool. It also means an empty-looking kubectl get deployments in a tenant namespace is correct, not a failed deployment.

Argo CD AppProject​

In a restricted Argo CD setup, a Kind the project does not permit fails the sync with ... is not permitted in project. An empty clusterResourceWhitelist permits no cluster-scoped resources, which is the usual reason a first OLIVE sync stops at the Namespace.

apiVersion: argoproj.io/v1alpha1
kind: AppProject
metadata:
name: olive
namespace: argocd
spec:
destinations:
- server: https://kubernetes.default.svc
namespace: 'oli-*'
# keycloak-infra and vault-secrets-setup run Jobs in the VAULT namespace,
# not in their own - the project must reach it.
- server: https://kubernetes.default.svc
namespace: 'oli-hashicorp-vault'
# service-mesh-setup writes mesh-wide policies into the Istio root namespace.
- server: https://kubernetes.default.svc
namespace: 'istio-system'
# On RKE2, the HelmChartConfig that enrols the bundled Traefik in the mesh -
# and the one that loads the redirectErrors plugin - must live in kube-system.
- server: https://kubernetes.default.svc
namespace: 'kube-system'

clusterResourceWhitelist:
- group: ''
kind: Namespace
- group: 'rbac.authorization.k8s.io'
kind: ClusterRole
- group: 'rbac.authorization.k8s.io'
kind: ClusterRoleBinding
# Only if a subchart in THIS project installs CRDs or webhooks. The
# infrastructure charts normally run in their own project - Traefik in
# particular installs the traefik.io CRDs and an IngressClass, see
# /operator/infrastructure-charts/traefik
- group: 'apiextensions.k8s.io'
kind: CustomResourceDefinition
- group: 'admissionregistration.k8s.io'
kind: ValidatingWebhookConfiguration
# Only with the admission policies enabled
- group: 'policies.kyverno.io'
kind: ImageValidatingPolicy
- group: 'policies.kyverno.io'
kind: ValidatingPolicy

namespaceResourceWhitelist:
- group: ''
kind: ConfigMap
- group: ''
kind: Secret
- group: ''
kind: Service
- group: ''
kind: ServiceAccount
- group: ''
kind: PersistentVolumeClaim
- group: ''
kind: LimitRange
- group: 'apps'
kind: Deployment
- group: 'apps'
kind: StatefulSet
- group: 'batch'
kind: Job
- group: 'batch'
kind: CronJob
- group: 'networking.k8s.io'
kind: Ingress
- group: 'networking.k8s.io'
kind: NetworkPolicy
- group: 'rbac.authorization.k8s.io'
kind: Role
- group: 'rbac.authorization.k8s.io'
kind: RoleBinding
- group: 'secrets.hashicorp.com'
kind: VaultConnection
- group: 'secrets.hashicorp.com'
kind: VaultAuth
- group: 'secrets.hashicorp.com'
kind: VaultStaticSecret
- group: 'postgresql.cnpg.io'
kind: Cluster
- group: 'postgresql.cnpg.io'
kind: Pooler
- group: 'postgresql.cnpg.io'
kind: ScheduledBackup
- group: 'cert-manager.io'
kind: Certificate
- group: 'traefik.io'
kind: Middleware
# Only with a service mesh
- group: 'security.istio.io'
kind: PeerAuthentication
- group: 'security.istio.io'
kind: AuthorizationPolicy
# Only to enrol RKE2's bundled Traefik in the mesh
- group: 'helm.cattle.io'
kind: HelmChartConfig

Trim the optional entries to match what you actually deploy. Adding a Kind you do not use costs nothing functionally, but the point of the allow-list is that it is narrow.

Kyverno also needs two Argo CD adaptations

Its CRDs exceed the client-side apply annotation limit, and its report CRs flood the resource tree. See Admission Control and Image Integrity.


Deriving the list yourself​

The reliable answer for a given deployment is the rendered chart. This never goes stale:

# Every Kind the chart renders
helm template olive oci://registry.gitlab.com/olive6224315/helm-charts/charts/olive-platform \
--version <CHART_VERSION> -f values.yaml \
| grep -h '^kind:' | sort -u

# Grouped with their API versions - what an AppProject needs
helm template olive oci://registry.gitlab.com/olive6224315/helm-charts/charts/olive-platform \
--version <CHART_VERSION> -f values.yaml \
| grep -hE '^(apiVersion|kind):' | paste - - | sort -u

Values change what is rendered — disabling the mesh removes the Istio resources, disabling a service removes its Deployment, Ingress and NetworkPolicy — so render with the values you will actually deploy.

Inspecting a running namespace​

kubectl get all does not mean all

It covers Pods, Services, Deployments, ReplicaSets, StatefulSets, DaemonSets, Jobs and CronJobs — and nothing else. It silently omits Ingress, NetworkPolicy, RBAC, ConfigMap, Secret, PersistentVolumeClaim and every custom resource, which is most of what OLIVE creates.

To see an OLIVE namespace properly, name the kinds:

kubectl get all,ingress,networkpolicy,role,rolebinding,serviceaccount,\
configmap,secret,pvc,limitrange,certificate,middleware,\
vaultstaticsecret,vaultauth,vaultconnection,peerauthentication \
-n <namespace> -o custom-columns=KIND:.kind,NAME:.metadata.name | sort -u

Or let the API server enumerate every namespaced kind for you:

kubectl api-resources --verbs=list --namespaced=true -o name \
| xargs -n1 -I{} kubectl get {} -n <namespace> --ignore-not-found \
-o custom-columns=KIND:.kind,NAME:.metadata.name --no-headers 2>/dev/null \
| sort -u

The second is slower but complete, and it is the honest way to answer "what is actually in this namespace".

Expect a listing to contain more than the tables above: the objects Kubernetes creates in every namespace (kube-root-ca.crt, the default ServiceAccount), the ones its controllers derive from what OLIVE renders (Pods, ReplicaSets, PersistentVolumeClaims, EndpointSlices, the TLS Secret cert-manager writes from each Certificate), and — in a mesh-enrolled namespace — Istio's istio-ca-root-cert and istio-ca-crl.