API reference
All endpoints are mounted at /v1/modules/scaibunker/ and authenticate with the standard ScaiGrid bearer token. Responses use ScaiGrid's standard envelope: { "status": "success", "data": ..., "meta": { "request_id", "timestamp" } } for success and { "status": "error", "error": { "code", "message", "details"? }, "meta": { "request_id" } } for failures. A request body the framework can't parse at all gets 422 with { "detail": ... }. List endpoints return { "data": { "items": [...] }, "pagination": { "has_more": bool, "next_cursor": "..." } }; pass next_cursor back as cursor. The usage feed GET /usage is the exception: its cursor is inside data.
Bunkers#
POST /bunkers#
Create a bunker. Requires scaibunker:create.
| Field | Required | Notes |
|---|---|---|
image |
yes, unless snapshot_id |
Image name; e.g. python-3.12. |
snapshot_id |
no | Restore this snapshot into the new bunker. The bunker gets the snapshot's image; cpu_millicores, memory_mb and disk_mb are those of the snapshot's source bunker (leave them out), and network_profile defaults to the source's. ScaiGrid places the bunker on a worker whose CPU can run the snapshot, normally the one it was taken on; if none fits, the bunker ends failed. |
lifecycle_mode |
no | ephemeral (default), session, persistent. |
name |
no | Human-readable label. |
network_profile |
no | isolated (default), registry, allowlisted, unrestricted, transit. |
network_allowlist |
when allowlisted |
Hostnames or first-level wildcards, optionally with a TCP port (github.com:22). An entry without a port allows 80 and 443. |
cpu_millicores |
no | Default 1000. |
memory_mb |
no | Default 512. |
disk_mb |
no | Default 1024. |
gpu_count, gpu_type |
no | Default 0 / null. gpu_count > 0 needs scaibunker:create:gpu and a worker with that many free GPUs; gpu_type (e.g. rtx-4090, case-insensitive) restricts it to that model. Bunkers without GPUs are kept off GPU workers while another worker fits. |
max_lifetime_s, idle_timeout_s |
no | Positive seconds; lifecycle-dependent defaults. max_lifetime_s is at most 86400 (24 h) for ephemeral and 259200 (72 h) for session; persistent has no ceiling. |
session_type, session_ref |
no | standalone (default), scaicore, scaiwave, api. |
label_set |
no | Worker selector, not a tag: the bunker only goes to a worker whose labels include every pair. A pair no worker carries returns 422 NO_WORKER_WITH_LABELS. Use name to tell bunkers apart. |
env_vars |
no | Map injected into the bunker's environment. Never returned by the API, and deleted when the bunker ends. |
interfaces |
when transit |
List of {if_name, bridge_name, spoof_guard, mac}. |
bandwidth_mbit |
no | Per-bunker egress cap (1–10000). |
user |
no | Default user for exec, the shell and file calls: a name from the image's /etc/passwd, a uid or uid:gid. Without it the bunker runs as root if you hold scaibunker:root, otherwise as bunker (1000:1000 where the image has no such user, with /workspace as home). A root user needs scaibunker:root. Returned as user (null = root). |
Returns the bunker record. Status starts at pending, advances through provisioning to running. With snapshot_id, the bunker reaches running only after its files are restored; a restore that fails leaves it failed.
A bunker that ends failed says why in failure_code and failure_message (both null otherwise). Codes include GPU_SETUP_FAILED (the GPU driver didn't load in the bunker), WORKER_UNAVAILABLE (no worker had room), WORKER_LOST (its worker stopped responding), WORKER_RETIRED (its worker was retired and no snapshot could move it) and WORKER_ERROR (any other worker failure). A failed bunker holds no quota.
The record's ipv6 says whether the bunker has IPv6 egress as well as IPv4: true for a registry, allowlisted or unrestricted bunker on a worker that offers IPv6, false otherwise, and null for bunkers created before 17 November 2026. See Network profiles.
The record's image_version is the image version the bunker runs (e.g. scaibunker-platform/python-3.12:1.20261016.0), or null when unknown. A restored bunker runs its snapshot's version, which may be older than the image's current one.
GPU bunkers get whole GPUs passed through, with the NVIDIA driver supplied by ScaiBunker (nvidia-smi and the CUDA driver libraries are in /usr/local/nvidia; images bring their own CUDA runtime). The driver needs a glibc-based image, so Alpine images such as minimal can't use the GPU. GPU bunkers can be paused and resumed, but not snapshotted (see below).
Errors for user: 403 BUNKER_PERMISSION_DENIED (root without scaibunker:root), 422 INVALID_USER (not a name, uid or uid:gid), 422 USER_NOT_FOUND (no such user in the image).
Errors specific to GPUs: 403 AUTHZ_PERMISSION_DENIED (no scaibunker:create:gpu), 409 SNAPSHOT_NOT_SUPPORTED (snapshot_id together with gpu_count), 422 IMAGE_REQUIRES_GPU (the image is marked gpu_required and gpu_count is 0), 503 WORKER_UNAVAILABLE (no worker has the GPUs free; also when the chosen worker turns out to be full and no other fits, in which case the bunker record is kept as failed).
Errors specific to snapshot_id: 409 SNAPSHOT_NOT_RESTORABLE (snapshot not in object storage or not ready), 409 SNAPSHOT_IMAGE_MISMATCH (image names a different image), 409 SNAPSHOT_PROFILE_MISMATCH (a networked snapshot into an isolated bunker or the other way round, or a transit snapshot with different interfaces), 422 SNAPSHOT_RESOURCES_MISMATCH (cpu_millicores, memory_mb or disk_mb differ from the source bunker's).
GET /bunkers#
List bunkers in the caller's tenant. Admins (scaibunker:admin) see across tenants. Query parameters: limit, cursor, status, lifecycle.
GET /bunkers/{bunker_id}#
Fetch one bunker.
DELETE /bunkers/{bunker_id}#
Terminate. Query parameter snapshot=true takes a final snapshot before destroy (409 SNAPSHOT_NOT_SUPPORTED for a GPU bunker). Decrements quota counters across every bucket the bunker contributed to.
POST /bunkers/{bunker_id}/pause#
Suspend the microVM in place. State preserved; quota still held.
POST /bunkers/{bunker_id}/resume#
Resume a paused bunker. Bunkers paused for being idle are resumed only by this call, not by the next exec.
POST /bunkers/{bunker_id}/snapshot#
Take a snapshot of the running bunker's rootfs. Returns the updated bunker record with snapshot_id populated. GPU bunkers can't be snapshotted, because the GPU's state can't be saved: 409 SNAPSHOT_NOT_SUPPORTED. Persistent GPU bunkers get no automatic checkpoints either, so they don't come back after a worker is retired.
Execution#
POST /bunkers/{bunker_id}/exec#
Run a command. Requires scaibunker:execute. Body:
| Field | Notes |
|---|---|
command |
The shell command to run. |
timeout_s |
Default 60. |
working_dir |
Default /workspace. |
env |
Optional environment overrides. |
stdin |
Optional string piped to the command's stdin. |
user |
Optional user for this command (name, uid or uid:gid); default the bunker's user. Root needs scaibunker:root. Without that permission, a command on a bunker that runs as root runs as bunker, and any user that is uid 0 in the image (such as a toor alias) is refused with 403 ROOT_REFUSED; a streamed exec reports that as an error event. |
stream |
If true, response is Server-Sent Events. Errors arrive as an error event inside a 200 stream (for example BUNKER_NOT_RUNNING), followed by data: [DONE]. While the command prints nothing, a : keepalive comment is sent every 15 seconds. |
Inline mode returns { exec_id, exit_code, stdout, stderr, duration_ms, full_output_available }. stdout and stderr are cut at 1 MiB each. When full_output_available is true, the whole output was saved: fetch it with GET /bunkers/{bunker_id}/exec/{exec_id}/output.
Streaming events:
| Event | Payload |
|---|---|
stdout |
{ "text": "..." } |
stderr |
{ "text": "..." } |
exit |
{ "exit_code": 0, "duration_ms": 1234, "exec_id": "…", "full_output_available": false } |
error |
{ "code": "EXEC_ERROR", "message": "..." } |
WebSocket /bunkers/{bunker_id}/shell#
Interactive PTY shell on a running bunker. Requires scaibunker:shell.
Auth: an API key or token, as Authorization: Bearer …, as the sub-protocol bearer.<token> (new WebSocket(url, ["bearer." + token]) in a browser; keeps the token out of URLs and logs), or as ?token=.
Frames:
| Direction | Frame | Meaning |
|---|---|---|
| client → server | binary (or plain text) | Keyboard input. |
| client → server | {"type": "resize", "cols": 120, "rows": 40} |
Terminal size (1–1000 each). Send it right after connecting. |
| client → server | {"type": "heartbeat"} |
Answered with {"type": "heartbeat"}. |
| client → server | {"type": "close"} |
End the session. |
| server → client | binary | Terminal output. |
| server → client | {"type": "exit", "exit_code": 0} |
The shell exited; the socket then closes with 1000. |
?user= picks the shell's user, with the same rules as exec user. A user that is uid 0 in the image is refused without scaibunker:root: the server sends {"type": "error", "code": "ROOT_REFUSED"} and closes.
One shell per bunker at a time. While it's open the bunker isn't idle-paused or checkpointed, and typing counts as activity. A shell with no traffic either way for 15 minutes is closed.
Close codes: 1000 session ended · 4401 missing or invalid token · 4403 no scaibunker:shell, or a root user without scaibunker:root · 4404 bunker not found · 4408 idle · 4409 a shell is already open, or the bunker isn't running · 4502 the bunker's worker can't be reached or went away.
Sessions are audited (shell_open / shell_close in the bunker's exec log, with duration, exit code and byte counts). What is typed and shown is not recorded.
Files#
All file endpoints require scaibunker:files and operate against running bunkers. Every file call (read, write, listing, delete, commit) runs inside the bunker as a user, and the bunker's own permissions decide: a path that user may not touch gets 403 FILE_PERMISSION_DENIED. Files a call creates belong to that user.
The user is the bunker's user unless you pass ?user= (a name, uid or uid:gid), with the same rules as exec user: root needs scaibunker:root; without it, a file call on a bunker that runs as root runs as bunker, and a user that is uid 0 in the image is refused (403 ROOT_REFUSED).
PUT /bunkers/{bunker_id}/files/{path:path}#
Write a file. Body is the raw bytes; Content-Type header is preserved.
GET /bunkers/{bunker_id}/files/{path:path}#
Read a file. Returns the raw bytes with a guessed media type.
Query parameter dir=true lists a directory instead, returning { entries: [{name, size, type, mtime, ...}] }.
DELETE /bunkers/{bunker_id}/files/{path:path}#
Remove a file.
GET /bunkers/{bunker_id}/exec/{exec_id}/output#
A download link for an exec's full output, when the exec returned full_output_available: true. Requires scaibunker:execute. Returns { download_url, expires_in_s }: a short-lived link (15 minutes), so treat it as a secret. Saved output is kept 30 days. 404 OUTPUT_NOT_FOUND when there is none or it has expired.
POST /bunkers/{bunker_id}/files/upload#
Start a staged upload (for files larger than ~10 MB). Body { "filename": "..." }. Returns { key, upload_url, method: "PUT", expires_in_s }. PUT the file's bytes to upload_url within expires_in_s (1 hour; the URL is a secret), then commit. Uncommitted uploads are deleted after a day. 503 WORKER_STORAGE_UNAVAILABLE if the bunker's worker has no upload storage.
POST /bunkers/{bunker_id}/files/commit#
Commit a staged upload. Body { "key": "...", "dest_path": "/workspace/..." }, with the key from the upload call. The worker copies the file into the bunker and the staged copy is deleted. Only keys from this bunker's own uploads are accepted: 404 UPLOAD_NOT_FOUND otherwise, or when nothing was uploaded under the key.
Snapshots#
Require scaibunker:create.
GET /bunkers/{bunker_id}/snapshots#
List snapshots for one bunker, paginated.
GET /snapshots/{snapshot_id}#
Fetch one snapshot's metadata: bunker_id, storage_path, size_bytes, size_mb, region, status, checksum, image_version (the image version a restore uses), trigger (manual for a requested snapshot, checkpoint for an automatic one of a persistent bunker), created_at, expires_at.
GET /snapshots/{snapshot_id}/archive#
Returns { "download_url": "...", "expires_in_s": 900 }: a short-lived link to the archive (tar.gz). Download it directly with a plain GET; no auth header is needed. Treat the link as a secret and request a fresh one when it expires.
GET /snapshots/{snapshot_id}/files/{path:path}#
Download one file from inside a snapshot without restoring the whole thing.
DELETE /snapshots/{snapshot_id}#
Delete a snapshot. Removes both the row and the S3 object.
Images#
GET /images#
List images visible to the caller (tenant-scoped + platform defaults). Requires scaibunker:create.
POST /images#
Register a new image. Requires scaibunker:images:manage. Body fields:
| Field | Notes |
|---|---|
name |
Unique within scope. |
build_source |
{kind: "oci", ref: "<image reference>"}, or {kind: "archive", size_bytes: <n>} to upload a docker save / OCI archive. ScaiBunker builds the image (pull or unpack, flatten, boot test without network, scan) before any worker sees it; see Register a custom image. A reference on a registry you stored a login for (POST /registry-credentials) is pulled with that login. Other kinds are refused with 422 IMAGE_SOURCE_UNSUPPORTED, except for platform images. |
size_mib |
Platform images only; a built image is sized to its content. |
display_name, description |
Optional metadata. |
default_cpu_millicores / default_memory_mb / default_disk_mb |
Applied when not overridden on bunker create. |
gpu_required |
bool. |
preinstalled |
List of package names for documentation. |
entrypoint |
Default /bin/bash. |
scope |
tenant (default); partner needs a partner admin, platform a super admin (403 otherwise). |
lazy_pull |
If true, scheduler may place on cold workers. |
The response carries build_status: queued, or for an archive build_status: uploading and an upload object (see below). Poll GET /images/{image_id}: build_status becomes building, then ready or failed (with build_error). Bunkers can't be created from it until it's ready (409 IMAGE_NOT_READY). A name already used in the same scope returns 409 IMAGE_NAME_CONFLICT.
For an archive, upload holds either method: "PUT" and a url (archives up to 5 GiB; valid 1 hour) or, above 5 GiB, multipart: {part_size, expires_in_s, parts: [{part_number, url}]} (valid 6 hours). Send the archive's bytes to the URL, or each part_size slice to its part URL, keeping each part's ETag response header. The upload must be completed within 24 hours (complete_by); after that the image fails and the upload is deleted. Archives can be up to 20 GiB.
GET /images/{image_id}/upload#
Fresh upload URL(s) for an image still in uploading, for when the first ones expired. Requires scaibunker:images:manage.
POST /images/{image_id}/upload/complete#
The archive is uploaded: ScaiBunker checks it is exactly size_bytes long and queues the build (build_status: queued). For a multipart upload, send {"parts": [{"part_number": 1, "etag": "…"}, …]}. Returns 409 IMAGE_UPLOAD_INVALID if nothing (or something of another size) was uploaded. The archive is deleted once the build ends. Requires scaibunker:images:manage.
GET /images/{image_id}#
Fetch one image you can see: your tenant's, your partner's, or a platform image. Others return 404 IMAGE_NOT_FOUND.
DELETE /images/{image_id}#
Deactivate. Soft-delete; existing bunkers keep running. The image is removed from worker caches on their next heartbeat (the disk is freed when the last bunker on it ends). Requires scaibunker:images:manage, and the image must be your tenant's; a partner image needs a partner admin, a platform image a super admin (403 otherwise). The same applies to scan, warm and the upload endpoints.
POST /images/{image_id}/scan#
Scan the image again. Images are scanned once on ingress and again when their content changes, so this is only needed after a scanner failure. Every image is scanned when it's built, so this re-records that build's scan. Requires scaibunker:images:manage.
POST /images/{image_id}/warm#
Force a fan-out warm to every targeting worker. Idempotent. Requires scaibunker:images:manage.
GET /images/{image_id}/cache#
Per-worker cache state for one image — used by the admin UI to show fan-out progress. Each row carries worker_id, status (pending, building, ready, failed, evicted), sha256, size_mib_actual, error, baked_at.
Registry credentials#
Logins for private registries, one per registry host per tenant. Only ScaiBunker's build service uses them, for your own builds; the password is stored encrypted and never returned. All endpoints require scaibunker:images:manage.
GET /registry-credentials#
List your tenant's credentials: id, host, username, last_used_at, created_at, updated_at.
POST /registry-credentials#
{"host": "ghcr.io", "username": "…", "password": "<token>"}. host is the registry as it appears in image references (ghcr.io, registry.example.com:5000); Docker Hub is docker.io. Use a read-only token where the registry offers one. A second credential for the same host returns 409 REGISTRY_CREDENTIAL_CONFLICT; update that one instead.
PATCH /registry-credentials/{credential_id}#
Change username and/or password.
DELETE /registry-credentials/{credential_id}#
Remove it. Builds already queued with it fail if they start afterwards.
Workers#
Admin-only (scaibunker:admin or scaibunker:admin:platform), except POST /heartbeat which uses the worker shared bearer.
GET /workers#
List worker nodes.
GET /workers/{worker_id}#
Fetch one worker's full record. runtimes lists the hypervisors it runs, for example [{"type": "firecracker", "version": "1.17.0", "gpu": false}, {"type": "cloud-hypervisor", "version": "53.0", "gpu": true}], or is null for workers that don't report them. GPU bunkers only go to workers with a gpu: true runtime when the list is reported. ipv6 is true when the worker gives new bunkers IPv6 egress.
GET /workers/{worker_id}/cache#
Heartbeat-derived cache ledger for one worker — what the controller thinks the worker has cached. Companion to GET /workers/{id}/images.
GET /workers/{worker_id}/images#
Live cache listing from the worker itself. Returns { items: [{name, sha256, size_mib, baked_at}], stale: bool, last_error: ... }. stale: true means the worker was unreachable; fall back to the ledger.
POST /workers/{worker_id}/drain#
Stop scheduling new bunkers to this worker. Active bunkers continue.
POST /workers/{worker_id}/retire#
Declare a worker gone for good. Only a worker that hasn't sent a heartbeat for 5 minutes can be retired; a live one returns 409 WORKER_STILL_ALIVE (drain it instead). A retired worker is never scheduled again, and its lost bunkers are recreated on other workers from their latest snapshot, under the same bunker id (see Architecture). If the worker comes back, it stays retired and the VMs it still runs for moved bunkers are destroyed.
POST /workers/{worker_id}/resume#
Reverse a drain or a retire.
POST /heartbeat#
Worker-only. Authenticated by SCAIBUNKER_WORKER_TOKEN. Body matches the WorkerHeartbeat schema (capacity, status, active bunkers, optionally a cached_images reconciliation list). The per-bunker statuses are how the controller takes back lost bunkers and destroys VMs it has already ended.
Bridges#
Admin-only for create/delete (scaibunker:admin or scaibunker:admin:platform).
POST /bridges#
Create a tenant-scoped Linux bridge on a worker. Body { worker_id, bridge_name, mtu? }. Two-phase: row reserved, worker called, row rolled back if the worker rejects.
GET /bridges#
List bridges in the caller's tenant.
GET /bridges/{bridge_id}#
Fetch one bridge.
DELETE /bridges/{bridge_id}#
Delete. Worker is called first; row is removed locally on success.
Availability groups#
GET /availability-groups#
List groups visible to the caller (tenant-scoped + platform defaults). Requires scaibunker:create.
POST /availability-groups#
Create a group. Tenant admins create within their own tenant; super-admins create platform defaults. Body { name, description }.
GET /availability-groups/{group_id}#
Fetch group with worker_ids[] and image_ids[].
DELETE /availability-groups/{group_id}#
Delete. Requires scaibunker:admin:tenant for tenant groups, scaibunker:admin:platform for platform defaults.
POST /availability-groups/{group_id}/workers#
Add a worker. Body { ref: worker_id }. Triggers a fan-out warm of every image in the group onto the joining worker.
DELETE /availability-groups/{group_id}/workers/{worker_id}#
Remove a worker from the group.
POST /availability-groups/{group_id}/images#
Add an image. Body { ref: image_id }. Triggers a fan-out warm of the image to every worker in the group.
DELETE /availability-groups/{group_id}/images/{image_id}#
Remove an image.
Quota profiles#
GET /quota-profiles#
List visible profiles (own tenant + platform defaults).
POST /quota-profiles#
Create. Tenant admins create tenant-scoped; super-admins create platform defaults. Body fields: name, description, max_concurrent_bunkers, max_persistent_bunkers, max_cpu_millicores, max_memory_mb, max_disk_mb, max_gpu_count, and optional per_bunker_max_* ceilings.
GET /quota-profiles/{profile_id}#
Fetch one profile.
PATCH /quota-profiles/{profile_id}#
Partial update. Only the fields you send are touched.
DELETE /quota-profiles/{profile_id}#
Delete. Existing assignments cascade.
GET /quota-profiles/usage#
Per-profile bucket usage for the calling user: current usage, caps, and remaining headroom for every profile that applies to them.
GET /quota-profiles/{profile_id}/assignments#
List assignments for one profile.
POST /quota-profiles/{profile_id}/assignments#
Assign. Body { target_kind: "user"|"group", target_id, mode: "individual"|"shared"|"per_user" }. individual is user-only, shared/per_user are group-only.
DELETE /quota-profiles/{profile_id}/assignments/{assignment_id}#
Unassign.
Audit#
For bunkers running under unrestricted with worker-side audit on.
GET /bunkers/{bunker_id}/audit-batches#
List per-flow audit batches. Query parameters: since_us (microsecond cutoff), limit (1–1000), continuation_token, worker_id (default: the bunker's current worker; batches stay with the worker that wrote them). Returns { worker_id, items: [{key, size, last_modified, ts_us}], is_truncated, next_continuation_token }. Batches are kept 30 days.
GET /bunkers/{bunker_id}/audit-batches/{batch_name}#
Fetch one batch's NDJSON contents. Takes the same worker_id query parameter as the listing. Each record has action: allow, or deny for a refused connection (at most 10 per second per bunker are recorded).
Exec log and erasure#
ScaiBunker logs every exec (the command line, exit code, duration and the first 4 KiB of stdout and stderr; never stdin or env), every file read and write (the path, not the content) and every shell session (times and byte counts, not the content). Rows are deleted after 30 days, like large exec output.
POST /admin/erasure/user/{user_id}#
Delete a user's exec log rows and the large exec outputs they point to, now. Needs scaibunker:admin:tenant (tenant admins have it) for a user in your own tenant; a super admin can pass ?tenant_id=. Returns { tenant_id, user_id, exec_log_rows, output_objects, failed }. If an output couldn't be deleted (failed > 0), the rows are kept so the call can be repeated.
Peers (worker-to-worker)#
GET /peers/{sha256}#
Worker-only (shared bearer + X-Worker-ID header). Returns the set of peer workers in the caller's availability groups that have this image sha cached, plus the controller storage URL as a fallback. Used by workers to fetch ext4 rootfs from a sibling rather than the controller's storage proxy.
Storage proxy#
The /storage/* prefix relays bytes between callers (workers or capability-token-bearing admins) and S3. Same routes are served by the dedicated SCAIGRID_MODE=bunker_proxy process when bytes-per-second through the proxy dominates controller CPU.
Authentication is one of: Authorization: Bearer <SCAIBUNKER_WORKER_TOKEN> (workers) or Authorization: Capability <jwt> (short-lived caps minted via POST /storage/capabilities).
| Method + path | Purpose |
|---|---|
PUT/GET /storage/images/{sha256}.ext4 |
Content-addressed ext4 image bytes. |
PUT/GET /storage/snapshots/{bunker_id}/{name} |
Per-bunker snapshot archives. |
PUT/GET /storage/audit/{bunker_id}/{name} |
Per-bunker NDJSON audit batches. |
PUT/GET /storage/output/{bunker_id}/{name} |
Large exec outputs. |
PUT/GET /storage/staging/{tenant_id}/{name} |
Admin-uploaded tar sources. |
POST /storage/capabilities |
Mint a short-lived capability token. Requires scaibunker:images:manage. |
GET requests support Range headers for resumable downloads.
Errors#
ScaiBunker-specific error codes:
| Code | Meaning |
|---|---|
BUNKER_NOT_FOUND |
Bunker id doesn't exist or isn't in your tenant. |
BUNKER_NOT_RUNNING |
Operation requires running state. |
BUNKER_INVALID_TRANSITION |
State machine refused (e.g. resume on terminated). |
BUNKER_QUOTA_EXCEEDED |
Caller's profile would be over a cap; the message names which one. |
BUNKER_PERMISSION_DENIED |
Caller lacks the required scaibunker permission. |
WORKER_NOT_FOUND |
Worker id doesn't exist. |
WORKER_UNAVAILABLE |
No worker can satisfy the resource request right now; retry later. |
NO_WORKER_WITH_LABELS |
label_set names labels no worker carries; retrying won't help. |
IMAGE_NOT_FOUND |
Image id or name unknown. |
IMAGE_INACTIVE |
Image was deactivated. |
IMAGE_NOT_READY |
The image is still being built, or its build failed. |
IMAGE_NAME_CONFLICT |
An image with this name already exists in this scope. |
IMAGE_SOURCE_UNSUPPORTED |
Only OCI references and uploaded archives can be registered. |
IMAGE_UPLOAD_INVALID |
The image isn't waiting for an archive, nothing was uploaded, or the upload's size doesn't match size_bytes. |
REGISTRY_CREDENTIAL_NOT_FOUND |
No such credential in your tenant. |
REGISTRY_CREDENTIAL_CONFLICT |
Your tenant already has a credential for this host. |
ENCRYPTION_REQUIRED |
Credentials can't be stored on this deployment (encryption at rest is off). |
IMAGE_BUILDS_UNAVAILABLE |
The image build service isn't available; try again later. |
SNAPSHOT_NOT_FOUND |
Snapshot id unknown. |
NETWORK_PROFILE_DENIED |
Caller lacks the network-profile permission. |
LIFECYCLE_MODE_DENIED |
Caller lacks the lifecycle-mode permission. |
MAX_LIFETIME_TOO_LONG |
max_lifetime_s is above the ceiling for the lifecycle mode (422). |
INVALID_BUNKER_REQUEST |
A create field is invalid or out of range, such as a negative timeout or a bad allowlist entry (422). |
INVALID_USER |
user isn't a name, uid or uid:gid (422). |
USER_NOT_FOUND |
No such user in the bunker's image (422). |
USER_UNSUPPORTED |
The bunker started before users were supported; recreate it (409). |
ROOT_REFUSED |
The user is uid 0 in the bunker's image and you don't hold scaibunker:root (403). |
NO_ROOT_UNSUPPORTED |
The bunker started before uid-0 checks were supported; recreate it (409). |
FILE_PERMISSION_DENIED |
The file call's user may not access that path inside the bunker (403). |
BRIDGE_NOT_FOUND |
Bridge id doesn't exist. |
BRIDGE_ALREADY_EXISTS |
Bridge name taken on that worker. |
BRIDGE_TENANT_MISMATCH |
Bridge belongs to a different tenant. |
INTERFACES_NOT_ALLOWED |
interfaces[] supplied for non-transit profile. |
TRANSIT_MISSING_INTERFACES |
network_profile=transit needs at least one interface. |
NO_SUITABLE_WORKER |
No worker has all the required image-cache state or bridges. |
QUOTA_PROFILE_NOT_FOUND |
Profile id unknown or not visible. |
QUOTA_ASSIGNMENT_CONFLICT |
Target already has a profile assignment. |
AUDIT_BATCH_NOT_FOUND |
Audit batch missing in S3. |
OUTPUT_NOT_FOUND |
No saved full output for this exec, or it expired. |
UPLOAD_NOT_FOUND |
The commit key isn't one of this bunker's uploads, or nothing was uploaded. |
WORKER_STORAGE_UNAVAILABLE |
The bunker's worker has no storage for uploads, saved output or audit. |
AUDIT_PATH_INVALID |
Bad audit batch name. |
STORAGE_UNAUTHORIZED |
Storage proxy auth failed. |
STORAGE_PATH_INVALID |
Storage path didn't match the allowed shape. |
STORAGE_NOT_FOUND |
Storage object missing. |
STORAGE_CAP_DISABLED |
Capability tokens not configured. |
WORKER_INVALID_REQUEST / WORKER_INVALID_STATE / WORKER_ALREADY_EXISTS / WORKER_OVERLOADED / WORKER_INTERNAL / WORKER_NOT_IMPLEMENTED / WORKER_TENANT_MISMATCH / WORKER_RESOURCE_NOT_FOUND / WORKER_UNAUTHORIZED |
Typed errors surfaced from the worker. |