Quick answer

Production homelabs rarely choose Proxmox or Docker alone: Proxmox VE 9 owns the bare metal while a dedicated Debian VM runs Docker Compose stacks cleanly. That VM boundary gives five-second incremental Proxmox Backup Server snapshots, kernel NFS mounts, and immunity from host AppArmor or cgroup upgrades that break Docker inside unprivileged LXC containers.

Contents

At a glance

Class
Comparison

Provenance

  • Jul 2, 2026Published
  • Nov 14, 2026Last substantive update

Search “Proxmox vs Docker” and you will wade through years of forum threads arguing a false binary. They sit at different layers of the stack. Stop treating them like rivals.

In my own homelab, I run both together. Proxmox VE 9 owns the bare metal, and one dedicated Debian 13 VM runs Docker Engine and Docker Compose on top of it.

Proxmox carves physical CPU, RAM, NVMe storage, and NICs into isolated virtual machines and LXC system containers. Docker packages applications inside a single Linux OS. Once you see the boundary, only two architecture questions remain:

  1. Should bare metal run Proxmox VE or plain Linux + Docker?
  2. If Proxmox owns the metal, why put Docker inside a QEMU VM instead of an unprivileged LXC container?

If you are also weighing system containers against full VMs for non-Docker services like Pi-hole or WireGuard, read our LXC vs VM on Proxmox breakdown alongside this guide.

The production homelab pattern: Proxmox + one Debian Docker VM

Almost every self-hosted project ships a compose.yaml file first. Hand-building 25 separate LXC containers wastes weekends. Conversely, installing Ubuntu + Docker straight onto bare metal forfeits instant hypervisor rollbacks, Home Assistant OS appliances, Windows test guests, and bare-metal-independent restores.

Layering Proxmox VE 9 on bare metal with one Debian VM for Docker Compose solves both problems at once:

  • One guest kernel boundary: All 15 or 30 Compose containers share one VM (~600–900 MB of base guest RAM overhead once, not per app), with standard ext4 filesystem semantics regardless of whether Proxmox uses ZFS, LVM-thin, or Ceph underneath.
  • Five-second incremental backups: Running VMs backed up to Proxmox Backup Server (PBS) track changed 4 MiB blocks in memory via QEMU dirty bitmaps. After the first full backup, nightly snapshots of a 200 GB Docker VM take a few seconds without stopping a single container.
  • Zero host-upgrade breakage: Proxmox kernel, AppArmor, lxcfs, and systemd point-release updates never break runc or containerd inside a QEMU VM.

When bare-metal Debian + Docker wins instead: Pick bare metal when an 8 GB mini PC or single-board computer serves one isolated job (for example, an off-site Restic target or a standalone edge proxy) and will never host a second VM or PBS backup agent. Plain Debian + Docker Engine is clean, fast, and avoids hypervisor memory overhead. On any 16 GB+ multi-service home server, Proxmox underneath pays for itself the first time an update goes sideways. (Moving off VMware? See Proxmox vs ESXi.)

Backup, kernel isolation & GPU-sharing comparison

Proxmox’s official Linux Container documentation (chapter-pct) explicitly advises running application containers like Docker inside a QEMU VM:

“If you want to run application containers, for example, Docker images, it is recommended that you run them inside a Proxmox QEMU VM. This will give you all the advantages of application containerization, while also providing the benefits that VMs offer, such as strong isolation from the host and the ability to live-migrate.”

Here is the concrete operational engineering behind that recommendation across every failure mode homelabbers hit:

Operational dimensionDocker in a Debian VM (Recommended)Docker in Unprivileged LXC (nesting=1)Native Proxmox LXC (No Docker)Bare-Metal Linux + Docker
Kernel & upgrade isolationFull guest kernel. Immune to Proxmox host AppArmor, cgroup2, or runc regressions.Shared host kernel. Host AppArmor / lxc package updates periodically break containerd or sysctl calls inside nested containers.Shared host kernel, single userspace init (systemd). Very stable for standard Debian packages.Single bare-metal kernel. Stable, but zero hypervisor rollback if a bad kernel or driver fails to boot.
PBS backup speed & mechanismQEMU dirty-bitmap block backup. Incremental nightly runs finish in ~5 seconds without scanning millions of files.Filesystem pxar archive walk. PBS must stat() hundreds of thousands of tiny Docker overlay2 layer files every run.Fast pxar walk (low file count per single-app LXC).DIY (restic / borg / scripts). Full host recovery requires OS reinstall + Compose redeploy.
ZFS storage behaviorGuest sees plain ext4 on a ZFS zvol. Zero overlay2 driver edge cases on any ZFS version.Native overlay2 works on OpenZFS 2.2+ (PVE 8.1+/9), broke on older ZFS pools (fuse-overlayfs fallback), and churns dataset POSIX metadata.Native ZFS dataset (subvol) per container with instant ZFS snapshots.Native overlay2 on ext4/xfs (or ZFS 2.2+).
NFS / SMB NAS mountsStandard /etc/fstab kernel mounts inside the VM (nfs4, cifs) with zero host coupling.Blocked in unprivileged LXC (Operation not permitted). Requires mounting on the Proxmox host first and passing mp0: bind mounts.Blocked in unprivileged LXC; uses host mount + mp0: bind mount.Standard /etc/fstab kernel mounts.
GPU access & multi-app sharingPCIe VFIO passthrough to the VM. Every Docker container inside that VM shares the GPU cleanly via NVIDIA Toolkit or /dev/dri.Host /dev/dri or /dev/nvidia* bind mount. Allows sharing one GPU across multiple LXCs, but locks guest NVIDIA libraries to the exact host driver version.Host /dev/dri or /dev/nvidia* bind mount (popular for standalone Plex/Jellyfin LXC when sharing iGPU across guests).Native host GPU access for all containers; no VM sharing.
Cluster live migrationOnline live migration with zero container downtime.Offline / restart migration only (containers stop and restart on target node).Offline / restart migration only.None.

Why Docker-in-LXC bites months later (not on day one)

Docker inside an unprivileged LXC with features: nesting=1,keyctl=1 starts in two seconds and uses almost zero idle RAM. That initial success is why so many weekend tutorials recommend it.

The pain arrives six months later during routine maintenance:

  1. AppArmor and procfs collisions on host updates: Enabling nesting=1 exposes host procfs and sysfs paths so Docker can create nested namespaces, while unprivileged user-namespace mapping restricts kernel calls. Minor updates to pve-container, lxc-pve, or Docker’s bundled containerd.io have repeatedly triggered apparmor="DENIED" or permission denied: sysctl net.ipv4.ip_unprivileged_port_start failures that prevent every container from starting after a routine apt full-upgrade.
  2. Kernel NFS and CIFS mounts fail inside unprivileged LXC: Stacks like Jellyfin, Immich, Paperless-ngx, and the *arr suite frequently mount NAS shares. Inside an unprivileged LXC, mount -t nfs fails immediately. You either weaken isolation by creating a privileged container (which Proxmox warns against outside strictly trusted testing) or maintain brittle /etc/fstab mounts on the Proxmox hypervisor itself. Inside a Debian VM, /etc/fstab or Docker NFS volumes just work.
  3. Backup metadata amplification: Every pulled Docker image unpacks thousands of tiny files across overlay2 lowerdirs. When Proxmox Backup Server backs up an LXC container, proxmox-backup-client walks the entire filesystem tree to build a .pxar archive. On a QEMU VM, PBS reads only the dirty 4 MiB extents recorded by the hypervisor’s block layer since the last run.

Compose data-location & Proxmox Backup Server worksheet

A backup only counts if it captures your actual state—and plenty of Docker users accidentally store volumes somewhere Proxmox skips! As Proxmox staff explain in the Proxmox forum thread on Docker volume backups (139411), backup inclusion depends on which virtual disk or mount point holds /var/lib/docker and your bind mounts:

Data typeRecommended path inside Debian Docker VMIncluded in PBS VM snapshot?Restore & consistency rule
Compose YAML & .env files/opt/stacks/<stack>/compose.yaml on scsi0YesKeep all stack definitions under one /opt/stacks tree so a single VM restore recovers config and containers together.
Docker named volumes & images/var/lib/docker/volumes/ on scsi0YesCaptured automatically on the VM disk. (Warning: in an LXC, if you move /var/lib/docker onto a separate mp0: mount point without ticking Backup (backup=1), PBS skips it completely!)
Local SSD app data bind mounts/srv/appdata/<stack> on scsi0 (or scsi1 with Backup enabled)YesKeep SQLite databases (Jellyfin, Vaultwarden, Uptime Kuma) on local ext4 virtual disks, never over NFS/SMB.
Transactional SQL databases (Postgres / MariaDB)Local disk + /srv/backups/sql/ dump cronYes (fsfreeze + dump)Enable qemu-guest-agent so PBS runs fsfreeze before snapshotting, AND run a nightly pg_dumpall into /srv/backups/sql/ on the backed-up VM disk.
Multi-terabyte NAS media shares/mnt/nas/media mounted via NFSv4 / SMBNo (by design)Remote network mounts are never swept into VM block backups, keeping your nightly PBS snapshots small and fast while your NAS protects bulk media separately.

Always verify disaster recovery once: restore yesterday’s PBS VM snapshot to a spare VM ID (such as 901) with its network NIC temporarily disconnected, boot into the console, and confirm docker compose ps brings every database and volume up cleanly.

Setting up the Debian 13 Docker VM cleanly

Create one QEMU VM in Proxmox (VirtIO SCSI single, scsi0 with Discard and SSD emulation enabled, CPU type: host, QEMU Guest Agent: Enabled, and 4–16 GB fixed RAM depending on your Docker RAM planner estimate—avoid QEMU memory ballooning on database-heavy Docker hosts so Linux page cache behaves predictably).

Inside the fresh Debian 13 (trixie) VM, install the guest agent and official Docker Engine packages per Docker’s Debian installation docs:

sudo apt update
sudo apt install -y qemu-guest-agent ca-certificates curl
sudo systemctl enable --now qemu-guest-agent

# Add Docker's official GPG key and deb822 repository
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

sudo tee /etc/apt/sources.list.d/docker.sources >/dev/null <<EOF
Types: deb
URIs: https://download.docker.com/linux/debian
Suites: $(. /etc/os-release && echo "$VERSION_CODENAME")
Components: stable
Architectures: $(dpkg --print-architecture)
Signed-By: /etc/apt/keyrings/docker.asc
EOF

sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
sudo docker run --rm hello-world

Two important security notes come straight from Docker’s Debian documentation. Published container ports (ports: - "8080:80") manipulate nftables/iptables directly and bypass ufw host firewall rules unless bound to 127.0.0.1:8080:80 behind a local reverse proxy, and wiring secrets or .env interpolation properly requires distinguishing .env from env_file: as detailed in our Docker Compose environment variables guide.

What about Proxmox VE 9.1+ native OCI image support?

Starting in Proxmox VE 9.1, you can pull OCI container images directly into LXC templates. Per the Proxmox VE Roadmap and container admin guide, running application containers via OCI is explicitly marked a technology preview.

It does not parse compose.yaml, create isolated per-stack Docker bridge networks, or orchestrate multi-container dependencies (such as Immich’s four linked server, ML, Valkey, and VectorChord Postgres services). Treat native OCI in Proxmox VE 9 as an interesting way to spin up a single stateless utility container, not a replacement for your Docker Compose VM.

Decision checklist

Run every workload through four rules:

  1. Appliances with their own OS or kernel (OPNsense, Home Assistant OS, Windows): Dedicated Proxmox QEMU VM per appliance.
  2. Multi-container stacks or frequent upstream releases (Immich, Paperless-ngx, Nextcloud, Jellyfin, *arr): Put them in your Debian Docker Compose VM backed up nightly to PBS. Pass your discrete GPU into this VM via PCIe VFIO passthrough if multiple containers need NVENC or CUDA.
  3. Core LAN plumbing that must stay up while rebooting the Docker VM (Pi-hole / AdGuard Home, Tailscale subnet router, UPS nut-server): Native Proxmox LXC container (one tiny Debian LXC per service, zero Docker overhead, sub-second boot).
  4. Need one Intel Quick Sync iGPU shared between two separate Proxmox guests simultaneously? Either co-locate all media/ML apps inside the single Docker VM, or use /dev/dri bind mounts across two native LXCs knowing they share the host kernel driver.

Size your combined VM and LXC memory budget in the Proxmox capacity planner before allocating RAM, and keep Proxmox doing hardware virtualization while Docker handles application stacks.

Frequently asked questions

Does Proxmox replace Docker?
No. Proxmox VE is a Type-1 hypervisor that carves bare-metal hardware into virtual machines and LXC system containers. Docker Engine is an application container runtime that runs multi-service Compose stacks. Proxmox VE 9.1+ added technology-preview OCI image imports for LXC, not a Docker Compose replacement, so serious homelabs layer Docker inside a Proxmox VM.
Should I run Docker inside a Proxmox VM or an LXC container?
Use a dedicated Debian or Ubuntu VM for Docker Compose unless host RAM is under 8 GB. A VM gives Docker its own kernel, native NFS/SMB mounts, immunity from Proxmox host AppArmor or systemd updates, and 5-second dirty-bitmap incremental backups in Proxmox Backup Server. Docker inside an unprivileged LXC works with nesting=1, but breaks far more often across host upgrades.
When is bare-metal Linux with Docker better than Proxmox?
When a small single-purpose machine (like a Raspberry Pi or 8 GB mini PC) will only ever run one or two Docker stacks and never host Home Assistant OS, OPNsense, or test VMs. On anything with 16 GB+ RAM, putting Proxmox underneath costs roughly 1–2 GB of host overhead in exchange for instant pre-upgrade snapshots and full-machine PBS disaster recovery.
Does ZFS still break Docker inside a Proxmox LXC?
OpenZFS 2.2+ (shipped since Proxmox VE 8.1, with OpenZFS 2.3 in VE 9) added native overlayfs support, so Docker’s overlay2 driver no longer crashes out of the box on modern ZFS pools. However, millions of small overlay2 layer files inside a ZFS subvol still slow down file-level pxar LXC backups compared with block-level dirty-bitmap backups of an ext4 VM disk.
How do multiple Docker containers share one GPU on Proxmox?
Pass the GPU via PCIe VFIO into your single Docker VM, then install the NVIDIA Container Toolkit or expose /dev/dri inside that VM. Every container in that VM can share the GPU concurrently for Jellyfin transcoding, Immich ML, and Ollama without binding your containers to the Proxmox host kernel’s driver version.

Corrections

Last updated
Methodology
See our methodology for research and review standards.
Corrections
Spotted an error? Email a correction with the affected line and what you found. The draft includes this page’s address. Verified changes are recorded here. Contact details.

About the author

Written by Lowell K. Wood IV, who builds and runs TechFuelHQ from St. Louis, Missouri.