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:
- Should bare metal run Proxmox VE or plain Linux + Docker?
- 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 MBof base guest RAM overhead once, not per app), with standardext4filesystem 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, andsystemdpoint-release updates never breakruncorcontainerdinside 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 dimension | Docker in a Debian VM (Recommended) | Docker in Unprivileged LXC (nesting=1) | Native Proxmox LXC (No Docker) | Bare-Metal Linux + Docker |
|---|---|---|---|---|
| Kernel & upgrade isolation | Full 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 & mechanism | QEMU 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 behavior | Guest 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 mounts | Standard /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 sharing | PCIe 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 migration | Online 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:
- AppArmor and
procfscollisions on host updates: Enablingnesting=1exposes hostprocfsandsysfspaths so Docker can create nested namespaces, while unprivileged user-namespace mapping restricts kernel calls. Minor updates topve-container,lxc-pve, or Docker’s bundledcontainerd.iohave repeatedly triggeredapparmor="DENIED"orpermission denied: sysctl net.ipv4.ip_unprivileged_port_startfailures that prevent every container from starting after a routineapt full-upgrade. - Kernel NFS and CIFS mounts fail inside unprivileged LXC: Stacks like Jellyfin, Immich, Paperless-ngx, and the
*arrsuite frequently mount NAS shares. Inside an unprivileged LXC,mount -t nfsfails immediately. You either weaken isolation by creating a privileged container (which Proxmox warns against outside strictly trusted testing) or maintain brittle/etc/fstabmounts on the Proxmox hypervisor itself. Inside a Debian VM,/etc/fstabor Docker NFS volumes just work. - Backup metadata amplification: Every pulled Docker image unpacks thousands of tiny files across
overlay2lowerdirs. When Proxmox Backup Server backs up an LXC container,proxmox-backup-clientwalks the entire filesystem tree to build a.pxararchive. 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 type | Recommended path inside Debian Docker VM | Included in PBS VM snapshot? | Restore & consistency rule |
|---|---|---|---|
Compose YAML & .env files | /opt/stacks/<stack>/compose.yaml on scsi0 | Yes | Keep 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 scsi0 | Yes | Captured 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) | Yes | Keep 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 cron | Yes (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 / SMB | No (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:
- Appliances with their own OS or kernel (
OPNsense,Home Assistant OS,Windows): Dedicated Proxmox QEMU VM per appliance. - 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. - Core LAN plumbing that must stay up while rebooting the Docker VM (
Pi-hole/AdGuard Home,Tailscalesubnet router,UPS nut-server): Native Proxmox LXC container (one tiny Debian LXC per service, zero Docker overhead, sub-second boot). - 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/dribind 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?
Should I run Docker inside a Proxmox VM or an LXC container?
When is bare-metal Linux with Docker better than Proxmox?
Does ZFS still break Docker inside a Proxmox LXC?
How do multiple Docker containers share one GPU on Proxmox?
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.