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.
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: trueand 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-authdeployment 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:
| Control | Development | Why |
|---|---|---|
| Authentication / authorization | Off | single-no-auth has one user and no tenant boundary to enforce |
| Service mesh mTLS | none | A single-namespace deployment has no cross-tenant traffic to protect, and the mesh is usually not installed on a development cluster |
| Network policies | On | Cheap here, and finding a missing egress rule in development is much cheaper than finding it in production |
| Image verification / registry allow-list | audit | Reports what would be blocked without blocking it |
| Workload hardening (seccomp, AppArmor, dropped capabilities, read-only root filesystem, non-root) | Always on | Ships 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 on | Not switchable — it is implemented in the services |
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) andmulti-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:
couchdbandseaweedfsare off here - Terminates no user session:
auth-proxyandkeycloak-setupare 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-proxyandkeycloak-setuprun 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:
- 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.
- 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.
- The per-tenant namespace and storage — separate PVCs, separate database instances, separate object storage.
- 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
| Control | Recommended production setting | Where |
|---|---|---|
global.networkPolicy.enabled | true | Requires a CNI that enforces NetworkPolicy |
global.serviceMesh.mode | ambient | Requires an Istio ambient installation on the cluster |
global.serviceMesh.vaultMeshed | true once the Vault namespace is enrolled | |
global.serviceAccounts.mode | split | Four purpose-scoped ServiceAccounts per tenant |
global.keycloakIpBlocks | Empty for a public Keycloak; the VPC CIDR if it sits behind an internal load balancer | Empty 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.mode | audit, then enforce | Requires Kyverno. No network call — the recommended steady state |
tenant-setup.podPrivileges.mode | audit, then enforce | Requires Kyverno. Complying needs no rebuild |
tenant-setup.imageVerification.mode | audit | Requires 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 MFA | Enforced for administrative roles | Realm 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
| Aspect | Development | Production |
|---|---|---|
| Deployment Mode | single-no-auth | multi-shared + multi-tenant |
| Tenant Model | Single, no tenant boundary | Multiple tenants |
| Authentication | None | Keycloak-based |
| Authorization | None | Role-based (user / editor / admin) |
| Compute Resources | Dedicated, one namespace | Shared runtime pool |
| Storage Resources | In the same namespace | Dedicated per tenant |
| Workflow Isolation | Single deployment | Per-tenant Temporal workers |
| Ingress Configuration | Single ingress; services published individually | Per-tenant ingress, behind the auth proxy |
| Network Policies | Recommended on | Expected on |
| Service Mesh mTLS | none | ambient |
| Use Case | Development & testing | Production & multi-organization |
| Scalability | Limited | High |
Next Steps
With your environment architecture decided, proceed to:
- Hardware and Environment Requirements – Size your infrastructure based on your deployment model.
- Dependencies – Understand and pre-install required infrastructure components (Vault, CNPG, Keycloak, Argo CD, and optionally Istio and Kyverno).
- Chart Values Reference – Review configuration examples for your specific deployment type before installation.
- Security Configuration – Decide which security controls to enable before you deploy.