How kuasar-io/kuasar works
Project Type and Purpose
• Kuasar is an open-source, Rust-based container runtime built on top of containerd’s new Sandbox API.
• It serves as a “sandboxer” platform, offering multiple isolation techniques (MicroVM, App Kernel/Quark, Wasm, runC) as external plugins to containerd.
• Its goal is to unify sandbox management, improve startup performance (1:N model), and support pluggable sandboxes.
High-Level Architecture Components
A. Control Plane
• containerd (with CRI plugin)
• kuasar-shim (for compatibility with containerd v1.7)
B. Plugin Plane (all separate Unix-socket–based processes)
• vmm-sandboxer
• quark-sandboxer
• wasm-sandboxer
• runc-sandboxer
C. Task Plane (inside or alongside the sandbox)
• vmm-task (runs inside a VM via vsock/UDS)
• quark-task (inside QVisor + QKernel)
• wasm-task (forks WasmEdge/Wasmtime runtime)
• runc-task (joins host namespace)
D. Runtime Plane
• VMM backends: Cloud Hypervisor, StratoVirt, QEMU (inside VM)
• App kernel: QVisor + QKernel
• Wasm runtimes: WasmEdge, Wasmtime
• runC binary
E. Supporting Modules & Tools
• shim code (in /shim) for request forwarding
• scripts and Makefile to build containerd, VMM images, kernels
• docs, examples, benchmarks
Interactions and Data Flows
1. containerd (or Kubernetes via CRI) issues a sandbox-create or task-start request.
2. Request goes through kuasar-shim (if using containerd 1.7) to the sandboxer’s Unix socket.
3. Sandboxer’s RPC server implements the Sandbox API (CreateSandbox/DeleteSandbox) and the Task API (CreateTask/Start/Exec/IO/Stop).
4. The sandboxer either:
• Launches a VM (vmm-sandboxer → VM via QEMU/Cloud Hypervisor/StratoVirt) and communicates with vmm-task over vsock/UDS.
• Starts QVisor + QKernel for Quark, and uses quark-task inside QVisor to manage containers.
• Forks a Wasm runtime process (wasm-task) to host Wasm code.
• Double-forks and sets up namespaces for runc-task.
5. IO streams (stdin/stdout/stderr) and control signals flow over Unix domain sockets or vsock.
6. Tasks run container processes/pods; metrics and logs can be stored or forwarded (e.g., via vmm/common/tracing).
Architectural Patterns & Design Principles
• Plugin-based microservices: each sandboxer is a standalone process exposing a well-defined gRPC/TTRPC interface over a Unix socket.
• 1:N process model: a single resident sandboxer process manages multiple container tasks, reducing overhead.
• Facade/Adapter: unified Sandbox API façade abstracts over heterogeneous runtimes (VM, Wasm, App Kernel, runc).
• Modular crates: each sandboxer (quark, runc, shim, wasm, vmm/common, vmm/sandbox, vmm/task) is an independent Rust crate.
• Configuration by TOML, scripting for build and image preparation.