Networking
OLIVE runs on Kubernetes like other cluster workloads. Cluster operators typically own cluster networking, DNS, egress and ingress paths, and any firewall or proxy rules that must allow the platform and its integrations to function.
For a concise list of main stack components (ingress controllers, identity, storage, and related services), see Platform Technology Overview.
Network policies
From OLIVE 1.3, every chart ships Kubernetes NetworkPolicy objects derived from a full service communication matrix: for each service, which peers it must accept traffic from, which peers it must reach, whether it needs storage, whether it needs Vault, and whether it needs the public internet.
The model is default-deny: the tenant-setup chart lays down a namespace-wide deny baseline (plus DNS and telemetry egress) and each workload chart adds only the connections that service actually needs.
What the resulting policy set enforces:
- Express-based services may talk to each other through a shared pod label,
olive/platform: <shared runtime namespace>. A service you deploy yourself alongside OLIVE can carry the same label to participate. - Only the services that require internet access get it. CouchDB, SeaweedFS and the bootstrap jobs do not.
- Only the services that require storage may reach the storage services.
- Only the services that require Vault may reach Vault.
- A service in one tenant's namespace cannot reach a service in another tenant's namespace.
Policies are switched on by the platform administrator through global.networkPolicy.enabled. See Security Configuration → Network Policies for the values.
What the cluster must provide
This is the failure mode that matters: everything appears to work, the policies exist, and no traffic is actually restricted. Confirm your CNI enforces NetworkPolicy — Cilium and Calico do. If it does not, say so explicitly rather than letting the deployment believe it is segmented.
The policies also need to know where the ingress controller runs, so that default-deny still admits ingress traffic:
global:
networkPolicy:
ingressController:
namespace: kube-system
podLabels:
app.kubernetes.io/name: rke2-traefik
A selector that matches nothing is not an error — it is zero peers, and default-deny then removes every route into the namespace at once. On RKE2, the bundled Traefik is a DaemonSet in kube-system labelled app.kubernetes.io/name=rke2-traefik; note the rke2- prefix, because the upstream Traefik chart uses plain traefik.
The values above are the default and describe RKE2. Where Traefik is installed separately — Amazon EKS, AKS, or RKE2 with the bundled ingress disabled — the platform administrator sets both fields to that installation. Tell them where it runs and how its pods are labelled; for the upstream chart installed as release traefik:
global:
networkPolicy:
ingressController:
namespace: traefik
podLabels:
app.kubernetes.io/name: traefik
Verify before anyone enables policies:
kubectl -n kube-system get pods -l app.kubernetes.io/name=rke2-traefik # RKE2 bundled
kubectl -n <traefik-namespace> get pods --show-labels # separate install
The VPC CNI enforces NetworkPolicy only with enableNetworkPolicy=true on the add-on, or with Calico or Cilium installed.
Egress
Services that need the public internet get an egress rule to 0.0.0.0/0 minus a configured list of non-routable ranges. That subtraction is what stops an internet rule from also matching in-cluster addresses and quietly bypassing the pod selectors. The default list covers RFC1918, CGNAT, link-local (including the metadata endpoint 169.254.169.254), loopback, multicast and reserved space.
The list is deliberately wider than any one cluster's ranges, because a missing range is the dangerous direction and neither EKS (VPC CNI) nor AKS (plain Azure CNI) has a fixed pod CIDR to preset.
Because the carve-out covers all private space, peered databases, on-prem systems over VPN, AWS interface endpoints and Azure Private Link are also blocked. Those must be added back as explicit ipBlock entries under the relevant chart's extraEgress. Expect to be asked for this whenever a connectivity engineer integrates an internal system.
DNS and telemetry
- DNS egress is scoped to the cluster DNS pods (
k8s-app: kube-dnsinkube-system). An unscoped port-53 rule is an exfiltration channel. - Telemetry egress to the observability collector is allowed by default on OTLP ports 4317 (gRPC) and 4318 (HTTP). Confirm these against your collector's Service — Grafana Alloy commonly also listens on 12345. A rule listing the wrong port is not an error; it is zero coverage, and it looks identical to the rule being absent. Without working telemetry egress, every pod's OTLP exporter retries forever and the retry noise can rotate away the evidence you would need to diagnose a mesh rollout.
Reaching the OLIVE registries
Pulling the platform requires outbound HTTPS to registry.gitlab.com — for the Helm charts and, separately, for OLIVE's own container images. Both are OCI endpoints on that host. This is a hard prerequisite: there is no offline installation path, so a cluster without a route to that host cannot install or upgrade OLIVE.
OLIVE does not re-host the third-party images it runs, so nodes pull from several registries:
| Host | What comes from it |
|---|---|
registry.gitlab.com | OLIVE's own service images, and every Helm chart |
quay.io | Keycloak, OAuth2 Proxy |
gcr.io | The distroless runtime base images the Express and Python services run on |
docker.io (also reached as index.docker.io) | Vault, the Vault Secrets Operator, CouchDB, Redis, SeaweedFS, Temporal, Alpine, BusyBox — and istio/proxyv2 if the mesh ever runs in sidecar mode |
A cluster that allow-lists only registry.gitlab.com does not install: the first failure is an ImagePullBackOff on Keycloak or CouchDB, not on an OLIVE service.
The authoritative inventory is the registry allow-list policy, because anything the admission policy permits is something the firewall has to permit too. The full list of image prefixes is on the Kyverno page.
If image signature verification will be enabled, the Kyverno pods additionally need HTTPS egress to the Sigstore services — fulcio.sigstore.dev, rekor.sigstore.dev and tuf-repo-cdn.sigstore.dev, the last being the TUF root the cosign client refreshes — because keyless verification happens inside the admission call. Those are the only outbound destinations OLIVE introduces beyond the registries above, they apply to those pods rather than to the cluster, and they are needed only for that one switchable control — see Admission Control and Image Integrity.
To test chart-registry access without deploying anything, fetch and render the small hello-world chart OLIVE publishes for this purpose:
helm registry login registry.gitlab.com -u <user> -p <token>
helm template registry-test oci://registry.gitlab.com/olive6224315/helm-charts/charts/hello-world
Rendering the chart is the cheapest way to separate "the firewall or proxy blocks the registry" from "the credentials are wrong" from "the chart itself fails". Image-registry access is not covered by it — the first workload that starts is what proves that, and a failure there appears as ImagePullBackOff. See Registries and Repositories.
Application-level egress control
The network policies are deliberately redundant with a control inside the services. OLIVE is a connectivity platform: by design, the Data Orchestrator invokes URLs a user configures. A shared egress guard in every outbound HTTP path rejects requests to internal address ranges, Kubernetes-internal service names and link-local metadata addresses before the request is made, and emits OLIFETCH1 when it does.
A network policy stops the packet; the application check stops the attempt and tells you it happened. Either alone would be a single point of failure — a policy may be disabled in a given deployment, and application logic can have bugs.
The guard restricts internal reach only. Calls to public internet destinations are not blocked by it — what limits those is the network policy layer, where only the services that need internet egress have it at all.
The block on internal addresses is not absolute: the platform reaches the internal addresses it needs by registering them, and a platform administrator can in principle register a further one. There is no public API for this and the mechanism may change, so it is not documented as a pattern. A connectivity engineer who genuinely needs it raises the case with their platform administrator, who contacts OLIVE support at olive-support@boc-group.com.
Service mesh
If a mesh is installed, the network path changes and the policies change with it. Ambient mode tunnels traffic between meshed workloads over HBONE on TCP 15008, and kubelet probes arrive SNATed to 169.254.7.127/32. Sidecar mode instead requires every pod's proxy to reach istiod on 15012.
The two need opposite policy changes, which is why global.serviceMesh.mode must match what is actually installed. See Service Mesh and mTLS.
Troubleshooting connectivity
A default-deny CNI usually drops rather than refuses, so the symptom is a timeout, not a connection error.
kubectl -n <namespace> get networkpolicy
kubectl -n <namespace> describe networkpolicy <name>
kubectl -n <traefik-namespace> get pods -l <ingressController.podLabels>
| Symptom | Likely cause |
|---|---|
| Nothing reachable from outside right after enabling policies | ingressController selector matches no pods — often the RKE2 default on a cluster with a separately installed Traefik |
| A login loop, or all requests returning 401 | The JWKS fetch is dropped — either keycloakIpBlocks pins a load-balancer address that has changed, or Keycloak is behind an internal load balancer whose private range the default carves out |
| Telemetry stops, no other symptom | Observability ports do not match the collector's Service |
| Probes fail after enabling ambient | Health-probe CIDR not allowed, or serviceMesh.mode not set to ambient |
| A datapoint to an on-prem system times out | Destination falls inside the non-routable carve-out; add an explicit extraEgress ipBlock |
A datapoint to an internal address is refused immediately, with OLIFETCH1 in the log | The application egress guard blocked it — this is working as intended |
Related
- Troubleshooting — failure modes by symptom across the whole deployment
- Security → Security Capabilities
- Security → Service Mesh and mTLS
- Ingress Requirements