Skip to main content
  1. Index/

bootc (Bootable Containers)

bootc is a CNCF sandbox project, created by Colin Walters, that applies the OCI container model to operating system delivery. Where conventional container images package an application to run inside a host OS, a bootc image packages the entire OS — kernel (under /usr/lib/modules), initrd, systemd units, firmware, and all userspace — as a standard OCI image that can be built with podman build or buildah, stored in any OCI-conformant registry, signed with standard supply chain tools, and pulled to a machine where it becomes the running system. At runtime the base OS is not running inside a container; systemd is pid 1 as usual. The container image format is purely a transport and build model, not an execution model.

The filesystem layout on a deployed bootc system reflects its immutability goals. /usr is mounted read-only, enforced at the kernel level via composefs: the ostree composefs backend mounts the OS tree as a verified, content-addressed filesystem so that any modification to a file — whether deliberate or from bit-rot — produces an I/O error rather than silent corruption. /etc and /var remain writable for local configuration and state. Updates work by pulling a new image version from the registry in the background; the new deployment is staged into the ostree object store and activated on the next reboot, with the previous deployment retained for instant rollback via bootc rollback. Disk images for initial provisioning (ISO, qcow2, AMI) are generated from bootc images using bootc-image-builder, which partitions the disk using the UAPI Discoverable Partitions Specification so that systemd can auto-discover and mount partitions without explicit configuration.

The security story is where bootc connects the rest of this glossary. Because the entire OS is a signed OCI artifact pulled from a registry, the OS image is subject to the same supply chain verification as application containers — cosign signatures, SBOMs, attestations via the OCI referrers API. At the boot level, active work integrates UKI-based measured boot so that the composefs root digest — which commits the entire OS tree — is embedded in the UKI kernel command line and therefore covered by the UKI’s Secure Boot signature and TPM PCR measurements. This creates an end-to-end chain: the LUKS volume key is sealed to PCR values that include the composefs digest, so the disk only unlocks automatically when the system has booted exactly the signed OS image enrolled at provisioning time. For CoCo and confidential computing scenarios, the same composefs digest feeds into the TEE’s attestation report — a TDX RTMR or SEV-SNP launch measurement — allowing a remote relying party to verify not just that a TEE is genuine hardware but that the specific, unmodified OS image it is running is the one the workload owner approved.

Related

Kata Containers

Kata Containers is an Open Infrastructure Foundation (OpenInfra Foundation) project that replaces the Linux namespace and cgroup isolation of a conventional container runtime with a full VM boundary, while remaining entirely compatible with the OCI runtime specification and the Kubernetes CRI. From the perspective of containerd, CRI-O, or the Kubernetes kubelet, a Kata pod is indistinguishable from a runc or crun pod — the same API calls, the same lifecycle verbs, the same pod spec — but instead of calling clone() to create a new namespace, Kata starts a lightweight virtual machine. The workload runs inside that VM with its own kernel, its own device model, and a hardware-enforced isolation boundary between itself and the host kernel. The premise is that Linux namespaces, while convenient, share the same kernel as the host: a kernel vulnerability exploitable from inside a container can affect the host and every other container running on the same node. A VM boundary means that even a full guest kernel compromise cannot directly affect the host.

ORAS (OCI Registry As Storage)

ORAS (OCI Registry As Storage) is a CNCF project that treats an OCI-conformant registry not as a container image store but as a general-purpose content-addressable storage system for any kind of artifact. Its central insight is that the OCI Distribution and Image specifications are already a well-understood, widely-deployed, access-controlled, geo-replicated, content-addressed storage substrate — and that the ecosystem does not need a separate storage solution for every new artifact type (Helm charts, WebAssembly modules, ML models, firmware images, OPA policies, SBOMs, attestations) when the same registry infrastructure can store all of them, using the same authentication, the same tooling, and the same pull-by-digest semantics that container images already use.

RHCOS (Red Hat Enterprise Linux CoreOS)

RHCOS (Red Hat Enterprise Linux CoreOS) is the operating system that runs on every OpenShift control plane and worker node. It is not a general-purpose Linux distribution — it is a purpose-built, immutable, container-optimised OS designed to run exclusively as a managed node in an OpenShift cluster. Its security posture is architecturally different from a hardened RHEL installation: rather than hardening a mutable system through configuration management, RHCOS makes the OS layer structurally resistant to modification by design. The root filesystem’s /usr tree is read-only (enforced at mount time by rpm-ostree and, in recent versions, by composefs over the OSTree object store), /etc and /var are writable but managed exclusively by the Machine Config Operator (MCO), and no package manager is available at runtime for ad-hoc software installation. An operator who wants to change any node-level configuration — kernel arguments, sysctl settings, systemd units, certificates, kubelet configuration — creates a MachineConfig object in the OpenShift API; the MCO renders it into an Ignition config, applies it to the target MachineConfigPool (master, worker, or custom), and drains and reboots the affected nodes in a rolling fashion. Direct SSH access to nodes for configuration changes is explicitly unsupported and actively discouraged — oc debug node/<name> is the supported emergency access path, dropping into a privileged container on the node’s host namespaces under audit.