Platform design: VMs, containers and specialised workloads
Choosing where each workload runs, and what the platform must provide to run both.

A platform that runs containers and virtual machines is not two platforms side by side. It is one control model over two execution models: the same declaration schedules a unit, and the platform decides whether that unit is a process on the shared host kernel or a guest with a kernel of its own. The design question is where each workload runs, and every answer has a price.
The control model: objects reconciled, not machines operated
The container world’s own documentation describes the platform as “a portable, extensible, open source platform for managing containerized workloads and services that facilitate both declarative configuration and automation”, and explains “the abstractions Kubernetes uses to represent your cluster”. The unit of scheduling is the pod — “the smallest deployable compute object in Kubernetes”. You state intent; a control plane reconciles real state toward it. This sheet uses that model to reason about placement, not to operate one; no command-line workflow appears here. What matters is that the unit placed is not a machine but a declaration.
A container inside a VM: when the kernel must not be shared
A container is a process on the host kernel, which is both its economy and its exposure. The answer for the cases the shared kernel does not cover is a container whose runtime boots a lightweight virtual machine per unit. Kata Containers builds containers from “lightweight virtual machines (VM’s) that feel and perform like standard Linux containers”, adding hardware virtualization “as a second layer of defence”. The VM defends the container rather than replacing it: the architecture “allows running several containers per VM to support container engines that require multiple containers running inside a pod”, so the pod keeps its shape and gains hardware distance from the host. The stated reasons: this “Isolates the workload entirely from the VM environment” and leaves the workload “managed and monitored through its cgroup confinement”.
VMs as objects in the same platform
The other direction keeps the control model and adds the virtual machine. KubeVirt “is a virtual machine management add-on for Kubernetes”: “The aim is to provide a common ground for virtualization solutions on top of Kubernetes.” It extends the API by “adding additional virtualization resource types (especially the VM type)”, so “the Kubernetes API can be used to manage these VM resources alongside all other resources Kubernetes provides”. A resource is not a machine: “The resources themselves are not enough to launch virtual machines”, because controllers and agents acting on them “needs to be added to the cluster”. The user guide keeps a separate vocabulary for the VM side, including “Resource allocation and optimization for the virtualization layer”. One control model now drives two execution models.
System container and VM on the same hypervisor
Both can also live on one host, with no cluster. A Proxmox VE installation offers guests of two kinds: “a Kernel-based Virtual Machine (KVM) and the other is a Linux Container (LXC)”. The container is “a lightweight alternative to fully virtualized machines (VMs)” because it uses “the kernel of the host system that they run on, instead of emulating a full operating system”, and the runtime cost “is low, usually negligible” — but “Only Linux distributions can be run in Proxmox Containers”. The virtual machine takes the opposite trade: QEMU/KVM “is not limited to Linux guests but allows arbitrary operating systems to run”. When neither suffices alone, the guidance is explicit: “for use cases demanding maximum isolation and the ability to live-migrate, nesting containers inside a Proxmox QEMU VM remains a recommended practice.”
The runtime is its own layer
Which execution model a unit gets is decided below the workload, at the runtime. containerd “is an industry-standard container runtime” that “can manage the complete container lifecycle of its host system” yet “is designed to be embedded into a larger system, rather than being used directly by developers or end-users” — a layer, not a product. The specification beneath it anticipates both outcomes: beside its per-platform objects it defines a vm object, “Virtual-machine-specific configuration”, that “MAY be set if the target platform and architecture of this spec support hardware virtualization”. The lifecycle verbs are identical; only the isolation engine behind them changes. The execution model is a platform decision, not something a workload declares.
The specialised workload breaks the uniform pool
A fleet is designed around a shape it can repeat; a workload needing a particular accelerator refuses it and brings scaling axes of its own. vLLM, “a fast and easy-to-use library for LLM inference and serving”, needs “Tensor, pipeline, data, expert, and context parallelism for distributed inference” and specific hardware — “NVIDIA GPUs, AMD GPUs, and x86/ARM/PowerPC CPUs” among others. How one accelerator is shared is treated with the GPU material; the platform point is narrower. The node carrying the device stops being interchangeable, so a homogeneous pool must carry a documented exception.
Choosing per workload, and what each choice costs
Four criteria decide placement, each a trade rather than a preference.
- Isolation. A shared-kernel container trusts the host kernel boundary; one inside a VM adds a kernel boot between untrusted code and the host.
- Density. The container is a “lightweight alternative” with negligible runtime cost; the VM spends memory and boot time on a kernel of its own.
- Lifecycle. The same control model declares either a container or a VM object, but a virtual machine has states a container lacks — a boot phase, a migration — so its lifecycle is longer and heavier.
- Competences. Running shared-kernel containers is one skill; a fleet that also runs guests, a hypervisor and their storage is two, both on call.
The rule that follows is not to pick one model. An architecture with two execution models has two profiles of failure, and a fault in one path is not a fault in the other: a kernel-level defect is contained differently, load behaves differently, recovery is not interchangeable. A platform that runs both must document both, or it operates one model while believing it operates the other.
Level and prerequisites
L5 — platform depth: where each workload runs once containers and virtual machines share a control model, and what that choice costs. The mechanics of a container on a host are the prerequisite, not the subject.
Prerequisites: Container images, registries, volumes and networks; Docker, Podman and Compose; Rootless containers, capabilities and isolation — the host-side container mechanics this sheet assumes — plus the processor, memory and hypervisor fundamentals of the earlier levels.
Where to go next
- Server & Virtualization — this sheet’s area; its Virtualization and networking node is virtualization-and-networking.
- Beyond L5: the distributed orchestration of containers across a fleet, a later level, and — in the AI and LLM macro-area — the models and serving stacks the specialised node hosts.
References
- Kubernetes — Concepts — https://kubernetes.io/docs/concepts/
- Kata Containers — Architecture — https://raw.githubusercontent.com/kata-containers/kata-containers/main/docs/design/architecture/README.md
- KubeVirt — README — https://raw.githubusercontent.com/kubevirt/kubevirt/main/README.md
- KubeVirt — User guide — https://kubevirt.io/user-guide/
- Proxmox VE — Administration guide — https://pve.proxmox.com/pve-docs/
- containerd — containerd README — https://raw.githubusercontent.com/containerd/containerd/main/README.md
- Open Container Initiative — Runtime specification: configuration — https://raw.githubusercontent.com/opencontainers/runtime-spec/main/config.md
- vLLM — Documentation index — https://docs.vllm.ai/en/stable/