Hardware and Environment Requirements
| Requirement | Description |
|---|---|
| Supported Kubernetes distributions | RKE2 and Amazon EKS — both tested. Other CNCF-compliant clusters may work with extra validation |
| Kubernetes version | 1.31 or later |
| CPU architecture | amd64. The images are not built for arm64, so arm node pools — AWS Graviton, Ampere — cannot run the platform |
| Minimum resources (non-HA: one development deployment plus the four infrastructure charts) | 12 vCPU, 32 GB RAM, 500 GB disk. Derived in The minimum and Disk; Cluster shapes sizes a cluster that also carries production |
| Minimum nodes | One, as far as CPU and memory are concerned — but three where volumes are served by a replicating storage class at its default, because Longhorn places each replica on a different node. See Disk |
| Host confinement | AppArmor is recommended and enabled by default. Hosts that cannot enforce it — SELinux distributions such as RHEL, Rocky and OpenShift — reject the pods with Cannot enforce AppArmor, so set global.appArmor: false there. seccomp stays on either way. See Workload Hardening |
| Deployment target | A CNCF-compliant Kubernetes cluster, on cloud or on-premises |
The chart defaults describe an RKE2 cluster with its bundled Traefik and Longhorn. On EKS, three values need reviewing before the first sync — global.ingress.className, global.networkPolicy.ingressController and global.storageClassName — and NetworkPolicy is only enforced when the VPC CNI add-on runs with enableNetworkPolicy=true (or Calico or Cilium is installed). See Cluster-specific settings.
For high-availability production environments, plan additional nodes and storage redundancy beyond these minimums, and size for your expected workload and observability stack.
The platform runs on a multi-node cluster and the stateless services take replica counts, but this manual does not yet document what a tenant actually experiences when a node is drained or lost: which components have a replica elsewhere and which do not, how long a tenant is unavailable, and in what order things come back. OLIVE creates no PodDisruptionBudget and does not autoscale.
Until that is measured and written down, treat node maintenance as a planned window per tenant rather than as transparent failover, and verify recovery with the five-minute liveness check afterwards — see Verify the Deployment. It is listed under Known gaps.
There is also no sized reference architecture yet — no tested profile that says how many tenants or how much connectivity activity a given cluster carries. What follows says what the charts reserve, which is what sizes nodes; it does not say how much work a cluster of that size carries. Size from your own measurements, and see Platform Scaling for which level to change when something is short.
See also Dependencies and Chart Values when translating these requirements into concrete Helm settings.
Measured Resource Footprint
What the 1.3.0 charts declare, per deployment and per infrastructure chart, so you can add up your own combination. These are declared requests and limits, not observed consumption — measure real usage afterwards and adjust, with Monitor Resource Usage.
Requests and limits
| Column | What it is | What it means for the cluster |
|---|---|---|
| Requests | What the scheduler reserves on a node before the pod starts | Size against this. If the requests do not fit, pods stay Pending regardless of what the nodes are actually doing |
| Limits | The ceiling a container may reach | A combined worst case nothing reaches at once. Sizing against the sum of limits buys several times more cluster than OLIVE uses |
The two fail differently: exceeding a CPU limit throttles the container, exceeding a memory limit kills it (OOMKilled). Memory is the dimension to leave real headroom in.
Two things the totals below do not account for:
- Allocatable is less than capacity. The kubelet, the runtime and the OS reserve part of every node — roughly 0.75 of a core and 2.5 GiB, which the sizing further down assumes. Confirm yours with
kubectl describe node. - Your own add-ons are not counted. Argo CD, CloudNativePG, Istio's per-node ztunnel, metrics and log collection all request resources, and none of them appear below. The per-node ones are charged once per node, so a three-node cluster pays for them three times over — a real counterweight to adding nodes.
One thing the totals make look harder than it is: no single pod needs a large node. The largest request anywhere below is Keycloak's 1 core / 1Gi, and inside the OLIVE deployments nothing exceeds 350m / 576Mi, a tenant's SeaweedFS. The constraint is always the sum, never an individual pod.
Per deployment
| Deployment | CPU requests | CPU limits | Memory requests | Memory limits |
|---|---|---|---|---|
Development (single-no-auth) | 2.32 cores | 26.8 cores | 8.75 GiB | 39.44 GiB |
Production — shared runtime pool (multi-shared) | 2 cores | 24 cores | 7.625 GiB | 36 GiB |
Production — each tenant (multi-tenant) | 1.075 cores | 6.05 cores | ~1.7 GiB (1,696 MiB) | ~5.1 GiB (5,184 MiB) |
The shared pool is deployed once; the tenant row is paid again per tenant. That is the arithmetic behind additional tenants cost significantly fewer resources than a single development deployment — a tenant adds about a core and 1.7 GiB to a pool that is already running, where a development deployment carries the whole stateless set alone.
These are chart defaults, which size CouchDB and SeaweedFS for a tenant with little content. A tenant whose data stores or replica counts you raise costs more — see Stateful Services per Tenant.
They come from kubectl get pods, which lists Job and cron pods beside the long-running ones. A completed pod holds no reservation, so the continuous footprint is lower — most noticeably for a tenant, where 11 of the 16 pods present were Jobs or cron pods. Excluding those: development 2.05 cores / 8.375 GiB, shared pool 1.8 cores / 7.375 GiB, tenant 0.81 cores / 1.25 GiB.
Size against the totals in the table, which hold while a deployment is being installed or upgraded. Per infrastructure chart is on the other basis — steady state, with its Jobs counted separately — so the two tables are not comparable row for row.
Per infrastructure chart
Steady state only: the servers and controllers that stay running, with this section's Jobs counted separately rather than folded in as they are above.
| Chart | Running pods | CPU requests | CPU limits | Memory requests | Memory limits |
|---|---|---|---|---|---|
vault-infra | 3 × Vault server | 1.5 cores | 6 cores | 1.5 GiB | 6 GiB |
keycloak-infra | Keycloak + its PostgreSQL | 1.2 cores | 4 cores | 1.5 GiB | 4 GiB |
kyverno-infra | 2 × admission, plus background, cleanup and reports controllers | 0.5 cores | none set | 448 MiB | 1.125 GiB |
traefik-infra | 2 × Traefik | 0.2 cores | 2 cores | 256 MiB | 1 GiB |
| All four | 3.4 cores | 12 cores, plus Kyverno unbounded | 3.6875 GiB | 12.125 GiB |
None of the four scale with tenant count: Vault, Keycloak and Kyverno are cluster-wide — Keycloak serves one realm per tenant from the same instance — and Traefik owns a cluster-scoped IngressClass. Count Traefik's row again only if you run more than one installation.
Storage claims
Only four components claim a volume, at these chart defaults:
| Component | Volumes | Claimed |
|---|---|---|
| Development deployment | CouchDB 1Gi, SeaweedFS 20Gi, Temporal PostgreSQL 10Gi | 31 GiB |
| Shared runtime pool | Temporal PostgreSQL 10Gi | 10 GiB |
| Each tenant | CouchDB 1Gi, SeaweedFS 20Gi | 21 GiB |
vault-infra | 3 × 10Gi, one per Vault server | 30 GiB |
keycloak-infra | PostgreSQL 10Gi | 10 GiB |
kyverno-infra, traefik-infra | none | — |
What that costs in raw disk depends on the storage class, and so does the minimum node count — see Disk.
Jobs and CronJobs
The infrastructure charts also run short-lived Jobs — Vault's bootstrap and per-deployment setup, Keycloak's Vault seeding, Kyverno's resource migration — plus a CronJob per deployment that renews the Vault client token. Each is small, but they have to be schedulable when they run, which is usually mid-install or mid-upgrade. All of them overlapping come to under 0.5 cores and about 1 GiB.
Sizing a Cluster
The minimum: development plus infrastructure
The smallest useful installation is one development deployment and the four infrastructure charts:
| Component | CPU requests | Memory requests |
|---|---|---|
Development deployment (single-no-auth) | 2.32 cores | 8.75 GiB |
| All four infrastructure charts | 3.4 cores | 3.6875 GiB |
| The infrastructure charts' Jobs, overlapping | 0.285 cores | ~0.6 GiB |
| Total requests to place | ~6 cores | ~13 GiB |
The development deployment's own Jobs are already inside its row, so the third row adds only the infrastructure charts' — nothing is counted twice.
On a single node, 12 vCPU and 32 GB holds that at about 53% of allocatable CPU and 44% of memory — room for a rolling update and for your own add-ons. 8 vCPU fits the requests too, at roughly 83% of a single node's allocatable CPU, with very little left over. A single node assumes a storage class that does not replicate across nodes; see Disk.
Adding production and a tenant
One cluster carrying a development deployment, a production deployment with one tenant, and all four infrastructure charts:
| Component | Count | CPU requests | CPU limits | Memory requests | Memory limits |
|---|---|---|---|---|---|
Development deployment (single-no-auth) | 1 | 2.32 | 26.8 | 8.75 GiB | 39.44 GiB |
Shared runtime pool (multi-shared) | 1 | 2 | 24 | 7.625 GiB | 36 GiB |
Tenant (multi-tenant) | 1 | 1.075 | 6.05 | ~1.7 GiB | ~5.1 GiB |
vault-infra | 1 | 1.5 | 6 | 1.5 GiB | 6 GiB |
keycloak-infra | 1 | 1.2 | 4 | 1.5 GiB | 4 GiB |
kyverno-infra | 1 | 0.5 | none set | 448 MiB | 1.125 GiB |
traefik-infra | 1 | 0.2 | 2 | 256 MiB | 1 GiB |
| Total | 8.795 cores | 68.85 cores, plus Kyverno | 21.72 GiB | 92.63 GiB |
Memory is rounded for reading; the totals are the exact values summed, so they will not match the rounded rows to the last digit.
Plan around the requests: 8.8 cores and 21.7 GiB. The limits come to roughly 8× that on CPU and 4× on memory — that gap is what lets an individual service burst; it is not capacity to buy.
Development is the expensive half here. It is about 26% of the CPU requests and 40% of the memory, because it runs the full stateless set for one namespace with nothing to share it with. Moving it to its own cluster removes that share.
Each further tenant adds 1.075 cores and about 1.7 GiB and nothing else — the charts and the pool are already paid for. Ten tenants would be roughly 18.5 cores and 36.6 GiB in total.
Cluster shapes
Adding the job peak leaves 9.3 cores and 22.7 GiB of requests to place:
| Cluster | Capacity | Allocatable | Requests occupy | Survives losing one node |
|---|---|---|---|---|
| 1 × 16 vCPU / 48 GiB | 16 vCPU / 48 GiB | 15.25 cores / 45.5 GiB | 61% CPU / 50% memory | No — single node |
| 2 × 8 vCPU / 32 GiB | 16 vCPU / 64 GiB | 14.5 cores / 59 GiB | 64% CPU / 38% memory | No |
| 3 × 8 vCPU / 32 GiB | 24 vCPU / 96 GiB | 21.75 cores / 88.5 GiB | 43% CPU / 26% memory | Yes — 64% / 38% on the two that remain |
Longhorn places each replica of a volume on a different node, so at its default of three replicas every OLIVE volume on a one- or two-node cluster stays permanently Degraded. Those two shapes are for clusters whose class replicates below Kubernetes — EBS gp3, for example — or where numberOfReplicas has been lowered deliberately. See Disk.
Start from three nodes of 8 vCPU and 32 GiB. It is the smallest shape that keeps every pod schedulable when one node goes away, which matters because OLIVE creates no PodDisruptionBudget and does not autoscale. It also absorbs a rolling update, where a replacement pod is scheduled before the one it replaces is retired, and it satisfies Longhorn's default replica placement.
Where surviving a node loss is not a requirement, 16 vCPU and 48 GiB of allocatable capacity is the floor: one node that size, or two of 8 vCPU / 32 GiB.
Disk
Storage claims lists what each component claims. A replicating storage class multiplies all of it. Longhorn keeps three replicas of every volume by default, so a tenant's 21 GiB of claims occupies about 63 GiB of raw disk across the nodes. On a class that replicates below Kubernetes — EBS gp3, where the redundancy is inside the service — the claim is the provisioned figure. Check which you have:
kubectl get storageclass <class> -o jsonpath='{.parameters.numberOfReplicas}{"\n"}'
| Installation | Claimed | Longhorn, 3 replicas | Single-replica class |
|---|---|---|---|
| The minimum | 71 GiB | ~213 GiB | 71 GiB |
| With production and one tenant | 102 GiB | ~306 GiB | 102 GiB |
| Each further tenant | +21 GiB | +63 GiB | +21 GiB |
The 500 GB at the top of this page covers the second row on Longhorn with room left over. It is deliberately generous: node-local ephemeral storage — the container image cache, pod logs and emptyDir volumes, which sit on each node's own disk rather than in a claim — is not characterised here, and the replica count is a storage-class decision rather than an OLIVE one.
Two constraints are worth knowing before you set the sizes rather than after. SeaweedFS is capped at 32 GB of usable object storage however large its volume, and growing any of these volumes later means deleting the StatefulSet with --cascade=orphan — cluster-operator work, not a values change. Both are in Sizing the volumes.
Next Steps
Once your infrastructure is sized, proceed to:
Dependencies – Validate that the required infrastructure components (Vault, CNPG, Keycloak, Argo CD) are installed and properly configured by your cluster operator.