Skip to main content

Shared Responsibility

OLIVE's overall security depends on controls owned by five distinct roles. An unclear boundary between them is itself a security weakness, so the roles are named before the controls are assigned.

The five roles​

OLIVE Platform Team — builds the software: the microservices, the shared libraries, the Helm charts, the container images, the security defaults and the release pipeline. Everything this team owns is delivered as an artefact; it operates nothing in production.

Cluster Operator — provides and runs the Kubernetes environment OLIVE is deployed into: the cluster and its nodes, the CNI, ingress and TLS termination, the service mesh platform, storage classes and encryption at rest, the log and metrics platform, backup infrastructure, the GitOps deployment system, and the identity infrastructure used by operator-level administrators. The role is defined by function rather than by team.

Platform Administrator — runs the OLIVE installation on top of that cluster: onboards and offboards tenants, sets the deployment values that switch security controls on or off, creates each tenant's Keycloak realm and sets platform-wide authentication policy, manages tenant lifecycle in Vault, states the log retention and access requirements, and holds the operator-level administrative accounts. This is the role that turns a delivered artefact into a running service.

Tenant Administrator — administers one tenant inside the realm the platform administrator created: its users and their credentials, role assignment within the tenant, MFA enforcement and password policy on that realm, session revocation, and access review. They have no cluster access, no Helm access and no visibility of any other tenant. See the Tenant Administrator guide. Customizer — writes the code that runs inside OLIVE's trust boundary: connectivity definitions, connectors and datapoints, and microfrontend components. This role matters disproportionately: its code executes with the platform's privileges and inside the user's browser session, so a Customizer mistake is not contained the way ordinary application input is.

The end customer as a commercial party is deliberately not a role here. A customer organisation may staff the Platform Administrator, Tenant Administrator or Customizer roles, but "customer" by itself owns no control.

Responsibility matrix​

AreaOLIVE Platform TeamCluster OperatorPlatform AdministratorTenant AdministratorCustomizer
Application code securityOwns———Owns their own code
Helm charts and workload security contextOwnsValidates in clusterSets deployment values——
Container image build and signingOwnsRegistry operation, verification credentials——Owns images for own components
Dependency and image scanningOwns (gates release)———Owns for own dependencies
SBOM generationOwns—Retains per deployed version——
Network policy definitionsOwnsCNI capability, enforcementEnables in deployment values—Uses the documented service label
Service mesh mTLS supportOwns (chart support)Provides and operates the meshEnables in deployment values——
Kyverno baseline and example policiesOwnsInstalls engine, sets enforcement modeSelects mode, applies namespace labels——
Additional organisation-specific policies—May own cluster-wideOwns OLIVE-namespace policies——
Keycloak configuration and MFAShips hardened exampleMFA for operator-level admin identitiesRealm creation and platform-wide authentication policyOwns inside their own realm — user lifecycle, MFA enforcement, password policy—
Role assignment (user / editor / admin)Provides separation—Defines the segregation policyOwns assignment inside their own tenant—
Vault role and policy designOwnsOperates instance, seal/unseal, key custodyApplies during tenant onboarding——
Secret rotation for infrastructure credentialsProvides mechanismOwns process for cluster-level secretsOwns process for OLIVE-level secretsRotates the two Keycloak-only client secrets; raises the two mirrored in Vault—
Tenant onboarding and offboardingProvides toolingStorage reclaim behaviourOwns — executes and verifies——
Tenant data deletion on terminationProvides mechanismBackup deletion timelinesOwns execution and evidence——
Security event emissionOwns————
Log collection, retention, access controlDefines streams and requirementsOperates the platform; owns retention and access enforcementStates the retention and access requirement per stream— (cannot reach the log platform)—
Alerting, detection, incident response—Owns tooling and platform alertsOwns OLIVE-level alert rules and first-line triage——
Cluster and node hardening—Owns———
Encryption at rest, key ownershipDefines requirementsOwns———
Backup, restore, disaster recoveryDefines what must be preservedOwns infrastructure and executionVerifies OLIVE-level restore correctnessOwns OCB exports of their own connectivity content—
Ingress, TLS certificates, perimeterStates configuration requirementsOwnsDomain and route configuration——
Reaching an internal destination (registration)Provides mechanism; advises via supportNetwork-level egress controlsRaises the case, applies the advised approachRaises the case for their tenantReports the use case
Deployment approval and promotionRelease process and versioningOperates Argo CDOwns promotion decisions——
Connectivity and microfrontend code securityProvides guidance and guardrails—Reviews before enablingDecides what is enabled in their tenantOwns
Uploaded content and file safetyProvides validation and limits—Policy and monitoringOwns what their users publishOwns content they publish
Risk management, incident reporting, governance—Owns for cluster scopeOwns for service scopeOwns for tenant scope—

Four notes on the model​

Customizer code is inside the trust boundary. Connectors execute with the platform's outbound reach and can be invoked by privileged users; microfrontend components run in the authenticated user's browser. The platform side is addressed — role separation, egress guards, file access controls, CSP — and the rest is documented as Customizer responsibility. That documentation is a control, and it only works if the Platform Administrator reviews Customizer code before enabling it. See the connectivity handbook's security chapter for what Customizers are asked to do.

Connectivity runs as whoever executes it. A connector containing a privileged datapoint does nothing for an ordinary user and succeeds for an administrator, so an administrator who uses their admin account for everyday work becomes a way to perform administrative actions without holding the role. The platform cannot prevent this: keeping admin accounts out of daily use, and out of connectivity execution, is an organisational rule the Platform Administrator has to set and hold. See Security Configuration → Identity and Secrets.

The Platform Administrator holds most of the switches, but not the ones inside a tenant. Network policies, mesh mTLS, Kyverno enforcement mode and the deployment values are all decided there — not by the platform team and not by the cluster operator. What happens inside a tenant's realm is not: user lifecycle, role assignment, MFA enforcement and password policy belong to that tenant's administrator, and the platform administrator sets the policy they work within rather than making each decision.

Several rows are split rather than owned. Backup — infrastructure and execution on one side, verifying that an OLIVE-level restore is correct on the other. Alerting — the tooling and the cluster's own alerts on one side, OLIVE-level rules and first-line triage on the other. Secret rotation, and the monitor objects, divide the same way. These are the rows where an assumption that the other side has it covered goes unnoticed longest, so they are the ones worth reading together.