Platform images
ScaiBunker ships six built-in images: minimal, ubuntu-24.04, python-3.12, nodejs-22, rust-latest
and python-3.12-ml. This page explains how they are made and what you can rely on.
What an image is#
A bunker is a Firecracker microVM that boots from an ext4 root filesystem image. The image holds:
- the operating system;
- one language runtime.
The worker supplies the rest:
- the kernel;
- the bunker agent, which runs as PID 1 and executes your commands;
- network and DNS configuration.
An image therefore contains no init system, no kernel, and nothing that identifies the machine it was built on.
Built from distribution sources#
Platform images are built directly from the distributions' own sources, not from third-party container images:
| Image | Base | Runtime | Root disk |
|---|---|---|---|
minimal |
Alpine Linux (latest stable) | busybox, apk |
200 MiB |
ubuntu-24.04 |
Ubuntu 24.04 LTS | none; apt available |
500 MiB |
python-3.12 |
Ubuntu 24.04 LTS | Python 3.12, pip, venv, headers | 800 MiB |
nodejs-22 |
Ubuntu 24.04 LTS | Node.js 22 LTS (official nodejs.org build), npm 12 | 600 MiB |
rust-latest |
Ubuntu 24.04 LTS | Rust stable via rustup (minimal profile), gcc as linker | 2,500 MiB |
python-3.12-ml |
Ubuntu 24.04 LTS | Python 3.12 with PyTorch, torchvision and torchaudio; CUDA runtime libraries included | 12,000 MiB |
Notes:
- Ubuntu images include the
updatesandsecuritypockets, so each build carries every security fix released up to its build date. - pip installs system-wide in the Python images. A bunker is a disposable VM, so no virtual environment is required.
- Rust needs three variables in the bunker's environment:
RUSTUP_HOME=/usr/local/rustup,CARGO_HOME=/usr/local/cargoand/usr/local/cargo/binonPATH. The image sets them for login shells, through/etc/profile.dand/etc/environment, and lists them in its manifest. - GPU images bundle the CUDA runtime libraries that match the PyTorch build. The NVIDIA driver isn't in the image: GPU bunkers get whole GPUs passed through, and ScaiBunker attaches a matching driver (in
/usr/local/nvidia) to each one. The exact PyTorch and CUDA versions of each build are listed in its manifest (boot_test).
How every image is built#
Each build goes through the same pipeline. A failure at any step stops the build, and nothing is published.
- Assemble the root filesystem.
- Ubuntu and Alpine: the distribution's own signed package archives.
- Node.js and Rust: the official downloads, which are checked against their published checksums before use.
- PyTorch: installed from PyPI, with pip verifying package hashes.
- Strip host details. Hostname,
machine-id,/etc/hostsand DNS settings are reset or removed, and logs and caches are cleared. An automated check rejects any image whose configuration mentions the build environment. - Create the ext4 image at the image's root-disk size. File ownership and permissions (including setuid bits) are preserved exactly, and a filesystem check must pass.
- Boot test.
- A copy of the image boots in a real Firecracker microVM.
- Inside the VM, an image-specific check runs. For example: Python imports
ssl,sqlite3andvenv; the Rust image compiles and runs a program; the ML image imports PyTorch, torchvision and torchaudio. - The published image never contains the test itself.
- Security scan.
- The root filesystem is scanned for known vulnerabilities, and a CycloneDX software bill of materials (SBOM) is generated.
- A critical vulnerability that already has a fix available fails the build, because it means an update was missed.
- Compress and publish.
- The image is compressed with zstd. Unused disk space costs almost nothing to download.
- It is published as a new, immutable version together with its manifest and SBOM.
Versions and updates#
- Version numbers take the form
1.<YYYYMMDD>.<n>, e.g.1.20261017.0. A second build on the same day becomes.1. - Rebuilds happen monthly. Images are also rebuilt off-cycle when an urgent security fix is published.
- Published versions never change. A rebuild always creates a new version, so a running bunker is never changed underneath you.
- Rollout. New bunkers get a new version once the workers have imported it, one worker at a time. Bunkers already running stay on their version. A bunker's
image_versionshows which version it runs. - Snapshots keep their version. A snapshot records the version its bunker ran (
image_version), and a restore always uses that version, even after the image has moved on. The restored bunker runs the old version; create a new bunker to get the new one. - Retention. The newest version and the two before it stay available. Older versions are deprecated, and removed once no bunker runs on them and no snapshot needs them.
The image manifest#
Every version carries an image.json manifest. The fields you are most likely to use:
| Field | Meaning |
|---|---|
base |
Distribution and release, e.g. {"distro": "ubuntu", "release": "24.04"} |
entrypoint |
The bunker's shell: /bin/bash, or /bin/sh for minimal |
env |
Environment variables the runtime requires (empty except for Rust) |
rootfs.sha256 |
SHA-256 of the uncompressed ext4 image. This is the image's identity: use it to verify the image after download |
rootfs.size_mib |
Root disk size |
boot_test |
What the boot check printed, such as the exact Python, Node.js, Rust or PyTorch version |
scan |
Vulnerability counts by severity at build time |
built_at |
Build time (UTC) |
ScaiBunker records this build-time scan on the image, tied to the image's rootfs.sha256. An image is scanned once, when it comes in. It's scanned again only when its content changes, which for platform images means a new version. New vulnerabilities are picked up by the monthly and urgent rebuilds, not by re-scanning an image that hasn't changed.
Need something else?#
If a built-in image lacks a tool you need, install it from inside the bunker, for example with apt, pip, npm, cargo or
apk, as far as the bunker's network profile allows. For a recurring need, register your own image; see
Register a custom image.