Skip to main content

Development and Production Environment Deployment

This page describes the typical cluster-level profiles for OLIVE: how development and production clusters differ in their architecture, resource allocation, security posture and feature availability. It complements Deployment Options and Tenant Isolation, which focuses on where and how you deploy, and how tenants are isolated.

For product-level differences between development and production modes (authentication, multi-tenancy), see Introduction & Deployment Approach.

Changed in 1.3

The common assets tenant has been removed. A production installation now consists of one shared runtime pool plus one deployment per tenant — nothing else. Reusable scenario and microfrontend assets are distributed through import/export rather than through a dedicated tenant. See Migration 1.2.0 to 1.3.0.

Development Environment Deployment​

Overview​

The development environment uses a single-tenant deployment model with a simplified architecture designed for rapid development and testing. It prioritizes ease of use over multi-tenancy and authentication complexity.

Key Characteristics​

  • Single Tenant: All compute and storage resources are deployed within a single namespace and dedicated entirely to that deployment.
  • No Authentication: There is no authentication or authorization requirement. Keycloak is not needed for login; the Editor uses a fixed development identity.
  • Simplified Access: Individual services can be published on the ingress with mapToAPI: true and then called directly, which is how the API tests reach them. Nothing is published by default — see Publishing a Service on the API.
  • Deployment Mode: Uses the single-no-auth deployment mode.

Use Cases​

  • Connectivity developers creating and testing connectivity applications
  • Platform evaluation and sandbox environments
  • Local development and integration testing
  • Proof-of-concept deployments

Resource Allocation​

All compute resources (stateless services) and storage resources (stateful services) run in one namespace, for example oli-single.

Security posture​

A development deployment deliberately relaxes two controls and keeps the rest:

ControlDevelopmentWhy
Authentication / authorizationOffsingle-no-auth has one user and no tenant boundary to enforce
Service mesh mTLSnoneA single-namespace deployment has no cross-tenant traffic to protect, and the mesh is usually not installed on a development cluster
Network policiesOnCheap here, and finding a missing egress rule in development is much cheaper than finding it in production
Image verification / registry allow-listauditReports what would be blocked without blocking it
Workload hardening (seccomp, AppArmor, dropped capabilities, read-only root filesystem, non-root)Always onShips with the charts. Only global.appArmor and global.seccomp can be turned off, and only because some hosts cannot enforce them — see Workload Hardening
Egress guard (internal, Kubernetes and metadata addresses blocked)Always onNot switchable — it is implemented in the services
warning

single-no-auth has no login and no per-user authorization. It must never be reachable from an untrusted network and must never hold customer data.

For example configurations, see Chart Values Reference — Development Environment Values.


Production Environment Deployment​

Overview​

The production environment uses a multi-tenant deployment model with authentication, authorization and resource isolation. It is designed for scalability, security and efficient resource sharing across multiple organizations.

Key Characteristics​

  • Multi-Tenant: Multiple independent tenants share the platform while maintaining strict data isolation.
  • Authentication & Authorization: Keycloak provides identity management and role-based access control; every service validates the JWT independently rather than trusting the edge.
  • Shared Runtime Pool: Stateless compute is shared in one namespace for efficiency.
  • Dedicated Stateful Resources: Each tenant has its own storage, database, search index and workflow workers.
  • Deployment Modes: Uses multi-shared (shared runtime pool) and multi-tenant (per-tenant deployments).

Architecture​

Production deployments consist of two components working together:

1. Shared Runtime Pool (multi-shared deployment)​

  • Purpose: Hosts the shared compute resources that serve all tenants.
  • Location: One common namespace, for example oli-runtime-multi
  • Responsibility: Provides the core platform services accessed by all tenants, plus the Temporal workflow engine (temporal.enabled: true)
  • Deployment: Deployed once per cluster
  • Holds no tenant storage: couchdb and seaweedfs are off here
  • Terminates no user session: auth-proxy and keycloak-setup are off here; those belong to the tenant deployments
  • Tenant separation: Enforced logically. Services in the shared pool are multi-tenant aware and separate tenants by the JWT claim and the Vault role, not by namespace

2. Tenant Namespaces (multi-tenant deployment)​

  • Purpose: Isolates each tenant's resources and data.
  • Location: Dedicated namespace per tenant, for example oli-multi
  • Storage: Each tenant has its own CouchDB and SeaweedFS file storage, each with its own PersistentVolumeClaim
  • Workflow Engine: Each tenant has dedicated Temporal workers (temporal.enabled: false, workers only)
  • Cron Jobs: Each tenant has its own cron jobs; they are tenant-specific and not deployed in the shared namespace
  • Ingress Configuration: Each tenant has its own ingress configuration, allowing independent host routing and TLS certificate management
  • Identity: auth-proxy and keycloak-setup run here; each tenant has its own Keycloak realm
  • Network: With networkPolicy.enabled: true, a service in one tenant's namespace cannot reach a service in another tenant's namespace. This is enforced by the network layer, not by application logic
  • Deployment: One deployment per tenant

How tenant isolation is enforced​

Tenant isolation is not a single control. Four independent mechanisms enforce the same boundary, so that a defect in one does not become a breach:

  1. The JWT claim check in every service — each service validates signature, issuer, audience and expiry itself, and derives the tenant from the token rather than from a header or a URL.
  2. The per-tenant Vault role — a workload can only obtain the Vault policy it was designed for, because each Vault role names exactly one ServiceAccount.
  3. The per-tenant namespace and storage — separate PVCs, separate database instances, separate object storage.
  4. NetworkPolicy — default-deny, with no route between tenant namespaces.

Items 1–3 are always on. Item 4 is a deployment value; see Security Configuration — Network Policies.

Security posture​

ControlRecommended production settingWhere
global.networkPolicy.enabledtrueRequires a CNI that enforces NetworkPolicy
global.serviceMesh.modeambientRequires an Istio ambient installation on the cluster
global.serviceMesh.vaultMeshedtrue once the Vault namespace is enrolled
global.serviceAccounts.modesplitFour purpose-scoped ServiceAccounts per tenant
global.keycloakIpBlocksEmpty for a public Keycloak; the VPC CIDR if it sits behind an internal load balancerEmpty allows any public host on 443 with private ranges carved out — which also means it blocks a private Keycloak. See Which value to use
tenant-setup.imageRegistry.modeaudit, then enforceRequires Kyverno. No network call — the recommended steady state
tenant-setup.podPrivileges.modeaudit, then enforceRequires Kyverno. Complying needs no rebuild
tenant-setup.imageVerification.modeauditRequires Kyverno. audit is a defensible permanent position: enforce needs failurePolicy: Fail, which makes pod creation depend on Fulcio and Rekor being reachable. See the recommended posture
Keycloak MFAEnforced for administrative rolesRealm configuration, not a chart value

See Security Configuration for what each of these does and how to roll it out.

Resource Efficiency​

  • Compute Savings: Stateless services are shared, reducing per-tenant compute overhead
  • Storage Isolation: Each tenant's data remains isolated in dedicated storage
  • Workflow Isolation: Each tenant has dedicated workflow workers
  • Cost Model: Additional tenants cost significantly fewer resources than a single development deployment

Use Cases​

  • Production deployments for multiple organizations
  • Environments where authentication and authorization are required
  • Multi-tenant SaaS platforms
  • Staging environments that mirror production architecture
  • Connectivity developers evaluating applications in an authenticated, authorized environment

Typical Service Configuration​

Production environments typically include:

  • Stateful Services: CouchDB, SeaweedFS — per tenant
  • Core Services: Full set of OLIVE Platform services — in the shared pool and, where the tenant needs its own, in the tenant namespace
  • Authentication: Keycloak setup and auth-proxy — per tenant
  • Workflow Engine: Temporal and the workflow engine PostgreSQL — in the shared pool
  • Extensions: Optional services such as prompt-caller, agent-caller, mcp-server-caller, temporal-caller, parse-openapi

For detailed configurations, see:


Comparison Table​

AspectDevelopmentProduction
Deployment Modesingle-no-authmulti-shared + multi-tenant
Tenant ModelSingle, no tenant boundaryMultiple tenants
AuthenticationNoneKeycloak-based
AuthorizationNoneRole-based (user / editor / admin)
Compute ResourcesDedicated, one namespaceShared runtime pool
Storage ResourcesIn the same namespaceDedicated per tenant
Workflow IsolationSingle deploymentPer-tenant Temporal workers
Ingress ConfigurationSingle ingress; services published individuallyPer-tenant ingress, behind the auth proxy
Network PoliciesRecommended onExpected on
Service Mesh mTLSnoneambient
Use CaseDevelopment & testingProduction & multi-organization
ScalabilityLimitedHigh

Next Steps​

With your environment architecture decided, proceed to:

  1. Hardware and Environment Requirements – Size your infrastructure based on your deployment model.
  2. Dependencies – Understand and pre-install required infrastructure components (Vault, CNPG, Keycloak, Argo CD, and optionally Istio and Kyverno).
  3. Chart Values Reference – Review configuration examples for your specific deployment type before installation.
  4. Security Configuration – Decide which security controls to enable before you deploy.