NewCompare CPU & GPU pricing across AWS, Azure & GCP
Self-hosted sandboxes

Trust and data disclosure

What the DevZero control plane can do inside your cluster, what caps it, what it can never do, and exactly which data leaves the cluster.

Trust and data disclosure

DevZero's control plane configures sandboxes in your cluster. That gives it real reach, and you should know how much before you enable the feature. This page lists it without softening.

How configuration reaches your cluster

DevZero never connects into your cluster. The DevZero workload operator already running there keeps an outbound connection to DevZero. Sandbox configuration travels down that connection as Kubernetes objects in the sandbox.devzero.io API group (policies, guardrails, the endpoint configuration, sandbox requests, token keys). The workload operator applies them; the sandbox operator turns them into pods, network policies and RBAC. Status travels back up the same connection.

To create a sandbox for an API caller, DevZero sends a sandbox request. The sandbox operator in your cluster, not DevZero, creates the sandbox claim from it. Sandbox output, files and terminal traffic never travel over this connection.

Guardrails cap mistakes, not DevZero

SandboxClusterGuardrails is a cluster-wide ceiling over every sandbox policy: which registries, runtimes, namespaces, Secrets, service accounts, resources and lifetimes any policy may use. A team Admin sets it in DevZero, and DevZero applies it to the cluster the same way it applies policies.

Because DevZero delivers the guardrails as well as the policies, guardrails protect you from a mistaken policy, not from DevZero itself. A compromised or coerced DevZero control plane could widen the guardrails along with a policy. The rows marked holds against DevZero below are enforced by code, RBAC or objects in your cluster that DevZero cannot change, and do not depend on guardrails.

If someone edits the guardrails object directly in the cluster, the sandbox operator enforces the edited version until DevZero's next push overwrites it.

What the control plane can do in your cluster

The DevZero control plane can…ThroughCapped by
run any image in a sandbox namespace on the sandbox runtimethe policy's image settingsthe guardrails registry list (allowedRegistries); the pod admission webhook re-checks every container
give users, groups or service accounts admin rights (connect, delete, pods/exec) over a policy's sandboxesthe policy's access.adminSubjects, rendered as an admin Rolethe guardrails list access.allowedAdminSubjects (an explicit list; empty means none). Groups such as system:authenticated, system:unauthenticated, system:serviceaccounts and system:masters are always refused. Holds against DevZero.
expose a Secret in a sandbox namespace to sandboxesthe policy's envFromthe guardrails Secret selector, and the Secret must carry your annotation sandbox.devzero.io/exposable-to naming the policy. Neither DevZero operator can write that annotation. Holds against DevZero. No other Secret can be mounted.
let sandboxes reach Services in your clusterthe policy's network.egress.allowClusterServicesthe guardrails list allowedClusterServiceNamespaces
let in-cluster service accounts create and connect to sandboxesthe policy's access.serviceAccounts, rendered as RoleBindingsthe guardrails list access.allowedServiceAccountNamespaces
choose which namespaces hold sandboxesthe policy's namespacethe guardrails list managedNamespaces (exact names by default). An existing namespace is adopted only if you labelled it sandbox.devzero.io/managed=true and it holds no pods other than sandboxes. Holds against DevZero.
choose the runtimethe policy's runtimethe guardrails list allowedRuntimeClasses. The RuntimeClass's handler must be runsc (gVisor) or kata*. The one exception is a class your guardrails name exactly: naming a plain runc class there lets a policy use it, which removes the sandbox boundary, so name only sandboxing classes.
set resource ceilings and lifetimesthe policy's resources and lifecyclethe guardrails maxResources and maxTTL
route sandbox traffic through DevZero's edgethe endpoint configuration (mode: relay, Phase 3)the guardrail endpoint.allowRelay (off by default). Even then the edge forwards encrypted bytes and cannot read them.
hold the TLS private key for your sandbox endpointnoneNever. The key is generated in your cluster in every mode; at most a certificate signing request goes to DevZero. Holds against DevZero. The guardrail endpoint.allowPublicVisibility caps exposure.
issue tokens the sandbox gateway acceptsthe public token-signing keys (a signed key set) it sends to the clusterthese keys are for the gateway only. The credential the gateway uses to reach each sandbox process is derived per pod and never leaves the cluster.
create and delete sandboxessandbox requests (the sandbox operator creates the claim)the policy's limits.maxSandboxes, any quota, and the NetworkPolicy canary
read sandbox output or filesnoneNever. The connection to DevZero carries only sandbox.devzero.io objects down and their status up. No DevZero component is in the data path except as an encrypted passthrough in relay mode.

What the control plane cannot do, even if compromised

  • create pods outside sandbox namespaces;
  • adopt an existing namespace you have not labelled sandbox.devzero.io/managed=true;
  • expose a Secret you have not annotated sandbox.devzero.io/exposable-to for that policy;
  • give system:*-style groups admin rights over sandboxes;
  • write anything outside the sandbox.devzero.io API group, or anything inside a sandbox namespace, through the workload operator;
  • obtain the private key of your sandbox endpoint;
  • decrypt sandbox traffic.

It can change the guardrails, and with them widen the registry list, turn on relay, and raise the other ceilings.

What leaves the cluster

This table replaces any slogan you may have read about sandbox data. "Managed" and "relay" are the Phase 2 and Phase 3 endpoint modes; Phase 1 ships "BYO". See Exposure modes.

CategoryManaged and BYO endpointsRelay
Sandbox bytes (stdout, files, ports)nevertransit DevZero's edge encrypted end to end (TLS passthrough); never stored, never decrypted
Metadata sent to the control planesandbox and claim phases and reasons, pod IP, image reference, environment variable names, byte counts, team and user IDs, a keyed hash of each command line (or the command line itself if you turn on audit.recordCommands)same
Keysnone. The endpoint private key is generated in your cluster in every mode (managed mode sends only a certificate signing request); in managed mode DevZero controls only the DNS namenone (the edge holds no certificate for your cluster)
DNSmanaged: the load balancer address (possibly a private address) is published in public DNSsame

Environment variable values, Secret contents, file contents and process output are not sent.

Availability

Running sandboxes and sessions continue until their shutdownTime without DevZero; new external sandboxes, extensions, and tokens need DevZero; in-cluster creation does not.

On this page