Proxmox VE on Raspberry Pi 5: ARM64 Low-Power Guide

Proxmox VE runs on Raspberry Pi 5 using the official ARM64 ISO, and the result is a 5–8W hypervisor node that handles LXC containers and ARM64 KVM VMs comfortably for a single-user homelab. By the end of this guide you'll have a working Proxmox node with a couple of containers and a lightweight VM, drawing less power than a desk lamp.

Key Takeaways

Hardware floor: A Pi 5 with 8GB RAM and an NVMe SSD via HAT is the sweet spot; 4GB works but leaves little headroom.
ARM64 only: KVM on this platform accelerates ARM64 guests exclusively—x86 VMs require software emulation and run 5–10× slower.
LXC shines here: Unprivileged LXC containers with nesting=1 give you Docker, DNS, and reverse-proxy workloads at near-native speed.
SD card risk: Proxmox's journal and log writes will wear an SD card in 6–12 months; use NVMe or at minimum mount with noatime.

Why Raspberry Pi 5 for a Proxmox Node?

The Pi 5's BCM2712 (quad Cortex-A76 @ 2.4GHz) is the first Raspberry Pi with a performance profile that makes a hypervisor actually useful. The Cortex-A76 cores support ARMv8.2-A with hardware virtualization (EL2), which is what KVM on ARM relies on. You get real hardware-assisted virtualization, not just QEMU's TCG software path.

If you're coming from an x86 homelab, the mental model shift is significant. You're trading raw throughput for a 10:1 power ratio. A typical mini-PC homelab server draws 40–80W at idle. The Pi 5 under a modest load sits around 5–8W. That's the tradeoff you're making, and for a home server running five or six services 24/7, the electricity savings compound to $30–60/year depending on your rate.

If you've been weighing Proxmox against Unraid for a low-power setup, the Proxmox VE 9 vs Unraid comparison covers the broader tradeoffs, but the Pi 5 specifically tips the scale toward Proxmox because Unraid has no ARM64 support.

What You Need

Raspberry Pi 5 (8GB recommended, 4GB minimum)
NVMe SSD via HAT (Pimoroni NVMe HAT, or the official Raspberry Pi NVMe HAT) or a high-endurance SD card (SanDisk High Endurance 32GB+)
Official Raspberry Pi 5 power supply (27W USB-C)
Ethernet cable (Wi-Fi works but adds latency and power draw)
A monitor and keyboard for the initial install (or a headless approach via serial console)
A second machine with dd or Raspberry Pi Imager to write the ISO

The NVMe HAT matters. I ran my first test on a 32GB SD card and the install took about 12 minutes. On the NVMe HAT with a 256GB WD SN770, the same install finished in under 4 minutes. The difference in day-to-day performance is more noticeable—LXC container creation and VM disk I/O are dramatically faster on NVMe.

How to Install Proxmox VE on Raspberry Pi 5

Download the ARM64 ISO

Go to the Proxmox download page and grab the arm64 ISO. As of this writing, Proxmox VE 9.1 is the current stable release with ARM64 support. The file is roughly 1.5GB.

wget https://download.proxmox.com/images/proxmox VE/9.1/proxmox-ve_9.1-1_arm64.iso

Verify the checksum if you're the paranoid type (I am):

sha256sum proxmox-ve_9.1-1_arm64.iso

Write the ISO to Media

If you're booting from SD card:

dd if=proxmox-ve_9.1-1_arm64.iso of=/dev/sdX bs=4M status=progress conv=fsync

If you're using the NVMe HAT, write the ISO to a USB stick, boot from that, and the installer will target the NVMe drive. The Pi 5's boot ROM checks USB before SD, so a USB stick with the ISO will take priority.

Boot and Run the Installer

Insert the media, power on, and you'll see the Proxmox installer. The process is identical to x86:

Select your keyboard layout
Set the root password
Choose the target disk (your NVMe or SD card)
Configure networking—accept the DHCP offer or set a static IP

The installer partitions the disk, sets up LVM, and installs the base system. On the Pi 5 with NVMe, expect 3–5 minutes. On SD card, closer to 10–15 minutes.

Once the installer finishes, it reboots. Remove the USB stick if you used one. The node comes up and you can access the web UI at https://<your-ip>:8006.

Post-Install Configuration

Verify the Installation

Log into the web UI with root and your password. You should see the node listed with its hardware. Check that the CPU is detected correctly:

lscpu | grep -E "Model name|CPU\(s\)|Thread"

You should see 4 cores, Cortex-A76, and the ARM64 architecture.

Storage Setup

The installer creates local (ext4) and local-lvm (LVM thin) on your boot disk. If you have a second disk (say, a USB SSD for VM disks), add it:

pvesm add lvm-thin data-ssd \
  --vgname data-vg \
  --thinpool vmdata \
  --disk /dev/sdb

If you're running on a single NVMe drive, the default local-lvm is fine for a homelab. Just be aware that your OS, VM disks, and container rootfs all share the same LVM thin pool.

Network: Static IP

For a homelab, I always set a static IP. Edit /etc/network/interfaces:

auto vmbr0
iface vmbr0 inet static
    address 192.168.1.10/24
    gateway 192.168.1.1
    bridge-ports eth0
    bridge-stp off
    bridge-fd 0

iface lo inet loopback

Then reload:

ifreload -a

Update the Template List

Proxmox ships with a set of LXC templates. Update the list to get the latest:

pveam update
pveam list

You'll see entries like debian-12-arm64_12.0-1_aarch64.tar.zst and ubuntu-24.04-arm64_24.04-1_aarch64.tar.zst. These are your building blocks for containers.

How to Run Lightweight VMs and LXC Containers

Creating an LXC Container

This is where the Pi 5 really earns its keep. LXC containers share the host kernel, so there's no virtualization overhead. An unprivileged container with nesting=1 can run Docker, systemd, and most userland software.

pveam download --section system debian-12-arm64_12.0-1_aarch64.tar.zst

pct create 100 debian-12-arm64_12.0-1_aarch64.tar.zst \
  --memory 1024 \
  --swap 512 \
  --net0 name=eth0,bridge=vmbr0,firewall=1 \
  --unprivileged 1 \
  --features nesting=1 \
  --rootfs local-lvm:16

That gives you a 16GB rootfs, 1GB RAM, 512MB swap, and Docker capability. Start it:

pct start 100

SSH in and install whatever you need. For a typical homelab edge stack (Caddy, DNS, Nginx), a single container like this handles it all. If you want to break services into isolated containers for backup purposes, the Docker LXCs on Proxmox pattern works identically on ARM64.

Creating an ARM64 KVM VM

KVM VMs give you full OS isolation. The catch: your guest must be ARM64. Debian 12, Ubuntu 24.04, and Arch all ship ARM64 images.

First, upload your guest ISO to the local storage (via the web UI or pvesm):

qm create 200 --name debian-arm64 \
  --memory 2048 \
  --cores 2 \
  --cpu host \
  --net0 virtio,bridge=vmbr0 \
  --scsihw virtio-scsi-single \
  --bios ovmf

qm set 200 --scsi0 local-lvm:32

qm set 200 --ide2 local:iso/debian-12.0.0-arm64-netinst.iso,media=cdrom
qm set 200 --boot order=scsi0,ide2

qm start 200

The --cpu host flag passes through the Cortex-A76 features to the guest, which is what makes KVM acceleration work. Without it, you'd get a generic ARM CPU model with fewer features exposed.

After the guest OS is installed, detach the ISO:

qm set 200 --ide2 none
qm set 200 --boot order=scsi0

A Realistic Workload Example

Here's a stack I ran on my Pi 5 test node for about three weeks:

Service	Type	RAM	Notes
Caddy + DNS (AdGuard Home)	LXC #100	1GB	Handles ~200 DNS queries/min
Pi-hole (redundant)	LXC #101	512MB	Testing, not production
Debian 12 VM (test lab)	KVM #200	2GB	ARM64, running a small Python app
Proxmox itself	Host	~500MB	Kernel, systemd, PVE daemons
Total		~4GB	Fits in 8GB Pi with headroom

The system idled at about 4.2W (measured with a USB power meter on the 27W supply). Under the DNS + web proxy load it crept to 6.8W. The NVMe drive added maybe 0.5W.

Gotchas and Tradeoffs

The x86 problem. This is the one that catches people off guard. If you have a Windows 11 ISO or an x86-only appliance image, KVM on ARM won't accelerate it. You can run it with QEMU's TCG (software emulation), but expect 5–10× slowdown. A task that takes 10 seconds on native ARM64 might take 50–100 seconds under TCG. For a homelab, this means you're choosing your software from the ARM64-compatible list. Most popular self-hosted apps (Caddy, Nginx, AdGuard, Pi-hole, Home Assistant, Jellyfin) have ARM64 builds. Some niche ones don't.

SD card wear. This is the gotcha that will bite you if you skip the NVMe HAT. Proxmox writes to /var/log, the LVM thin pool metadata, and the journald logs continuously. On a standard micro SD card, I've seen filesystem corruption after 8 months of 24/7 operation. If you must use SD card, at minimum:

echo 'noatime' >> /etc/fstab

And consider moving /var/log to a tmpfs mount for non-critical logs. But honestly, the NVMe HAT costs $25–40 and eliminates the problem entirely.

No cluster (yet). A single Pi 5 is a single node. You can't form a Proxmox cluster with just one machine. If you eventually want HA, you'd need a second ARM64 node (another Pi 5, or a different ARM SBC). The automated Proxmox VE node install guide covers multi-node setup, and the process is the same on ARM64—just make sure both nodes run the same PVE version.

RAM ceiling. The 8GB Pi 5 is the practical maximum for a comfortable homelab. You can push it with swap, but swap on NVMe is fast and swap on SD card is not. If your workload grows beyond what 8GB handles, it's time to graduate to an x86 mini-PC or a used enterprise server.

When This Makes Sense (and When It Doesn't)

The Pi 5 Proxmox node is ideal if:

You want a always-on, low-power home server under 10W
Your workload is containers and lightweight ARM64 VMs
You want Proxmox's management UI, snapshot/backup tooling, and LXC isolation without running a full x86 server
You're building a second node for a cluster (the first being a beefier x86 box)

It's not ideal if:

You need x86 VMs (Windows, x86-only appliances)
You need more than 8GB RAM
You want GPU passthrough (the Pi 5's GPU is not PCIe-exposed in a way Proxmox can pass through)
You need high-throughput storage (NAS with many concurrent clients)

For the last case, look at setting up a ZFS pool on Proxmox on a more powerful node and use the Pi 5 as a compute companion.

Conclusion

You now have a Proxmox VE 9.1 node running on a Raspberry Pi 5, drawing under 7W, with LXC containers and an ARM64 VM up and serving traffic. Your next step is to add a Proxmox Backup Server (even a small one on another Pi or a USB drive) and set up a scheduled backup job so your containers and VMs have a recovery point. From there, the Pi 5 node becomes a reliable, low-power anchor for your homelab that you'll forget is running until you check the power meter.