Skip to main content

Hardware and Environment Requirements

RequirementDescription
Supported Kubernetes distributionsRKE2 and Amazon EKS — both tested. Other CNCF-compliant clusters may work with extra validation
Kubernetes version1.31 or later
CPU architectureamd64. 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 nodesOne, 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 confinementAppArmor 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 targetA CNCF-compliant Kubernetes cluster, on cloud or on-premises
A few values differ between RKE2 and EKS

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.

OLIVE does not yet characterise its high-availability behaviour

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​

ColumnWhat it isWhat it means for the cluster
RequestsWhat the scheduler reserves on a node before the pod startsSize against this. If the requests do not fit, pods stay Pending regardless of what the nodes are actually doing
LimitsThe ceiling a container may reachA 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​

DeploymentCPU requestsCPU limitsMemory requestsMemory limits
Development (single-no-auth)2.32 cores26.8 cores8.75 GiB39.44 GiB
Production — shared runtime pool (multi-shared)2 cores24 cores7.625 GiB36 GiB
Production — each tenant (multi-tenant)1.075 cores6.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.

These totals include each deployment's own Job and CronJob pods

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.

ChartRunning podsCPU requestsCPU limitsMemory requestsMemory limits
vault-infra3 × Vault server1.5 cores6 cores1.5 GiB6 GiB
keycloak-infraKeycloak + its PostgreSQL1.2 cores4 cores1.5 GiB4 GiB
kyverno-infra2 × admission, plus background, cleanup and reports controllers0.5 coresnone set448 MiB1.125 GiB
traefik-infra2 × Traefik0.2 cores2 cores256 MiB1 GiB
All four3.4 cores12 cores, plus Kyverno unbounded3.6875 GiB12.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:

ComponentVolumesClaimed
Development deploymentCouchDB 1Gi, SeaweedFS 20Gi, Temporal PostgreSQL 10Gi31 GiB
Shared runtime poolTemporal PostgreSQL 10Gi10 GiB
Each tenantCouchDB 1Gi, SeaweedFS 20Gi21 GiB
vault-infra3 × 10Gi, one per Vault server30 GiB
keycloak-infraPostgreSQL 10Gi10 GiB
kyverno-infra, traefik-infranone—

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:

ComponentCPU requestsMemory requests
Development deployment (single-no-auth)2.32 cores8.75 GiB
All four infrastructure charts3.4 cores3.6875 GiB
The infrastructure charts' Jobs, overlapping0.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:

ComponentCountCPU requestsCPU limitsMemory requestsMemory limits
Development deployment (single-no-auth)12.3226.88.75 GiB39.44 GiB
Shared runtime pool (multi-shared)12247.625 GiB36 GiB
Tenant (multi-tenant)11.0756.05~1.7 GiB~5.1 GiB
vault-infra11.561.5 GiB6 GiB
keycloak-infra11.241.5 GiB4 GiB
kyverno-infra10.5none set448 MiB1.125 GiB
traefik-infra10.22256 MiB1 GiB
Total8.795 cores68.85 cores, plus Kyverno21.72 GiB92.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:

ClusterCapacityAllocatableRequests occupySurvives losing one node
1 × 16 vCPU / 48 GiB16 vCPU / 48 GiB15.25 cores / 45.5 GiB61% CPU / 50% memoryNo — single node
2 × 8 vCPU / 32 GiB16 vCPU / 64 GiB14.5 cores / 59 GiB64% CPU / 38% memoryNo
3 × 8 vCPU / 32 GiB24 vCPU / 96 GiB21.75 cores / 88.5 GiB43% CPU / 26% memoryYes — 64% / 38% on the two that remain
The one- and two-node shapes need a storage class that does not replicate

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"}'
InstallationClaimedLonghorn, 3 replicasSingle-replica class
The minimum71 GiB~213 GiB71 GiB
With production and one tenant102 GiB~306 GiB102 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.