Skip to main content

Infrastructure Prerequisites

OLIVE depends on infrastructure it does not contain: an identity provider, a secrets manager, and — optionally — a service mesh and an admission policy engine. These have to exist, and be configured in particular ways, before the platform charts will work.

Installing them is not your task. It is cluster work and it needs cluster rights: CRDs, cluster-scoped webhooks and ClusterRoles, writes into kube-system and the mesh root namespace, plus things that live outside Kubernetes altogether — a KMS key, IAM roles, an S3 bucket, DNS, a publicly trusted certificate. Your cluster operator owns that, and the responsibility matrix says so.

Specifying them is your task. This page is the contract: what each component must provide before OLIVE can run on it. Hand it to whoever operates your cluster, and keep it to check their work against.

The two-sided version of this page

Cluster Operator → Handover Checklist is the same handover written as one list for both sides: what the cluster operator provides, the values each of you needs back from the other, and the cluster-scoped checks only they can run. Work through it together; use this page for the detail of what Vault, Keycloak, the mesh and Kyverno have to deliver.

ComponentRequired?Your cluster operator installs itYou specify
HashiCorp VaultYes — OLIVE cannot run without onevault-infra, or their ownThe KV mount, auth method, bootstrap policy and role, and the address block
KeycloakYes for authenticated deploymentskeycloak-infra, or their ownThe issuer URL, realm and MFA policy, admin credential path, audit settings, login theme
Service meshOptionalservice-mesh-setup on top of an Istio they installedOnly that serviceMesh.mode matches what exists
KyvernoOptionalkyverno-infra, or their ownThe policies: signer identity, registry allow-list, enrolment label keys and per-namespace modes
The charts are a convenience, not a requirement

OLIVE makes five Helm charts available that set these up, documented in Cluster Operator → Infrastructure Charts — including one for Traefik, which is useful only where Traefik is not already installed. They are not part of the OLIVE platform and are provided as-is.

If your organisation already runs a Keycloak, already has a hardened Vault, or has its own opinion about Kyverno, use what you have. What matters is that the things on this page are true afterwards, not how they came to be true. Choosing not to use the charts does not reduce your support for the platform, and choosing to use them does not extend support to cover them.


What you hand over​

These blocks are read by more than one chart, including the platform charts. Keep them in one shared values file that every deployment includes — a cluster where two charts disagree about where Vault lives, or about which mesh mode is installed, fails in ways that look like something else entirely.

global:
vault:
namespace: 'oli-hashicorp-vault'
serviceName: 'oli-vault'
port: 8200
scheme: 'http'
serviceMesh:
mode: ambient # none | sidecar | ambient — must match what is installed
vaultMeshed: true
# The three Kyverno enrolment label keys. Separate on purpose — a namespace
# can enforce one control while still only auditing another.
imageVerification:
labelKey: 'olive/image-verification'
imageRegistry:
labelKey: 'olive/image-registry'
podPrivileges:
labelKey: 'olive/pod-privileges'

Order of installation​

The order is a prerequisite in its own right, because each step depends on the one before it:

  1. Vault — everything else stores credentials in it, including Keycloak's admin password.
  2. Keycloak — needs Vault to exist first; its admin credential is seeded into Vault and read back from there.
  3. Service mesh configuration — after Istio itself is installed, and before any namespace is enrolled.
  4. Kyverno — any time; it evaluates namespaces that carry the enrolment label.

Then you deploy the OLIVE platform charts.

What you can verify yourself, and what you have to ask for​

Most of these checks are cluster-scoped reads, which you may not be able to run. Where that is the case, the check is a question for your cluster operator rather than a command for you.

QuestionWho runs it
Are the Kyverno policies present and active?Cluster operator — kubectl get validatingpolicy,imagevalidatingpolicy, and the policy status, since a policy whose CEL failed to compile is listed and completely inert
Which namespaces are enrolled, and in which mode?Cluster operator — kubectl get ns -L olive/image-verification,olive/image-registry,olive/pod-privileges
Is my namespace actually being evaluated?You — kubectl get polr -n <namespace>. A namespace that is labelled but has no rows here is enrolled and not being evaluated
Is Vault reachable at the address I specified?You, from inside a tenant namespace
Does the ClusterRole the VSO binding references exist?Cluster operator — kubectl get clusterrole | grep vault-secrets-operator
"Enforced" is not something you can assume from a values file

Setting a mode to enforce only labels the namespace. If the engine is not installed, the policies are not deployed, or a policy selects a different label than the namespace carries, then nothing is enforced — silently, with no error anywhere, and the values file reads as though the tenant were protected.

Get the first two rows of that table answered before you treat any of these controls as in place.


HashiCorp Vault​

Vault is the platform's source of truth for secrets. Every tenant's credentials, every connectivity authentication entry, the storage credentials and the Keycloak administrator password live there. Microservices authenticate to Vault with the requesting user's JWT, so Vault — not the application — decides what that caller may read.

Without a Vault that OLIVE can bootstrap tenants into, the platform does not start. This is the one component here that is not optional.

Whoever sets Vault up, this is the checklist. All of it has to be true before a tenant's vault-secrets-setup deployment can succeed.

Reachability​

OLIVE addresses Vault through four values, read by every chart that talks to it:

global:
vault:
namespace: 'oli-hashicorp-vault' # the namespace Vault RUNS in
serviceName: 'oli-vault' # the Service / StatefulSet name
port: 8200
scheme: 'http'

namespace is more than half an address. It is also where the tenant setup Job and the token-renew CronJob run, and it is the bound_service_account_namespaces of the Kubernetes auth roles. All of that moves together.

serviceName is the one people forget. If you renamed your Vault Helm release, the Service is named after it, and setting only the namespace fails as a connection timeout rather than a name error.

Inside Vault​

RequirementDetail
Initialised and unsealedBy whatever seal you choose — Shamir, AWS KMS, another KMS provider
KV v2 mount at secret/This is where all platform secrets live
Kubernetes auth method enabled at kubernetesConfigured against https://kubernetes.default.svc
disable_iss_validation=true on that auth configSee the warning below
The bootstrap policyThe full ACL policy below — this is the part you cannot improvise
The bootstrap role in the Kubernetes auth methodBound to the ServiceAccount the tenant setup Jobs present
Vault Secrets Operator installed in the clusterExactly one instance for the whole cluster. It has no watch-namespace option, so every instance reconciles every VaultConnection, VaultAuth and VaultStaticSecret in the cluster. It does not need duplicating: the Vault address lives on the VaultConnection, so one operator can serve tenants on two different Vaults. The same applies to the Vault Agent Injector, a single cluster-wide mutating webhook — which is required and ships disabled: vault.injector.enabled: true. CouchDB and SeaweedFS read their credential from a file the injected agent writes, so without it those pods start and hang with a green Helm release and a green Argo CD sync. Confirm with kubectl get mutatingwebhookconfiguration | grep -i vault before the first tenant
The KV mount name is not free

Tenant onboarding writes every policy against secret/data/..., i.e. a KV v2 mount literally named secret. Renaming it produces policies that grant nothing — they are syntactically valid and match no path.

The bootstrap policy​

This is the piece that has to be right to the character. Tenant onboarding authenticates against this policy and creates the per-tenant policies, Kubernetes auth roles and JWT auth mounts through it. If a path is missing, onboarding fails with a permission denied that names a Vault path and nothing else.

# Tenant policy management (name-prefixed only)
path "sys/policies/acl/shared-secrets-*" { capabilities = ["create", "update", "read"] }
path "sys/policies/acl/tenant-sync-*" { capabilities = ["create", "update", "read"] }
path "sys/policies/acl/tenant-infra-*" { capabilities = ["create", "update", "read"] }
path "sys/policies/acl/keycloak-onboard-*" { capabilities = ["create", "update", "read"] }
path "sys/policies/acl/token-issuer-*" { capabilities = ["create", "update", "read"] }
# Legacy prefix. No 1.3 deployment creates these; kept so the policy still
# covers objects left behind by a pre-1.3 installation.
path "sys/policies/acl/control-plane-*" { capabilities = ["create", "update", "read"] }

# Keycloak infrastructure policies, written by the keycloak-infra bootstrap Job
path "sys/policies/acl/keycloak-infra-*" { capabilities = ["create", "update", "read"] }

# Function-scoped policies consumed by application code
path "sys/policies/acl/read-repo-secrets-*" { capabilities = ["create", "update", "read"] }
path "sys/policies/acl/edit-repo-secrets-*" { capabilities = ["create", "update", "read"] }
path "sys/policies/acl/read-couchdb-secrets-*" { capabilities = ["create", "update", "read"] }
path "sys/policies/acl/read-seaweedfs-secrets-*" { capabilities = ["create", "update", "read"] }

# Kubernetes auth role management (name-prefixed only)
path "auth/kubernetes/role/shared-secrets-role-*" { capabilities = ["create", "update", "read"] }
path "auth/kubernetes/role/vso-sync-role-*" { capabilities = ["create", "update", "read"] }
path "auth/kubernetes/role/tenant-infra-role-*" { capabilities = ["create", "update", "read"] }
path "auth/kubernetes/role/keycloak-onboard-role-*" { capabilities = ["create", "update", "read"] }
path "auth/kubernetes/role/token-issuer-role-*" { capabilities = ["create", "update", "read"] }
path "auth/kubernetes/role/keycloak-infra-*" { capabilities = ["create", "update", "read"] }

# Enable / inspect the per-tenant JWT auth mounts
path "sys/auth" { capabilities = ["read", "list"] }
path "sys/auth/jwt-*" { capabilities = ["create", "update", "read", "sudo"] }

# Create the per-tenant JWT login roles
path "auth/+/role/shared-secrets-role-*" { capabilities = ["create", "update", "read"] }
path "auth/+/role/read-repo-secrets-*" { capabilities = ["create", "update", "read"] }
path "auth/+/role/edit-repo-secrets-*" { capabilities = ["create", "update", "read"] }
path "auth/+/role/read-couchdb-secrets-*" { capabilities = ["create", "update", "read"] }
path "auth/+/role/read-seaweedfs-secrets-*" { capabilities = ["create", "update", "read"] }

# Own login
path "auth/kubernetes/login" { capabilities = ["create", "update"] }

Three things about this policy that are easy to get wrong​

sudo on sys/auth/jwt-* is required. Enabling an auth method is a root-protected operation, and the setup Job enables the per-tenant JWT mount itself. Without sudo there, onboarding fails with permission denied. Older platform documentation put that capability in the tenant policy instead — which is exactly what allowed a tenant to reconfigure its own auth mount and issue itself any identity, including administrator. Keep it here, not there.

In Vault ACL paths, * is a wildcard only as the final character. auth/jwt-*/role/shared-secrets-role-* matches a literal asterisk segment and therefore nothing at all. + is the single-segment wildcard, which is why the JWT role rules are written auth/+/role/.... Limiting those rules to the role/ sub-path also keeps auth/jwt-<tenant>/config out of reach — that write belongs to the scoped keycloak-onboard-<tenant> policy, which pins its parameters.

The prefixes are load-bearing, and they come first for a reason. Because * only globs at the end, there is no suffix pattern that could authorise a name shaped like <instance>-infra-seed. Every name in this policy is prefix-shaped so that one rule covers every present and future tenant or Keycloak instance without the policy being rewritten.

Do not widen this to sys/policies/acl/* and auth/kubernetes/role/*

An earlier version of this policy did exactly that, and it made the role a standing Vault administrator: able to write the default policy, mint roles binding any service account, and read any tenant's secrets. The prefixes are what reduce it to the objects onboarding actually manages.

Residual risk even so: whoever can present the bound service-account token can still rewrite tenant policies. Keep that ServiceAccount confined to the Vault namespace, keep the role TTL short, and audit writes to sys/policies.

The bootstrap role​

vault write auth/kubernetes/role/vault-bootstrap-role-v2 \
bound_service_account_names="vault-secrets-operator" \
bound_service_account_namespaces="<the Vault namespace>" \
policies="vault-bootstrap-policy-v2" \
ttl="30m"
One name and one namespace per role

Vault matches bound_service_account_names and bound_service_account_namespaces as independent sets, so a role listing two of each authenticates all four combinations. Bind exactly one of each.

Secrets that must exist​

PathHoldsCreated by
secret/shared-secrets/olive-regcredThe container registry pull credential, as .dockerconfigjsonYou, by hand
secret/<keycloakVaultPath>The Keycloak admin credentialThe keycloak-infra seed Job, or you

olive-regcred is deliberately not created by any chart — it is a credential OLIVE has no business holding on your behalf.


Keycloak​

Keycloak is the platform's identity provider. It issues the tokens every OLIVE service validates, it holds each tenant's realm, and it provides multi-factor authentication, brute-force detection and session management — capabilities OLIVE deliberately does not implement itself.

Required for any authenticated deployment (multi-shared / multi-tenant). A single-no-auth development deployment does not use it for login.

Reachability — public HTTPS, not in-cluster DNS​

This is the requirement most likely to be got wrong when setting Keycloak up independently.

OLIVE's consumers — the tenant onboarding Job, the auth proxy, and every Express service validating a JWT — reach Keycloak only over its public HTTPS address, never over in-cluster DNS. The token issuer must be the same URL that browsers use, because the issuer in a JWT has to match what the services expect, and they compare it exactly: no wildcards, no suffix matching.

global:
keycloakBaseURL: 'https://auth.develop.olive-team.com'
jwtIssuer:
rootPath: https://auth.develop.olive-team.com/realms/

This means Keycloak needs a valid, publicly trusted TLS certificate for that hostname. If the certificate is internally signed, the onboarding Job's TLS verification fails, and you will need the custom-CA configuration in the Vault and platform charts.

Hostname strictness​

global.keycloakHostnameStrict defaults to true, and that is the only value that belongs in production: Keycloak then builds every issuer URL, redirect URI, admin console URL and OIDC discovery document from keycloakBaseURL and nothing else.

keycloakHostnameStrict: false is a host-header injection primitive

With it off, Keycloak resolves its hostname from the incoming request headers — against the component whose entire job is issuing tokens. An attacker who reaches the pod with a forged Host header gets tokens and password-reset links pointing at a host they control, and the mails look genuine because Keycloak really did send them.

The chart refuses to render a non-strict Keycloak unless global.keycloakHostnameStrictAcknowledged is also set. Do not pass --hostname-strict in keycloakx.args either — the argument wins over the environment variable, and the render fails rather than let the two disagree.

keycloakHostPrefix​

Leaving keycloakBaseURL empty derives https://<keycloakHostPrefix>.<clusterName>.<domain>, with the prefix defaulting to authenticate. The prefix is local to this chart: keycloak-setup builds its own base URL from global.keycloakBaseURL and otherwise hardcodes authenticate., so changing the prefix alone moves Keycloak and leaves the onboarding Job talking to the old host.

The chart therefore refuses a non-default prefix unless global.keycloakBaseURL is set as well. Set both.

A PostgreSQL database​

Keycloak needs a persistent relational database. The chart provisions a CloudNativePG cluster; an external PostgreSQL works equally well.

Two sizing rules that bite later rather than immediately:

  • Connection pool vs. server limit. replicas × poolMaxSize + 10 reserved must not exceed the server's max_connections. Keycloak does not back off when the server refuses a connection.
  • Multiple replicas need a distributed cache. Two or more Keycloak replicas with a local cache produce intermittent login failures — the worst possible symptom, because it looks like a network problem.

The pool defaults are poolInitialSize / poolMinSize 5 and poolMaxSize 20, which keeps two replicas inside a default max_connections=100 with headroom for replication slots, the instance manager and psql.

TLS from Keycloak to PostgreSQL is global.postgres.tlsMode, default verify-full (encrypt, verify the CA, verify the hostname). That works out of the box with the chart's CloudNativePG cluster, because the operator puts the -rw Service names in the server certificate's SANs and Keycloak connects to <cluster>-rw. If you repoint Keycloak at a Pooler or an additional Service, that name has to be in the SAN list too or every connection fails closed at startup. Pointing at a database the chart does not manage (cnpg.cluster.enabled: false) also means setting global.postgres.caSecret explicitly.

Storage for the database volume comes from global.storageClassName, which sets the StorageClass for every volume in the namespace. '' leaves the chart's own value; 'default' omits the field so Kubernetes picks the default class; otherwise name one ('longhorn', 'gp3'). A StatefulSet's volumeClaimTemplates are immutable, so on an existing install this has to keep rendering what it rendered before.

The admin credential in Vault​

OLIVE's tenant onboarding authenticates to Keycloak as its administrator, and reads that password from Vault:

WhatWhere
Vault KV pathsecret/<global.keycloakVaultPath>, default keycloak/keycloak-credentials
Fieldpassword
Usernameadmin (fixed — the onboarding script does not read a username from Vault)

The path is relative to the KV mount; the charts refuse to render if it repeats the mount or contains a data/ segment.

Keycloak reads the bootstrap password only once

KC_BOOTSTRAP_ADMIN_PASSWORD is honoured only on the first start against an empty database. After that, the authoritative copy lives inside Keycloak's own database. Writing a different value into Vault afterwards does not change it — it only makes the two disagree, and the next tenant onboarding fails to authenticate.

If you seed this yourself, seed it before Keycloak first starts. To change it later, see Secrets Rotation.

If you provision Vault access yourself, note that the reader and the seeder must be two different identities: one Vault policy with READ on the KV path, another with CREATE. Sharing one ServiceAccount means the reader can create secrets and the seeder inherits whatever the reader may do.

The test user​

keycloak-setup can create a user in each tenant realm, from three values:

keycloak-setup:
activateTestUser: false # default
testUserName: 'test'
testUserPassword: 'test'
Never enable this in a deployment that is reachable or holds data

It defaults to false, and it must stay false anywhere except a throwaway lab. The default name and password are test / test, the user is created enabled and email-verified, and the password is set as not temporary — so it never has to be changed.

The job is also idempotent only in one direction: it creates the user if missing and otherwise leaves it alone. Setting activateTestUser back to false does not remove a user that was already created. If one exists in a realm that matters, delete it in Keycloak by hand and confirm it is gone.

Realm configuration​

OLIVE's onboarding creates and maintains the per-tenant realms, so you do not configure those by hand. What you do decide:

  • Multi-factor authentication, per realm and per role. Expected for administrative roles.
  • Brute-force detection — enable it.
  • Session lifetimes, and that removing a user actually terminates their sessions.
  • Admin event logging — required by the auth-proxy session-purge job, and the only way successful logins become visible to monitoring, since they complete in Keycloak rather than in OLIVE. Emit them as JSON so they can be ingested.
Audit logging has two halves, and the chart only owns one

Capture is per realm, not per server: eventsEnabled, adminEventsEnabled, adminEventsDetailsEnabled, eventsExpiration and eventsListeners live in the realm, so they come from the realm import or the Admin API. No Keycloak option, environment variable or Helm value switches them on cluster-wide.

Both are on in a newly onboarded realm. The realm OLIVE imports sets eventsEnabled: true with a 30-day eventsExpiration, and the onboarding job sets adminEventsEnabled and adminEventsDetailsEnabled and re-enforces them on every sync — the session-purge CronJob reads the admin log, and with admin events off that endpoint returns an empty list rather than an error, so the job would run green and terminate nothing.

Realm import only reaches new realms

eventsEnabled is set by the realm import, which applies when a realm is created. A tenant realm onboarded before this default changed still has user events off, and re-syncing keycloak-setup will not turn them on — only admin events are reconciled on every run. Check each existing realm and enable user events there by hand: Realm settings → Sessions/Events → User events config → Save events.

Emission is what global.audit controls. The built-in jboss-logging listener writes captured events at DEBUG for successes and WARN for failures — so at the default root level of INFO, a correctly configured realm captures every login and emits nothing to stdout. The events land in the database's EVENT_ENTITY table and nowhere a log stack can see them.

global:
audit:
enabled: true
successLevel: 'info' # Keycloak's default is debug — this is the step that matters
errorLevel: 'warn'
logFormat: 'json' # whole-server switch, not events-only
logLevel: ''

Cost of successLevel: info is one log line per user event, and on a busy realm token refreshes dominate. Dropping to warn keeps only failures, which is still the half that matters for intrusion detection. logFormat: json changes every line Keycloak writes, so turn it on when the log pipeline expects JSON and not before.


The OLIVE login theme​

The chart mounts an olive login theme that inherits keycloak.v2 and adds an Impressum and privacy footer. global.keycloakLegal.enabled defaults to true, with impressumUrl and privacyUrl as public HTTPS links.

For a customer-operated installation, set your own URLs here and set the editor's LEGAL_IMPRESSUM_URL and LEGAL_PRIVACY_URL environment variables to match. Publish those notices before enabling the theme. The defaults are BOC's, which are wrong for an installation you operate — both configuration points, and who has to publish what, are in Legal Notices and Configurable Links.

If you override keycloakx.extraVolumes, extraVolumeMounts or podAnnotations, preserve the theme mount and its checksum annotation — the checksum is what restarts Keycloak when the theme content or links change. Before disabling the theme, select another installed theme on every realm using it.



Service mesh​

Optional. Skip this if global.serviceMesh.mode is none.

Traffic between the cluster and external systems is already encrypted. Traffic between workloads inside the cluster is plaintext unless a service mesh provides mutual TLS. Enabling the mesh is what lets you say data is protected in transit inside the cluster too, not only at the edge.

OLIVE supports Istio, and the evaluated shape is ambient mode — a per-node ztunnel DaemonSet rather than a per-pod sidecar. sidecar mode is not thoroughly tested; the charts render the policy shape it needs, but no release has been validated on it end to end. See Service Mesh and mTLS.

Your share of this is one value, and it is the one that fails silently:

global:
serviceMesh:
mode: ambient # none | sidecar | ambient
vaultMeshed: true # is the Vault namespace enrolled?
mode must match what is actually installed

sidecar and ambient need opposite changes to the network policies — sidecar needs egress to istiod on 15012, ambient needs 15008 added to every rule whose peer is a meshed pod. A wrong value renders the policy set for the other mode, and nothing reports it.

vaultMeshed only ever adds an allowed port, so over-declaring the mesh is silently tolerated. What you actually get is tenant-to-Vault traffic running as plaintext on 8200, carrying Vault tokens and secrets, where you believed it was mTLS.

What to ask your cluster operator to confirm, because OLIVE depends on it and none of it is visible from a tenant namespace:

RequirementWhy it matters to OLIVE
The mesh starts PERMISSIVE, and STRICT is phased inSTRICT rejects plaintext from anything unmeshed. Every exemption exists because some unmeshed component legitimately needs to reach a meshed pod
Exemptions for the kube-apiserver's webhook callers — vault-agent-injector and KyvernoUnder mesh-wide STRICT, pod creation fails in every tenant namespace that runs CouchDB or SeaweedFS — which is every tenant
An exemption for the ingress controller, unless it is itself enrolledOtherwise the platform goes dark from outside while looking healthy inside
L4 AuthorizationPolicy for the storage services, enabled with enrollmentUnder ambient the real destination port travels inside the HBONE tunnel where the CNI cannot see it, so the NetworkPolicy port restrictions on seaweedfs and couchdb stop binding
Kubelet health probes allowed from 169.254.7.127/32Once a pod is enrolled, probes no longer arrive from the node IP. Without a rule for it, every liveness and readiness probe fails — the most common ambient rollout failure

The details, and the chart that configures all of it, are in Cluster Operator → Service Mesh.


Kyverno​

Optional. The platform runs without it. What you lose is enforcement: the imageVerification, imageRegistry and podPrivileges modes in the tenant values become labels that nothing reads.

OLIVE signs the container images it builds with cosign and pins every image by digest. Kyverno is what makes that verifiable at admission: it checks the signature before a pod is created, and refuses anything that does not verify or that comes from an unapproved registry.

The enrolment label contract​

This is the part that matters most, and the part that fails silently.

The policies select namespaces by a label; tenant-setup puts that label on the tenant namespace. The label's value is the mode — audit or enforce. A namespace with neither is not evaluated at all.

global:
imageVerification:
labelKey: 'olive/image-verification'
imageRegistry:
labelKey: 'olive/image-registry'
podPrivileges:
labelKey: 'olive/pod-privileges'
podPrivileges, not podSecurity

namespace.podSecurity in the same values file is Kubernetes Pod Security Admission for the Kyverno pods themselves — a different mechanism in a different place. The two being one word apart has already confused one reader.

Nothing cross-checks the two sides

A typo on either side produces a cluster where the policies exist, the namespaces look enrolled, and nothing is enforced — with no error anywhere.

Keep these keys in the shared values file so one edit moves both charts, and verify enrolment is real after any change.

What you can check yourself, per namespace:

kubectl get polr -n <namespace>

What to ask your cluster operator for, because both are cluster-scoped reads:

# Which namespaces are enrolled, per control
kubectl get ns -L olive/image-verification,olive/image-registry,olive/pod-privileges

# The policies themselves — policies.kyverno.io types, not the legacy ClusterPolicy
kubectl get validatingpolicy,imagevalidatingpolicy

A namespace that carries a label but has no rows in polr is enrolled and not being evaluated — check the label value against the mode values the policies select on.

The keyless verification identity​

Signature verification is keyless: the identity comes from the build pipeline's OIDC certificate, not a stored public key.

keyless:
subject: 'https://gitlab.com/olive6224315/docker-images//.gitlab-ci.yml@refs/heads/main'
issuer: 'https://gitlab.com'
rekorUrl: 'https://rekor.sigstore.dev'

Three things about the subject string, each of which silently matches nothing when wrong:

  • It is a URI and must start with https://.
  • It contains a double slash between the project path and the CI config path. Without it, nothing ever matches and every image fails verification with no hint why.
  • It ends with the ref the pipeline ran on, e.g. @refs/heads/main. Renaming the signing branch therefore changes the identity of every image signed afterwards.

Read the exact string off a real signature rather than composing it by hand.

Name the registries explicitly​

imageReferences:
- 'registry.gitlab.com/olive6224315/docker-images/*'
Never use a wildcard that matches any registry

A pattern like * also matches the hashicorp/vault agent sidecar and the istio/proxyv2 proxy that webhooks inject into tenant namespaces. Nothing in the platform signs those, so the first namespace switched to enforce would be a namespace where no pod can be created at all.