celld-operator
celld v0.6.2Alpha · tracks upstream release-for-release→

Durable Objects on your own Kubernetes.

celld-operator runs Cloudflare Workers and Durable Objects on your cluster with celld, and supplies everything celld deliberately leaves out: fleet provisioning, ingress, gated rollouts, autoscaling, and guardrails. One custom resource, one operated fleet.

$ helm install celld-operator \
    oci://ghcr.io/ezgamehost/charts/celld-operator
Works with
  • Gateway API
  • Istio
  • ingress-nginx
  • KEDA
  • Prometheus
  • cert-manager
  • Amazon S3
  • Cloudflare R2
  • Google Cloud Storage
  • Azure Blob Storage
Why celld-operator

Stateless self-hosted Workers already exist. This is the stateful part.

workerd gives you self-hosted stateless Workers. celld adds distributed, durable Durable Objects: your agents, rooms, documents, and tenants as named stateful cells, backed by an object-storage bucket you own. The operator makes a fleet of them a single Kubernetes resource.

1 → 9
one WorkerApp reconciles up to nine Kubernetes objects
RPO 0
no write is acknowledged before it survives a failure
3
store dialects: s3://, gs://, az://
4
ingress modes: Gateway API, Istio, Ingress, or none
How it works

Nodes coordinate through a bucket. The operator does the rest.

celld nodes share one object-storage bucket (deployments, per-cell SQLite data, ownership records, leases) with no consensus service; a conditional write decides which node owns a cell. The operator turns one WorkerApp into one fleet on a bucket prefix: routed through your edge, fenced by network policy, scaled on cell utilization, and rolled out one pod at a time behind a fleet-wide restoring=0 gate. Read the architecture →

namespace: tenant-acme Gateway TLS · shared edge HTTPRoute Service :8080 NetworkPolicy · PDB chat-celld-0 chat-celld-1 chat-celld-2 peer :8081 peer :8081 object store s3://cells/apps/chat cells · deploys · leases celld-operator control plane reconciles · gates rollouts · polls /state
One resource

Declare the app. Get the whole fleet.

Hostnames, the expected deployment, the bucket, sizing, and scaling targets. The operator validates the spec against your allowlists, then reconciles every object below and wires them together: traffic flows from the route to the serving Service to the pods, peers find each other through the headless Service, the ServiceAccount carries the bucket identity, and every policy selects the same pods. Status reports fleet health, per-pod deployment versions, and rollout progress. What each object does →

WorkerApp tenant-acme/chat reconciles and owns ownerReferences → WorkerApp chat HTTPRoute parentRef infra/edge Service chat-celld :8080 backend Service headless chat-celld-internal :8081 StatefulSet chat-celld pod chat-celld-0 pod chat-celld-1 pod chat-celld-2 partition owned by the gated rollout controller selects all pods peer DNS all pods serviceName ScaledObject KEDA scales ServiceAccount chat-celld runs as bucket …/apps/chat IRSA / workload identity NetworkPolicy :8081 fleet + operator AuthorizationPolicy Istio · :8081 principals PodDisruptionBudget maxUnavailable: 1 select fleet pods traffic or reference selects / applies to created when enabled
Features

The control plane celld deliberately ships without

celld supplies the runtime and the data plane; the operator supplies the platform. Upstream stays unpatched: the operator talks to celld through environment variables, signals, a health path, and the internal /state endpoint.

Gated rollouts

One pod at a time, stepping only when every pod is Ready and the whole fleet reports restoring=0. Breaking celld upgrades are refused unless the resource asks for a Recreate.

How the gate works →

Cell-aware autoscaling

CPU is the wrong signal. The operator exports resident-cell utilization and shedding from each pod's /state and drives KEDA on complete, fresh samples only: up early, down slowly, never mid-rollout.

Scaling policy →

Ingress your way

Gateway API HTTPRoutes on a shared Gateway, classic Istio VirtualServices, or plain Ingress with cert-manager TLS. Readiness means the Gateway accepted and programmed the route, not just that it exists.

Networking →

Guardrails by default

Allowlists for images, IAM roles, Azure identities, and bucket endpoints. Non-root, read-only pods. The unauthenticated internal listener is fenced by NetworkPolicy and never routed.

Security model →

Deploys that verify

celld adopts new deployments in place. Pin appVersion in git or follow the bucket with auto; either way the app is Ready only when every pod reports serving the expected version.

Deploying updates →

Telemetry in your bucket

Parquet traces and logs under the fleet's own prefix, queryable with DuckDB and nothing to run, or OTLP to your collector. W3C traceparent joins edge spans to Durable Object spans.

Observability →
Gated rollout

Rollouts that wait for the fleet, not just the pod.

When a node drains, its cells restore on the peers, which a stock rolling update cannot see. The operator owns the StatefulSet partition and releases one ordinal only when every gate passes:

  1. Pause the autoscalerKEDA must acknowledge Paused=True, and no HPA may target the fleet.
  2. Check the version boundaryNon-rolling celld changes are refused unless updateStrategy: Recreate.
  3. Release one podLower the partition by one, then hold a 10-second settle interval.
  4. Wait for the fleetEvery pod Ready and answering /state, fleet-wide restoring=0. Then the next pod.
Encoded, not documented

Rules you cannot get wrong

celld has precise operational requirements. Most platforms put them in a runbook; this operator puts them in the reconciler, and there are no templates to drift.

  • Liveness is TCP only. celld's health path answers 503 during a graceful drain; an HTTP liveness probe there would kill nodes mid-handoff.
  • 60 seconds of grace around a 40-second shutdown bound, so the kubelet does not SIGKILL a node that is still handing off.
  • CELLD_MAX_RSS_MB is explicit at 80% of the memory limit, visible in the pod spec and under celld's absolute cap.
  • The internal listener stays internal. Port 8081 admits only fleet pods and the operator's manager pods, and is never routed.
  • Durability is guarded. fleet durability requires persistent volumes, three replicas, and pods on distinct hosts.
  • Downgrades that could lose writes are blocked, even with Recreate.
Built on celld

The runtime underneath

celld is Deno Land's open-source (Apache-2.0) daemon that embeds V8 and runs Wrangler-built Workers. Your build is unchanged: esbuild, wrangler.jsonc, celld deploy.

  • RPO=0. A write is acknowledged only once it is in the bucket, or on follower disks with fleet durability.
  • One writer per cell. Conditional writes fence ownership, with no consensus service or membership protocol.
  • Cheap density. One 8 GB node holds about 1,000 resident cells; inactive cells are just objects in the bucket.
  • Workers
  • Durable Objects
  • KV
  • Queues
  • D1
  • Workflows
  • R2
  • Cron Triggers
  • Static assets
  • Workers AI
  • Vectorize
  • Hyperdrive

Full compatibility matrix →

Status

Alpha software, stated plainly

celld v0.6.2 is a beta release and this operator is alpha. The project publishes what it has verified and what it has not, so you can qualify it on your own platform before you trust it with data.

Read the production audit →

Verified in the repository

Unit and envtest suites for malformed state, incomplete fleets, KEDA pause acknowledgement, Recreate, deployment convergence, and credential isolation; Helm rendering tests; a Kind lifecycle suite; module and image vulnerability scans.

Yours to qualify

Real host and zone loss under acknowledged writes, cloud workload identity, CNI and mesh enforcement, KEDA and Prometheus outages, and production-scale load, on the platform you intend to run.

Run your first fleet

Install the operator, deploy a Wrangler project to your bucket, and create a WorkerApp. The operator converges the rest.