Chart Values Reference
This page provides example values.yaml configurations for Helm and Argo CD deployments of OLIVE 1.3. Each configuration corresponds to a deployment model described in Development and Production Environment Deployment.
For either Argo CD or Helm installation, select the appropriate configuration profile below based on your deployment model and environment type.
- The common assets tenant no longer exists. OLIVE 1.3 has no
common-assetsdeployment and nocommonLibraryNamevalue to point at one. Reusable scenario and microfrontend assets are distributed with the normal import/export mechanism instead. If you are coming from 1.2, see Migration 1.2.0 to 1.3.0. - Security controls are now explicit deployment values.
networkPolicy,serviceMesh,serviceAccounts,keycloakIpBlocks,vault,imageVerificationandimageRegistryare set in the samevalues.yamlas everything else. See Security Configuration for what each one does and when to turn it on. - The namespace and the tenant name are now independent. In 1.2,
global.namespacehad to equalglobal.tenant. In 1.3 they are separate, so namespaces can carry a prefix of your choosing. - A shared runtime pool replaces the old "stateless layer" naming. The
multi-shareddeployment provides the services that all tenants use; tenants reference it throughglobal.express.sharedNamespace.
Configuration Properties
Identity and topology
| Property | Description |
|---|---|
global.tenant | The name of the tenant, and the identifier the tenant is known by across the platform. It is used to build the tenant's DNS name (each tenant gets its own subdomain), it appears in log records as the tenant identifier, and it names the tenant's accounts in Vault and in Temporal. Lowercase alphanumeric characters, - (dash) and . (dot) only. Must start and end with [a-z0-9], be ≤ 20 characters, contain no uppercase letters and no underscores, and be unique across the cluster. Because it is visible in host names and logs and is bound into Vault and Temporal accounts, treat it as permanent: pick a short, recognisable name and do not rename it afterwards. |
global.namespace | The Kubernetes namespace for this deployment. New in 1.3: the namespace no longer has to match global.tenant. In 1.2 the two had to be the same value; in 1.3 they are independent, so you can prefix namespaces to give your Kubernetes cluster more structure — for example oli-<tenant> — while the tenant keeps its own short name. |
global.clusterName | The purpose of the cluster (for example develop, operate). Used to build host names. |
global.infraName | Abbreviation of the cluster/environment (for example dev, stage, prod). Required for Argo CD deployments. |
global.domain | The domain configured in the cluster and reverse proxies for ingress. |
global.resolveTLS | Whether TLS has to be resolved — for example when HTTPS is used on the ingress. |
global.urlScheme | Scheme used when the platform builds its own URLs. Defaults to https. |
global.deploymentMode | Deployment architecture: single-no-auth (development, one user, no login), multi-shared (the shared runtime pool, installed once per cluster), or multi-tenant (one deployment per tenant). |
global.createNamespace | Whether the chart creates the namespace itself. Set true, even if the namespace already exists, the lables of the namespace will be updated. |
global.ingress.className | The IngressClass every OLIVE Ingress references, and the switch that decides whether the Traefik Middleware resources are rendered. traefik is the supported controller from 1.2.0 onwards. It is the IngressClass name of RKE2's bundled Traefik and of the upstream Traefik Helm chart installed as release traefik, so the value stays traefik on EKS and other clusters as well. See Cluster-specific settings. |
global.express.sharedNamespace | The namespace that hosts the shared Express runtime. In multi-tenant this points at the multi-shared deployment; in single-no-auth it points at the deployment's own namespace. It is also the value of the olive/platform pod label that network policies use to allow Express services to reach each other. |
global.temporal.enabled | Whether the Temporal workflow engine runs in this deployment. Enabled in the shared pool; disabled in tenant deployments, which get their own workers. |
global.clusterIssuer | The cert-manager ClusterIssuer the platform's Certificate objects reference — for example letsencrypt-dns or an internal ACME issuer. Required whenever services.infra.certificate is true, which is every profile below. A Certificate with no issuer is created and never becomes ready, and the symptom is a hostname that serves the ingress controller's default certificate. The cluster operator provides the issuer name. |
global.volumeLabels | Labels added to the couchdb and seaweedfs PersistentVolumeClaims, so a backup tool can select them without maintaining a list of claim names. Defaults to olive-boc/backup: velero. Decide this before the first install: the labels live in the StatefulSet's immutable volumeClaimTemplates, so changing them afterwards is the same disruptive procedure as resizing a volume. |
global.customCa.enabled / name / bundle | Trust an internal certificate authority inside the pods, paired with the services.infra.custom-ca service flag. See Custom CA Certificates. |
services | Nested boolean map that activates or deactivates individual services for this deployment. |
Authentication
| Property | Description |
|---|---|
global.keycloakBaseURL | Origin of the Keycloak instance, for example https://auth.develop.olive-team.com. |
global.jwtIssuer.rootPath | Trusted issuer base path. Always ends in /realms/. Services compare issuers exactly — no wildcards and no suffix matching. |
global.jwtIssuer.additionalRootPaths | Additional trusted issuer base paths. Each entry widens trust by exactly one issuer and must be https. |
global.keycloakVaultMount | The Vault KV mount the Keycloak admin credential is read from. Defaults to secret, which is the mount OLIVE expects; set it only if your Vault uses a differently named KV v2 mount. |
global.keycloakVaultPath | Path of the Keycloak admin credential inside Vault, relative to the KV mount (for example keycloak/oli-keycloak-credentials). The chart refuses to render if the mount or a data/ segment is repeated here. |
Security controls
These are described in full under Security Configuration. The table is the short reference.
| Property | Description |
|---|---|
global.networkPolicy.enabled | Master switch for default-deny NetworkPolicies across every chart in the namespace. Requires a CNI that enforces NetworkPolicy. |
global.networkPolicy.ingressController | Namespace and pod labels of the ingress controller, so the default-deny baseline still admits ingress traffic. |
global.serviceMesh.mode | none, sidecar or ambient. Must match what is actually installed on the cluster — the two meshed modes need opposite NetworkPolicy changes. ambient is the tested mode; sidecar is not thoroughly tested, see Service Mesh and mTLS. |
global.serviceMesh.vaultMeshed | Whether the Vault namespace is itself enrolled in the mesh. Leave false until it is. |
global.networkPolicy.allowKeycloak | Whether the egress rule for the Keycloak JWKS fetch is rendered at all. Set false only when Keycloak is reachable through a route the default-deny baseline already permits — otherwise every service fails JWT validation. |
global.networkPolicy.keycloakPorts | The ports that rule opens. Defaults to 443; change it only for a Keycloak that is not on HTTPS/443. |
global.keycloakIpBlocks | The IP ranges the network policies allow every OLIVE service to reach on port 443, for the Keycloak JWKS fetch. Leave it empty unless you are pinning a real address — empty renders any public host on 443, with in-cluster and private ranges subtracted. Pinning it to Keycloak's own address narrows that to one host; read the section below first. |
global.nonRoutableCidrs | Ranges carved out of every 0.0.0.0/0 egress rule, so in-cluster traffic cannot bypass the pod selectors. |
global.serviceAccounts.mode | split gives the tenant four purpose-scoped ServiceAccounts, each bound to exactly one Vault role. legacy is the single shared ServiceAccount of earlier releases. |
global.vault.namespace / serviceName / port / scheme | Where the platform finds HashiCorp Vault. Also drives the network policy that allows Vault access. |
tenant-setup.imageVerification.mode | disabled, audit or enforce — the container image signature verification posture declared for this namespace. Read by the example Kyverno policies (see the note below). |
tenant-setup.imageRegistry.mode | disabled, audit or enforce — the image registry allow-list posture declared for this namespace. Read by the example Kyverno policies (see the note below). |
tenant-setup.podPrivileges.mode | disabled, audit or enforce — the pod-privilege posture declared for this namespace: privileged containers, explicit privilege escalation, hostPath volumes and host namespace sharing. Read by the example Kyverno policies, like the two above. Not the same thing as podSecurity — see the next row. |
tenant-setup.podSecurity | Kubernetes Pod Security Admission labels on the namespace (enforce, audit, warn, version). A different mechanism in a different place from podPrivileges: PSA is enforced by the API server and needs nothing installed, while podPrivileges enrols the namespace in a Kyverno policy and does nothing unless Kyverno is running. PSA is the floor; podPrivileges adds a cluster-wide report that names the container, the field and the Deployment. The two are one word apart and are regularly confused. |
global.appArmor | Default true. Whether the pods request an AppArmor profile. Set false on hosts that cannot enforce AppArmor — SELinux hosts (RHEL, Rocky, OpenShift) and some managed clusters — where the kubelet otherwise rejects every pod with "Cannot enforce AppArmor". Keep it identical across every chart in the cluster. |
global.seccomp | Default true. Whether the pods request the RuntimeDefault seccomp profile. Leave on; turn off only if the container runtime rejects it. |
couchdb.credentials.rotationId / seaweedfs.credentials.rotationId | Change the string to request a new generated credential for that storage service. |
tenant-setup.imageVerification.mode and tenant-setup.imageRegistry.mode do not perform any checking. All they do is label the namespace. The checking is done by Kyverno policies, which OLIVE ships as examples in the kyverno-infra chart and which read that label to decide how to treat the namespace.
So the control only exists when both halves are in place:
- Kyverno is installed and the policies are deployed to the cluster, and
- the namespace declares a mode here.
If the policies are not deployed, setting mode: enforce enforces nothing. Nothing fails, nothing is logged, and the values file reads as though the tenant were protected — which is the dangerous part. The same is true if the policy selects a different label than the one the namespace carries.
Verify rather than assume, per namespace:
kubectl get polr -n <namespace>
An empty policy report in a namespace that should be in audit means the policies are not evaluating it.
Whether the policies exist at all is a cluster-scoped read, which a Platform Administrator usually cannot run — ask your cluster operator to confirm the policies are present and active (kubectl get validatingpolicy,imagevalidatingpolicy, and their status, since a policy whose CEL failed to compile is listed and completely inert). See Security Configuration → Admission Policies and, for the cluster side, Cluster Operator → Admission Control and Image Integrity.
Cluster-specific settings: ingress controller and storage
Three values depend on the Kubernetes distribution rather than on OLIVE. Their defaults describe an RKE2 cluster with its bundled Traefik and Longhorn. On any other cluster — Amazon EKS, AKS, or RKE2 with the bundled ingress disabled — review all three before the first sync.
| Property | Default | Change it when |
|---|---|---|
global.ingress.className | traefik | Your Traefik IngressClass is not named traefik (kubectl get ingressclass). |
global.networkPolicy.ingressController | namespace: kube-system, podLabels: {app.kubernetes.io/name: rke2-traefik} | Traefik is not RKE2's bundled Traefik. Only read when global.networkPolicy.enabled is true. |
global.storageClassName | empty — each chart's own value, which is default | You want a specific StorageClass instead of the cluster default, or you upgrade an existing RKE2/Longhorn installation (see below). |
Set them once, in the values snippet shared by the shared runtime pool and all tenants.
Ingress controller location (Traefik pod labels)
With network policies enabled, every namespace runs default-deny, and the only source allowed to reach the published services is the ingress controller. The policies identify it by namespace and pod labels, rendered as a single peer — "these pods in that namespace", not "every pod in that namespace":
global:
networkPolicy:
enabled: true
ingressController:
namespace: kube-system # where Traefik runs
podLabels:
app.kubernetes.io/name: rke2-traefik # labels of the Traefik pods
The default above is RKE2's bundled Traefik, a DaemonSet in kube-system whose pods carry the rke2- prefixed label. A separately installed Traefik — the usual case on EKS — runs in its own namespace and carries the upstream label without the prefix. For the upstream Traefik Helm chart installed as release traefik in namespace traefik:
global:
networkPolicy:
enabled: true
ingressController:
namespace: traefik
podLabels:
app.kubernetes.io/name: traefik
Any label set that uniquely selects the Traefik pods works; use more than one label if several releases share a namespace. A single chart can override the global value under its own networkPolicy.ingressController, but there is rarely a reason to.
It is zero peers: the moment default-deny lands, every route into the namespace closes and the ingress answers with timeouts. Check the selector against the real pods before enabling network policies:
kubectl -n <traefik-namespace> get pods -l app.kubernetes.io/name=<label-value> --show-labels
On EKS, NetworkPolicy is only enforced when the VPC CNI add-on runs with enableNetworkPolicy=true (or Calico/Cilium is installed). Otherwise the policies are accepted and do nothing.
The rest of the Traefik integration needs no change on a non-RKE2 cluster: OLIVE uses the entry points web and websecure and both the kubernetesIngress and kubernetesCRD providers, which are the upstream chart's defaults. What the controller must provide is listed in Cluster Operator → Ingress Requirements.
Storage class and how default is handled
Every volume OLIVE creates — CouchDB and SeaweedFS StatefulSets, and the CloudNativePG clusters of the workflow engine and Keycloak — takes its StorageClass from one rule, first hit wins:
| Order | Source | Result |
|---|---|---|
| 1 | global.localDev: true | local-path (desktop clusters) |
| 2 | global.storageClassName | That class, for every volume of the deployment |
| 3 | The chart's own value (storageClassName, or cnpg.cluster.storage.storageClass for PostgreSQL) | That class, for this chart only |
| 4 | Nothing set | default |
default means the cluster's default StorageClass. Kubernetes itself gives the string default no special meaning — it would look for a class literally called default, which EKS and RKE2 do not have, and the claim would stay Pending. The charts therefore never send it: for default they leave storageClassName off the claim entirely, which is how Kubernetes selects the class marked (default). An empty string is treated the same way.
global:
storageClassName: default # cluster default StorageClass (field left off the claim)
# storageClassName: gp3 # EKS with the EBS CSI driver, if no class is marked default
# storageClassName: longhorn # RKE2 with Longhorn
Check which class is the default with kubectl get storageclass — it is marked (default). If none is, either mark one or name a class explicitly.
Earlier chart versions rendered storageClassName: longhorn explicitly. A StatefulSet's volume claim template cannot be changed after creation, so if the new charts render anything else, the StatefulSet update is rejected and the sync fails. On every existing cluster that was installed with Longhorn, set:
global:
storageClassName: longhorn
This keeps the rendered claims identical. The new resolution applies from the chart versions built on utilities 1.10.0 (couchdb 1.8.0, seaweedfs 1.2.0, workflow-engine-postgres 1.2.0, keycloak-infra 1.4.0) onwards, which is every chart in 1.3.
What keycloakIpBlocks is for
Every OLIVE service validates the JWTs it receives, and to do that it fetches Keycloak's public signing keys (JWKS) from the issuer's /protocol/openid-connect/certs endpoint. Keycloak is reached over its public HTTPS address, not over in-cluster DNS, so that fetch leaves the cluster.
With network policies on, the namespace is default-deny, so that outbound call needs a rule. Kubernetes NetworkPolicy cannot match host names — only IP ranges — so the rule has to be an ipBlock. global.keycloakIpBlocks is what goes into it, restricted to keycloakPorts (443 by default) so it is not general internet access.
global:
keycloakIpBlocks: [] # the shipped default — see the warning below
The default is an empty list, and empty does not mean "no rule". It means the charts render 0.0.0.0/0 with the in-cluster, private, node and link-local ranges subtracted — global.nonRoutableCidrs and its companions. So the effective default is any public host on 443, and nothing inside the cluster.
That is wider than ideal, but it is the only default that is correct everywhere, and the failure mode of a wrong value is severe. Narrowing it is a security improvement you opt into once you know your Keycloak's address and can keep it correct.
0.0.0.0/0 written out means the same as leaving the list emptyBoth render 0.0.0.0/0 with the except: carve-out, so if the answer to "which address is Keycloak on?" is "I do not know", writing it out explicitly is a correct and honest way to say so. An empty list is the shorter way to say the same thing.
A wide-but-not-/0 range — a /8, a /16 — is rendered bare, without the carve-out, because Kubernetes requires every except entry to fall inside the block's own cidr. If you pin something that broad, check by hand that it does not contain your cluster's pod or Service CIDR.
To narrow it, resolve the host global.keycloakBaseURL points at and pin every address it returns:
dig +short auth.develop.olive-team.com
global:
keycloakIpBlocks:
- '203.0.113.42/32'
- '203.0.113.43/32' # pin every address the name resolves to
This is almost always a cloud load-balancer address, and those change — when the load balancer is recreated, when the ingress is reconfigured, when the provider reassigns it, or when the name starts resolving to a different set of addresses.
When it changes and the pinned value does not, every service loses JWKS at the same moment. The symptom is not a clear error:
- The JWKS fetch is dropped by the CNI, silently — default-deny drops rather than refuses.
- The HTTP client hangs until its timeout (about five seconds), then fails.
- JWT validation fails, so the service answers
401. - The Traefik
redirectErrorsmiddleware turns that401into a redirect to/oauth2/start. - The user is bounced back into a login they have already completed — an infinite login loop.
It presents as a Keycloak or authentication fault. Nothing in it mentions a network policy, and Keycloak itself is healthy throughout.
So pin this value only if you will monitor the address, and re-check it after any change to the load balancer, the ingress or the Keycloak host name — in the same change. If you cannot guarantee a stable address, leaving the default is the safer choice: egress to public HTTPS stays wider than you would like, and the platform keeps working.
Which value to use
The question that decides this is not "what is my Keycloak's IP" — it is whether the address the pods resolve is public or private. The empty default allows public addresses and blocks private ones, because global.nonRoutableCidrs carves out 10.0.0.0/8, 172.16.0.0/12 and 192.168.0.0/16.
| Where Keycloak sits | What the pods resolve | Set keycloakIpBlocks to |
|---|---|---|
Behind an internet-facing load balancer — the usual OLIVE arrangement, where authenticate.<cluster>.<domain> goes through the same ingress | A public address | Leave it empty. Nothing to do, and nothing to know |
| Behind an internet-facing NLB with Elastic IPs | A public address, and a stable one | Optionally the Elastic IPs, /32 each — the only case where pinning an LB address is safe |
| Behind an internal load balancer, or a private hosted zone resolving to one | A private address | The VPC CIDR, e.g. 10.0.0.0/16. The empty default blocks this |
| In the same cluster, reached over a private address | A private address | The VPC or subnet CIDR, as above |
If the Keycloak hostname resolves to a private address — an internal ALB or NLB, a private hosted zone, or anything inside the VPC — the empty default drops the JWKS fetch, because private ranges are subtracted from it. You get the five-step failure above and an infinite login loop, on a cluster where nothing is misconfigured except this.
Check before you deploy, from inside the cluster rather than from your laptop — split-horizon DNS can give different answers:
kubectl run dnscheck --rm -it --image=alpine/curl --restart=Never -- \
nslookup auth.develop.olive-team.com
A 10., 172.16–172.31. or 192.168. answer means you must set keycloakIpBlocks explicitly.
Pin the VPC CIDR, not the load balancer. This is the answer to "I have no idea what the IP is", and it is better than 0.0.0.0/0 on every axis:
global:
keycloakIpBlocks:
- '10.0.0.0/16' # your VPC CIDR - stable for the life of the VPC
A VPC CIDR is fixed when the VPC is created and does not change, so it has none of the staleness risk that pinning a load-balancer address has. It is also far narrower than the whole internet. If you want narrower still, use the CIDRs of the subnets the load balancer sits in.
For an ALB, AWS allocates the addresses dynamically and documents that you should not depend on them — they change, and so does how many there are. Pinning them is the staleness trap above with a short fuse. For an NLB, internet-facing, you can assign Elastic IPs and those are static, which makes pinning safe. Private NLB addresses are stable in normal operation but are not contractually fixed.
If you do not know which you have, pin the VPC CIDR for an internal LB and leave the list empty for an internet-facing one. Neither requires knowing an IP.
- Turn the rule off if the issuer host actually resolves in-cluster in your deployment:
networkPolicy.allowKeycloak: false. Only correct when JWKS is genuinely not fetched over the internet. - Keep the list empty and rely on the carve-out. With an empty list,
global.nonRoutableCidrsand the cluster, node and link-local ranges are subtracted from this rule, so it cannot reach in-cluster, private or cloud-metadata addresses — it is public HTTPS only, not "anything". That property is lost the moment you write a CIDR out by hand, so pin a real address or pin nothing.
A per-chart networkPolicy.keycloakIpBlocks overrides the global value for one chart. There is rarely a reason to use it: every authenticated service needs the same Keycloak.
Volume sizes
CouchDB and SeaweedFS take their volume size from values that are read when the claim is created:
couchdb:
couchdbPvcSize: '1Gi'
seaweedfs:
seaweed:
pvcSize: 20Gi
Set these to the size the tenant is expected to need before the first deployment. That is the only point at which the size is purely a values decision.
The size lives in the StatefulSet's volume claim template, which cannot be changed after creation, so raising couchdbPvcSize or seaweed.pvcSize on a running deployment leaves the volume untouched and the deployment out of sync. Growing it needs a step on the cluster itself, with permissions a platform administrator does not have. Request it from whoever operates the cluster — the procedure is in Cluster Operator → Sizing the volumes.
A volume can only be made larger; Kubernetes rejects a smaller size. SeaweedFS is also capped at 32 GB of usable object storage regardless of the volume size — see Cluster Operator → Sizing the volumes.
The storage requirements themselves — access modes, sizes, reclaim policy — are in Cluster Operator → Storage Requirements.
Development Environment Values
This configuration deploys a single-user development environment using the single-no-auth deployment mode: no login, no tenant separation, everything in one namespace. Refer to Development Environment Deployment for architectural details.
Two things that belong in some development deployments are deliberately not in it, because they are regularly copied into environments they do not belong in:
- publishing internal services on the ingress — see Publishing services on the API;
- switching off TLS verification — see Internal TLS certificates in a lab.
Add either only when you have read the section it points to.
Note that serviceMesh.mode is none here. Development deployments normally do not carry the mesh; network policies are still enabled, because running with them on in development is the cheapest way to find a missing egress rule before production does.
global:
tenant: "single"
namespace: "oli-single"
clusterName: "develop"
infraName: "dev"
domain: "olive-team.com"
resolveTLS: true
deploymentMode: "single-no-auth"
createNamespace: true
urlScheme: "https"
express:
sharedNamespace: "oli-single"
releaseVersion: "0.0.1"
jwtIssuer:
rootPath: https://auth.develop.olive-team.com/realms/
keycloakVaultPath: keycloak/oli-keycloak-credentials
keycloakBaseURL: 'https://auth.develop.olive-team.com'
ingress:
className: traefik
storageClassName: longhorn # RKE2 + Longhorn; 'default' = cluster default
fastapi:
sharedNamespace: "single"
releaseVersion: "0.0.1"
serviceAccounts:
mode: split
networkPolicy:
enabled: true
ingressController: # RKE2 bundled Traefik - change on EKS etc.
namespace: kube-system
podLabels:
app.kubernetes.io/name: rke2-traefik
keycloakIpBlocks: [] # empty = any public host on 443; pin to narrow
serviceMesh:
mode: none
vaultMeshed: false
vault:
namespace: 'oli-hashicorp-vault'
serviceName: 'oli-vault'
port: 8200
scheme: 'http'
editor:
express:
env:
SINGLE_NO_AUTH_DEPLOY_USER: "test"
SINGLE_NO_AUTH_DEPLOY_PW: "test"
data-orchestrator:
express:
replicas: 2
couchdb:
couchdbPvcSize: '1Gi'
tenant-setup:
imageVerification:
mode: audit
imageRegistry:
mode: audit
services:
infra:
certificate: true
auth-proxy: false
keycloak-setup: false
tenant-setup: true
vault-secrets-setup: true
workflow-engine-postgres: true
custom-ca: false
stateful:
couchdb: true
seaweedfs: true
core:
cloud-function-registry: true
instantiator: true
data-orchestrator: true
file-storage-service: true
import-export: true
ui-component-registry: true
microfrontend-interpreter: true
editor: true
repository: true
scheduler: true
session-memory: true
template-data-retriever: true
extensions:
agent-caller: true
mcp-server-caller: true
prompt-caller: true
temporal-caller: true
develop-support: true
qa:
ping: true
simple-adder: true
Notes on the development profile
- No service is published on the ingress. That is the default in every deployment mode. If you call a service directly from outside the cluster — running API tests, for example — see Publishing services on the API.
SINGLE_NO_AUTH_DEPLOY_USER/..._PW. The Editor's fixed development identity. These are not credentials in the Keycloak sense and must never be reused in an authenticated deployment.- TLS verification stays on. If a lab uses its own internal CA, trust that CA explicitly rather than disabling verification — see Custom CA Certificates and Internal TLS certificates in a lab.
Production Environment Values
A production installation consists of two deployment types:
- Shared runtime pool (
multi-shared) — the services all tenants use, deployed once per cluster. - Per-tenant deployments (
multi-tenant) — one deployment per tenant, holding that tenant's storage, workers, ingress and identity integration.
There is no third "common assets" deployment in 1.3.
Shared Runtime Pool Values (multi-shared)
Deploy this once per cluster. It provides the stateless services for every tenant, plus the Temporal workflow engine. It carries no CouchDB or SeaweedFS of its own — those are per-tenant — and it runs no auth proxy or Keycloak setup, because those belong to the tenant deployments that terminate user sessions. It also runs no scheduler cron job: the scheduler service is enabled here, but the trigger that drives it belongs to each tenant — see Cron Scheduler Configuration.
Refer to Shared Runtime Pool for architectural details.
global:
tenant: "runtime-multi"
namespace: "oli-runtime-multi"
clusterName: "develop"
infraName: "dev"
domain: "olive-team.com"
resolveTLS: true
deploymentMode: "multi-shared"
createNamespace: true
temporal:
enabled: true
express:
sharedNamespace: "oli-runtime-multi"
serviceAccounts:
mode: split
networkPolicy:
enabled: true
ingressController: # RKE2 bundled Traefik - change on EKS etc.
namespace: kube-system
podLabels:
app.kubernetes.io/name: rke2-traefik
keycloakIpBlocks: [] # empty = any public host on 443; pin to narrow
ingress:
className: traefik
storageClassName: longhorn # RKE2 + Longhorn; 'default' = cluster default
jwtIssuer:
rootPath: https://auth.develop.olive-team.com/realms/
keycloakVaultPath: keycloak/oli-keycloak-credentials
keycloakBaseURL: 'https://auth.develop.olive-team.com'
serviceMesh:
mode: ambient
vaultMeshed: true
vault:
namespace: 'oli-hashicorp-vault'
serviceName: 'oli-vault'
port: 8200
scheme: 'http'
tenant-setup:
imageVerification:
mode: audit
imageRegistry:
mode: audit
services:
infra:
certificate: true
auth-proxy: false
keycloak-setup: false
tenant-setup: true
vault-secrets-setup: true
workflow-engine-postgres: true
custom-ca: false
stateful:
couchdb: false
seaweedfs: false
core:
cloud-function-registry: true
instantiator: true
data-orchestrator: true
file-storage-service: true
import-export: true
ui-component-registry: true
microfrontend-interpreter: true
editor: true
repository: true
scheduler: true
session-memory: true
template-data-retriever: true
extensions:
agent-caller: true
temporal-caller: true
mcp-server-caller: true
prompt-caller: true
parse-openapi: true
qa:
ping: true
simple-adder: true
Tenant Values (multi-tenant)
Deploy this once per tenant. Note the differences from the shared pool:
temporal.enabled: false— the workflow engine runs in the shared pool; this deployment only gets the tenant's own workers.express.sharedNamespacepoints at the shared pool's namespace, not at this tenant's namespace.auth-proxyandkeycloak-setuparetrue— this is where user sessions are terminated and the tenant's realm is onboarded.- The stateful services (
couchdb,seaweedfs) aretrue— each tenant has its own storage. couchdb.credentials.rotationIdandseaweedfs.credentials.rotationIdcontrol storage credential rotation for this tenant.- The scheduler cron trigger is configured here, not in the shared pool —
scheduler.schedule-trigger-cron-job, once per tenant. See Cron Scheduler Configuration.
Refer to Tenant Namespaces for architectural details.
global:
tenant: "multi"
namespace: "oli-multi"
clusterName: "develop"
infraName: "dev"
domain: "olive-team.com"
resolveTLS: true
deploymentMode: "multi-tenant"
createNamespace: true
temporal:
enabled: false
ingress:
className: traefik
storageClassName: longhorn # RKE2 + Longhorn; 'default' = cluster default
express:
sharedNamespace: "oli-runtime-multi"
jwtIssuer:
rootPath: https://auth.develop.olive-team.com/realms/
keycloakVaultPath: keycloak/oli-keycloak-credentials
keycloakBaseURL: 'https://auth.develop.olive-team.com'
serviceAccounts:
mode: split
networkPolicy:
enabled: true
ingressController: # RKE2 bundled Traefik - change on EKS etc.
namespace: kube-system
podLabels:
app.kubernetes.io/name: rke2-traefik
keycloakIpBlocks: [] # empty = any public host on 443; pin to narrow
serviceMesh:
mode: ambient
vaultMeshed: true
vault:
namespace: 'oli-hashicorp-vault'
serviceName: 'oli-vault'
port: 8200
scheme: 'http'
tenant-setup:
imageVerification:
mode: audit
imageRegistry:
mode: audit
couchdb:
credentials:
rotationId: '2026.09.04'
seaweedfs:
credentials:
rotationId: '2026.09.04'
services:
infra:
certificate: true
auth-proxy: true
keycloak-setup: true
tenant-setup: true
vault-secrets-setup: true
workflow-engine-postgres: true
custom-ca: false
stateful:
couchdb: true
seaweedfs: true
core:
cloud-function-registry: true
instantiator: true
data-orchestrator: true
file-storage-service: true
import-export: true
ui-component-registry: true
microfrontend-interpreter: true
editor: true
repository: true
scheduler: true
session-memory: true
template-data-retriever: true
extensions:
temporal-caller: true
agent-caller: true
mcp-server-caller: true
prompt-caller: true
parse-openapi: true
qa:
ping: true
simple-adder: true
networkPolicy (including ingressController), serviceMesh, nonRoutableCidrs, keycloakIpBlocks and vault must be identical in the shared pool and in every tenant that talks to it. The same file is the natural place for ingress.className and storageClassName, which describe the cluster rather than the tenant. A tenant whose serviceMesh.mode disagrees with the cluster gets policies that allow the wrong ports, and the symptom is a timeout rather than an error. Keep them in one shared values snippet that all deployments include.
Production Deployment Requirements
A complete production deployment needs at least:
- One shared runtime pool (
multi-shared), deployed once per cluster. - One or more tenants (
multi-tenant), one deployment each.
Plus the cluster-level dependencies described in Dependencies: HashiCorp Vault, Keycloak, cert-manager, the CNPG operator, Argo CD, and — if you enable them — the Istio ambient mesh and Kyverno.
Service-Specific Configurations
Service-specific settings can be configured via the service's configuration in values.yaml. For services with Express-based engines, you can define environment variables at the service level.
To define environment variables for an Express-based service:
- Specify the name of the service.
- Under the service, add the
expresssection. - Within
express, use theenvblock to define environment variables as key–value pairs.
Example: Data Orchestrator Configuration
data-orchestrator:
express:
replicas: 2
env:
SOME_SETTING: "value"
Publishing a Service on the API (mapToAPI)
Internal services are not published on the ingress unless the deployment explicitly asks for it. This is the default in every deployment mode, including single-no-auth. To publish one:
scheduler:
express:
mapToAPI: true
Publish only the services that genuinely need to be reachable from outside the cluster. Every additional mapped service is an additional externally reachable interface. In authenticated deployments the auth proxy still guards it, but the interface exists.
The API test profile
OLIVE's own API test suite calls a number of services directly, so the development deployment it runs against publishes all of them. This is what that overlay looks like — included as a worked example of the pattern, not as a recommended baseline:
cloud-function-registry:
express:
mapToAPI: true
instantiator:
express:
mapToAPI: true
scheduler:
express:
mapToAPI: true
import-export:
express:
mapToAPI: true
temporal-caller:
express:
mapToAPI: true
agent-caller:
express:
mapToAPI: true
prompt-caller:
express:
mapToAPI: true
template-data-retriever:
express:
mapToAPI: true
parse-openapi:
express:
mapToAPI: true
Nine services published is nine externally reachable interfaces, and in a single-no-auth deployment there is no authentication in front of any of them. Take only the entries for the services your own tests actually call, keep the overlay in a separate values file from the base profile so it cannot travel by accident, and never apply it to a deployment that is reachable from an untrusted network.
Internal TLS certificates in a lab
A lab that issues its own TLS certificates, under its own internal domain names, presents certificates the containers do not trust. Datapoints calling those hosts then fail certificate verification.
The correct fix is to trust the CA, by adding it to the deployment — see Custom CA Certificates. That makes exactly the certificates your organisation issued acceptable and leaves verification working for everything else. It is the only acceptable answer outside a lab.
There is a blunt alternative, which is why it is documented here rather than left to be rediscovered:
data-orchestrator:
express:
env:
NODE_TLS_REJECT_UNAUTHORIZED: "0"
NODE_TLS_REJECT_UNAUTHORIZED=0 does not make one internal CA trusted — it makes every certificate acceptable to every HTTPS request that Node.js process makes, including one presented by a host you did not intend to talk to. Any guarantee that a datapoint reached the system it named is gone, and nothing in the logs records that.
It is defensible only in a controlled laboratory environment with no customer data, as a short-term measure while the CA is being added. It must never reach a deployment that handles customer data, and it must not be carried across from a lab values file into a production one.
Request-Level Diagnostics in Authenticated Deployments
Request-level diagnostics are enabled by default in development deployments that use single-no-auth.
In deployments with authentication (multi-shared and multi-tenant), request-level diagnostics are disabled by default. To enable them, configure the shared service deployment values.yaml where data-orchestrator runs:
data-orchestrator:
express:
env:
GLOBAL_DIAGNOSTICS_ENABLED: "true"
Apply this setting only for troubleshooting windows and disable it again afterward.
Do not enable global diagnostics in production environments that process customer data unless explicitly approved by your security and compliance stakeholders.
Next Steps
You're now ready to deploy the OLIVE Platform. Choose one of the three supported installation methods:
- Install with Argo CD (Recommended) – Our validated, production-ready approach using GitOps and ApplicationSets for automated, repeatable deployments.
- Install with Helm CLI – Manual installation using Helm commands (useful for development or simpler environments).
- Install via Rancher – Register the chart in Rancher and install from the UI.
For additional customization topics, see:
- Security Configuration - Network policies, service mesh, admission policies, identity and secrets
- Custom CA Certificates - Configure internal Certificate Authority
- Resource Scaling - Adjust replicas and resource limits
- Cron Scheduler Configuration - Configure scheduled tasks