DPTCloud
Back to articles
Technology Insight

Building a Secure MicroVM Infrastructure: Isolating Untrusted Code with Kata Containers on Bare-Metal VPS

May 29, 2026

Introduction: The Risk of Untrusted Code in Modern Infrastructure

In the era of automation, CI/CD pipelines, and multi-tenant platforms, running untrusted or third-party code has become an unavoidable operational requirement. Whether you are building a SaaS platform that executes user-submitted scripts, analyzing potential malware, or running legacy applications with known vulnerabilities, isolation is your primary line of defense.

For years, standard containerization technologies like Docker and Kubernetes (using runc) were the default choice for application deployment. However, standard containers share the host operating system's kernel. If an attacker successfully executes a privilege escalation exploit within a traditional container, they can breach the container boundary, compromise the host kernel, and gain unauthorized access to the entire infrastructure. This fundamental architectural limitation makes traditional containers unsuitable for running truly hostile or unpredictable code.

The Architecture of MicroVMs: Bridging Containers and Virtual Machines

To mitigate the security risks of shared kernels without sacrificing the speed and efficiency of containers, the cloud-native ecosystem evolved to create MicroVMs (Micro Virtual Machines). MicroVMs represent a hybrid approach: they provide the hardware-level isolation of a traditional virtual machine combined with the rapid deployment times and low resource overhead of a standard container.

Among the leading technologies in this space is Kata Containers. Kata Containers is an open-source project that delivers a secure container runtime with lightweight virtual machines that feel and act like containers, but provide strong workload isolation using hardware virtualization technology.

How Kata Containers Works

Instead of sharing the host kernel, every Kata Container runs inside a dedicated, lightweight MicroVM, utilizing its own unique kernel instance. The architecture relies on three core pillars:

  • The Runtime (kata-runtime): A OCI-compliant runtime that intercepts commands from container engines (like Docker or containerd) and translates them into virtual machine operations.
  • The Hypervisor: Kata leverages specialized, lightweight hypervisors such as QEMU, Cloud Hypervisor, or Amazon's Firecracker to spawn the MicroVM in milliseconds.
  • The Agent (kata-agent): A minimal daemon running inside the MicroVM's guest OS that manages container lifecycles and communicates back to the host system via VSOCK channels.

Why Bare-Metal VPS is Mandatory for This Architecture

Deploying Kata Containers requires hardware-assisted virtualization (such as Intel VT-x or AMD-V technology). If you attempt to deploy Kata Containers inside a standard cloud instance or a nested virtual machine, you will encounter severe performance degradation or outright failure due to the complexities of nested virtualization.

Choosing a Bare-Metal VPS or a dedicated bare-metal server grants direct access to the physical CPU and its virtualization extensions. This eliminates hypervisor overhead, guarantees deterministic hardware performance, and ensures that your custom MicroVM infrastructure runs at maximum efficiency with sub-millisecond execution latencies.

---

Step-by-Step Implementation Guide

Below is a comprehensive technical blueprint to install and configure Kata Containers on a bare-metal Ubuntu server using Containerd as the primary container engine.

Step 1: Verify Hardware Virtualization Support

Before installing any software, verify that your bare-metal server supports hardware virtualization by executing the following command in your terminal:

egrep -c '(vmx|svm)' /proc/cpuinfo

If the output is greater than 0, your CPU supports virtualization. Next, ensure the kvm modules are properly loaded into the kernel:

lsmod | grep kvm

If you see kvm_intel or kvm_amd listed, your system is ready to host MicroVMs.

Step 2: Install Containerd and Prerequisite Tooling

Kata Containers integrates seamlessly with Containerd, an industry-standard container runtime. Install it along with necessary dependencies:

sudo apt-get update
sudo apt-get install -y containerd curl apt-transport-https ca-certificates

Step 3: Install Kata Containers via official binaries

The most reliable way to install Kata Containers is through the official GitHub release binaries or using the official `kata-deploy` toolkit. For standard installations, utilize the official repository package manager:

# Download and setup Kata Containers repository
curl -sL [https://github.com/kata-containers/kata-containers/releases/download/3.2.0/kata-static-3.2.0-x86_64.tar.xz](https://github.com/kata-containers/kata-containers/releases/download/3.2.0/kata-static-3.2.0-x86_64.tar.xz) -o kata.tar.xz
# Extract and link to system path
sudo tar -C / -xVF kata.tar.xz
sudo ln -s /opt/kata/bin/kata-runtime /usr/local/bin/kata-runtime

Step 4: Configure Containerd to Recognize Kata Runtime

To tell Containerd to execute specific workloads inside a Kata MicroVM instead of a standard linux cgroup container, modify the /etc/containerd/config.toml file. Add the following runtime configuration block:

[plugins."io.containerd.grpc.v1.cri".containerd.runtimes.kata]
  runtime_type = "io.containerd.kata.v2"
  [plugins."io.containerd.grpc.v1.cri".containerd.runtimes.kata.options]
    ConfigPath = "/etc/kata-containers/configuration.toml"

After saving the configuration file, restart the Containerd service to apply the new rules:

sudo systemctl restart containerd
---

Testing and Verifying the Isolated MicroVM

To verify that untrusted code is executing within a completely isolated kernel environment, pull a standard test image and run it explicitly using the Kata runtime via nerdctl or ctr CLI tools:

sudo ctr images pull docker.io/library/alpine:latest
sudo ctr run --runtime io.containerd.kata.v2 docker.io/library/alpine:latest kata-test uname -a

Observe the output carefully. The kernel version displayed by the uname -a command inside the container will match the specialized Kata guest kernel, completely differing from your bare-metal host machine's kernel version.

Security Best Practices for Untrusted Environments

While Kata Containers provides deep architectural protection, running untrusted code requires a defense-in-depth approach. Consider implementing the following additional safeguards:

  1. Strict Network Isolation: Disable default network bridging. Use dedicated virtual private networks (VPCs) or fine-grained firewall rules to prevent compromised code from scanning internal network topologies.
  2. Read-Only Root Filesystems: Mount the untrusted container's root filesystem as read-only whenever possible to prevent persistent malware injection.
  3. Resource Quotas: Constrain the MicroVM using explicit CPU and Memory cgroup limits to prevent Distributed Denial of Service (DDoS) attempts against your bare-metal host resources.

Conclusion

By shifting from shared-kernel containers to dedicated MicroVM infrastructure with Kata Containers, you establish an uncompromising security perimeter around your core infrastructure. Utilizing bare-metal servers guarantees that your system leverages raw hardware virtualization capacity, offering rapid boot-up speeds alongside production-grade security. Whether you are running external scripts or isolating sensitive enterprise workloads, this architecture ensures your underlying systems remain entirely private, secure, and resilient.

Building a Secure MicroVM Infrastructure: Isolating Untrusted Code with Kata Containers on Bare-Metal VPS | DPTCloud