Skip to content
Noite
Esc
↑↓navigate↵open⌘Jpreview
On this page

Known limits

What Noite's alpha does not do yet — tenant isolation depth, custom domain ownership, resource containment, and the restart cost of an upgrade.

Noite is alpha and self-hosted: you run it, so you decide who gets an account. These are the gaps that matter for that decision. Each one is on the roadmap; none is a surprise to the maintainers. To report a vulnerability, see the security policy.

Tenant isolation

Under NOITE_TENANCY=multi (Tenancy) tenant code runs as unprivileged users, with a cleared environment and an egress policy. Builds and release commands run as one uid per app, so two concurrent builds cannot read each other’s worktrees or caches. That is still a sandbox for semi-trusted tenants, not for adversaries:

  • Bucket keys in fleets. A fleet’s celld process holds scoped keys for its own prefix only — except on stores with no prefix-scoped keys (R2) or without the extra NOITE_CREDENTIAL_PROVIDER=aws configuration (AWS S3), where fleets keep the object store’s root keys as an explicit root mode the boot log, /ready and make doctor all name.
  • Object store reachable from Worker code and builds. The store’s unauthenticated surface (it answers 401/403) is the one private address tenants may reach, because celld and the release command’s scoped key need it. Builds hold no keys.
  • Per-app memory caps. Each tenant fleet runs in its own cgroup with its own memory.max (RUNNER_FLEET_MEMORY_MB, overridable per app in Settings → Limits), so one app’s growth hits its own limit instead of pushing every app toward the same shed threshold. Swap is disabled per leaf, so a capped fleet is OOM-killed rather than swapped out; a host /noite.swap (created by the installer under 4 GB) is a safety net for the resident services, not a fleet budget. An OOM kill restarts the fleet and records a tenant-visible fleet event and fleet log line. It needs the multi-only cgroup grant (docker/compose.multi.yaml); without it fleets share the container cgroup and multi stays at 503.
  • A build has its own capped cgroup. Install, build and release steps run in a build leaf with memory.max (RUNNER_BUILD_MEMORY_MB; unset derives the detected memory minus a 1 GiB resident floor, split across build slots, clamped 512–4096 MiB), a bounded memory.swap.max (RUNNER_BUILD_SWAP_MB; unset derives the host’s swap across the build slots), memory.oom.group, a hard cpu.max of one core less than the box split across the build slots, and a low cpu.weight/io.weight. The RAM cap keeps the runner, fleets and Caddy resident; a build larger than the box’s spare RAM swaps the overflow, so the ~1.3–1.5 GiB Vite 8/Rolldown build of a Void app completes on a small box (slowly) instead of dying at the cap. A step that fills RAM and swap is killed alone — the others keep serving — and the deploy log names both budgets. Fleet leaves keep zero swap, so a capped fleet still grows past its budget into host swap; the installer’s /noite.swap only protects the resident services.
  • No container per build. Depth is uid, environment, resource limits and egress rules. Rootless containers or gVisor are not planned unless tenants are expected to be hostile.
  • Void Sandboxes (void/sandbox) run through a platform controller. An app using them gets a runner-owned noite-void-sandbox script cohosted in its fleet (Void sandboxes): one fleet’s sandboxes are unreachable from any other fleet or the public internet, and previews get their own controller. Each fleet admits at most NOITE_VOID_SANDBOX_MAX_CONCURRENT live sandboxes (default 4), and aborting an exec’s signal sends SIGKILL to the process, as on Workers. Custom sandbox images must carry the sandbox shim (/usr/local/bin/sandbox-shim) — base them on a shim-carrying image or file operations fail at container start.
  • Sandbox containers share the host kernel. Apps on the agent template run tools in celld containers classes on the install’s engine. Only the runner holds the host engine socket — each fleet gets a filtered per-fleet socket, cross-app sandbox dials are refused, and deploys may only reference registry images or Dockerfiles that run nothing (no RUN, base images vetted for ONBUILD and pinned by digest; no per-class runtime). But the containers run under runc, which shares the host kernel; gVisor support for Sandbox containers is on the roadmap. Pulled images are never garbage-collected either, so engine disk grows with every new image. NOITE_SANDBOX=0 turns the whole plane off (Tenancy).
  • Workers caches is per-fleet, in memory. caches.default is shared by every script of the fleet’s deployment (CELLD_CACHE_SCOPE=deployment), like a Cloudflare zone, and lives in the fleet process’s memory (64 MiB default cap), not on an edge network. Noite fleets are single-node, so entries are coherent per fleet; Void ISR serves L1 from caches.default with KV behind it, and revalidate() purges both.

The remaining gaps are tracked here: Noite roadmap board (the “harden multi-tenant mode” item is still a draft).

If a tenant is not someone you would give shell access to a shared server, do not give them a push key yet.

Custom domains

Adding a hostname claims it for the app, and the claim stays pending until ownership is proven: publish the TXT record the panel shows (_noite-challenge.<hostname>) and press Verify. Only a verified hostname routes, resolves and gets a certificate (issued on demand on the first visit). Several apps may hold a pending claim for one hostname, but the first to verify wins: a hostname another app already verified answers 409, and verifying drops rival pending claims. Under single tenancy the one operator owns the DNS, so claims are born verified by design.

Platforms

  • Railway does not grant NET_ADMIN, so the egress policy cannot run there: use NOITE_TENANCY=single and invite nobody to push code (Platforms).
  • Coolify passes TLS through to Noite, so per-visitor rate limits are off; per-app ceilings still work.

Operations

  • Upgrades restart every app. A new image restarts the runner, and every tenant fleet cold-boots with it. There is no rolling upgrade, but the window is short: measured on a 32-core host with 1, 5 and 15 apps, every app was serving again within 5.1 s of the new container starting (the fastest fleet in ~2.1 s), because the runner starts every fleet before it deploys the control UI and the fleets boot in parallel. The edge holds a visitor’s request for up to 20 s and answers it when the fleet is up, so the wait is a slow response rather than an error; the installer warns and asks before recreating a changed image. Batch them and run them off-peak anyway (Operations).
  • Downgrades across a schema change are refused. The runner and control databases carry a schema version; an older image will not start on newer data. Back up before upgrading (Operations).
  • Snapshot loss window. The runner’s SQLite is snapshotted to the bucket within about 22 s of changes settling, so a lost volume loses at most that much recent state, as long as uploads succeed. While uploads fail (store unreachable, credentials refused), every change since the last successful upload is at risk. /ready and make doctor report the seconds since the last upload and the last upload error, so watch those.
  • Telemetry recovery is bounded by retention. Metrics, logs and errors are rebuilt from bucket Parquet: a failed ingest pass now holds its watermark and catches up hour by hour, and a window can be replayed by hand. Nothing older than RUNNER_TELEMETRY_RETENTION_DAYS (30 days by default) can be recovered — celld has pruned it (Telemetry).
  • One node. The control UI and the runner restart together and nothing fails over; availability is that of the one container and its bucket.
  • RustFS is qualified by Noite, not by celld. The bundled RustFS 1.0.5 passes celld’s startup check and Noite’s contract qualification, so it stays the zero-config default for single-host installs. For multi-host production, use a store celld qualifies: S3, R2, GCS, Tigris or Azure Blob (Storage).
  • Bundled SQLite carries a known advisory. libsqlite3-sys RUSTSEC-2026-0459 / CVE-2026-119375: SQLite before 3.54.0 can return uninitialized page-cache memory when opening a database alongside a crafted -wal with a mismatched page size. Accepted on record: the runner opens only its own databases and restores snapshots only from runner/state/, which scoped fleet keys cannot write — and under the documented root-credential mode (R2) fleets already hold full store trust, so no less-trusted party can hand the runner a crafted pair. Lifted when sqlx releases on libsqlite3-sys ≥ 0.39.

Was this page helpful?