celld-operator

Security

An honest isolation story, stated plainly: this is a platform for your applications, or your customers' applications under your operation, not for anonymous hostile code. celld's own security page says it is not safe for hostile multi-tenant use; the operator's design takes that seriously instead of papering over it.

The isolation model

celld trusts the application code, the fleet nodes, and the operators, so the design assumes the worst case: a V8 isolate escape hands an attacker the entire node process. The operator's answer is fleet-per-app blast-radius containment:

Two limits belong next to that claim. Within a fleet there is no per-cell resource quota: application code can consume its nodes' shared resources, so a runaway cell starves its neighbours in the same app. And kernel-level separation needs dedicated nodes: pin fleets with spec.scheduling.nodeSelector and tolerations.

WorkerApp authors are trusted

Anyone who can create a WorkerApp can run code and reference Secrets in that namespace. The operator does not turn them into untrusted tenants; it limits what they can point a fleet at. Restrict WorkerApp RBAC per namespace, and configure the operator's allowlists:

Helm valueDefaultEffect
operator.allowedImagePrefixes["ghcr.io/denoland/celld:"]Runtime images must start with an allowed prefix and carry a numeric major.minor.patch tag, even when digest-pinned. Add trusted mirrors explicitly.
operator.allowedIAMRolesemptyExact role ARNs a WorkerApp may name in credentialsFrom.iamRole.
operator.allowedAzureClientIDsemptyExact client IDs allowed in credentialsFrom.azureClientID.
operator.allowedBucketEndpointsemptyExact HTTPS endpoints allowed in bucket.endpoint (no credentials, query, or fragment). Empty permits AWS S3 only.

A WorkerApp outside the allowlists reports SpecValid: False and nothing is created for it. Image allowlists decide which runtime runs; they do not sandbox the Worker code it runs.

Pod hardening

Fleet pods run as UID/GID 10001 with a read-only root filesystem, only /tmp and /var/lib/celld writable, every capability dropped, privilege escalation disabled, and the RuntimeDefault seccomp profile. No service-account token is mounted by default, though identity webhooks (IRSA, AKS workload identity) may inject purpose-specific tokens. Qualify your celld image, CSI driver permissions, and identity injector against that profile.

The internal listener

celld's internal listener, which the operator pins to :8081, carries the peer protocol and an alpha operator API whose routes do not authenticate the caller: /state, /cell/, /evict/, /do/, POST /reload, and POST /shutdown. /cell/ and /do/ activate cells and run application code, so reaching the port means state mutation, not just inspection. Reserved runtime classes (D1, KV, Queues, Workflows) use the HMAC-authenticated /runtime/<SCOPE> route instead. The operator fences the port in depth:

Peer tunnels and control requests carry celld's fleet HMAC, a clock limit, and replay protection, but the calls inside a tunnel are plain HTTP and nothing is encrypted. The operator neither installs nor requires a mesh; without one it reports MeshPolicyReady: False. Verify that your CNI enforces NetworkPolicy, and encrypt the pod network: prefer Istio ambient mode, since a sidecar exiting first would break the handoff celld performs during termination.

Bucket credentials

The bucket credential is fleet-admin authority. The bucket holds deployments, cell state, ownership and node leases, and the peer-authentication secret; whoever holds the credential controls the fleet. Credential scoping is the tenancy enforcement.

Grant put and delete under the prefix (the startup probe writes and removes an object under probe/). The separate deployTrackingSecretRef for appVersion: auto should be read-only on deploy/current.json; the operator never uses its own ambient identity to read a bucket, and reads Secrets uncached rather than holding them in an informer.

TLS and application auth

Trust boundaries at a glance

BoundaryMechanism
Internet → WorkerEdge TLS + per-host routing; app-level auth in the Worker
Tenant ↔ tenantNamespaces, NetworkPolicy, per-fleet credentials; node pools via spec.scheduling
WorkerApp author → clusterNamespace RBAC plus operator allowlists for images, identities, and endpoints
Anything → operator API (:8081)NetworkPolicy + AuthorizationPolicy; never routed
Node ↔ nodecelld HMAC, clock limit, replay protection; encryption from your mesh or CNI
Fleet → bucketOne prefix-scoped identity per fleet
Operator → fleetsManager pods selected by label in the operator namespace; narrowed to the operator's principal where Istio enforces

Support and disclosure

Upstream ships security fixes for the latest celld release only; the operator's support policy mirrors it: current celld, current operator. Report operator vulnerabilities per the repository's SECURITY.md; report celld issues upstream at denoland/celld.

Edit this page on GitHubUpdated 2026-10-18