Raspberry Pi 4 (8 GB) als Proxmox VE Test-Node

Raspberry Pi 4 – Debian 13, LUKS2, Dropbear und Proxmox VE

Installation von Debian 13 (Trixie) ARM64 auf einem Raspberry Pi 4 mit 8 GB RAM. Das Root-Dateisystem wird mit LUKS2 verschlüsselt und beim Systemstart über Dropbear-SSH entsperrt.

Die Einrichtung erfolgt über debootstrap und eine ARM64-chroot-Umgebung auf einem Linux-PC. Anschließend werden die angepassten Proxmox-Pakete des Community-Projekts PXVIRT installiert.

1. Voraussetzungen

• Raspberry Pi 4 mit 8 GB RAM
• USB-SSD ab 32 GB, empfohlen 64 GB oder mehr
• Debian-13-Linux-PC mit Internetzugang
• Netzwerkverbindung über Ethernet
• Statische IPv4-Adresse, Netzmaske und Gateway
• SSH-Schlüssel für die Administration
• USB-Boot-fähige Raspberry-Pi-Firmware

Für alle administrativen Befehle auf dem Linux-PC wird eine Root-Shell mit su - verwendet.

Datenträgeraufbau

Partition	Format	Verwendung
Partition 1	FAT32	/boot/firmware
Partition 2	LUKS2	Verschlüsselter Root-Datenträger
cryptroot	ext4	Debian, Proxmox, Container und VMs

Die Boot-Partition bleibt unverschlüsselt. Alle Daten innerhalb der Root-Partition werden durch LUKS2 geschützt.

2. SSH-Schlüssel vorbereiten

Auf dem Linux-Client zwei getrennte Ed25519-Schlüssel erzeugen.

Schlüssel zur LUKS-Entsperrung:

ssh-keygen -t ed25519 -a 100 \
-f ~/.ssh/id_initramfs_unlock_pi4 \
-C "Pi4 LUKS Unlock"

Schlüssel für die normale Administration:

ssh-keygen -t ed25519 -a 100 \
-f ~/.ssh/id_pi4_admin \
-C "Pi4 Administration"

Beide privaten Schlüssel mit jeweils einer Passphrase schützen.

Die öffentlichen Schlüssel werden später in das neue Debian-System übernommen.

3. Linux-PC vorbereiten

Zur Root-Shell wechseln:

su -

Paketlisten aktualisieren:

apt update

Benötigte Pakete installieren:

apt install -y \
debootstrap \
qemu-user \
qemu-user-binfmt \
binfmt-support \
cryptsetup \
parted \
dosfstools \
e2fsprogs \
ca-certificates \
curl \
git \
openssh-client

QEMU ermöglicht das Ausführen von ARM64-Programmen auf einem Linux-System mit anderer CPU-Architektur.

Binfmt-Unterstützung kontrollieren:

cat /proc/sys/fs/binfmt_misc/qemu-aarch64

Bei einem x86-64-Host muss der Eintrag aktiviert sein, bevor ARM64-Programme innerhalb der chroot-Umgebung ausgeführt werden können.

Bei einem ARM64-Host wird QEMU für die Ausführung der Zielprogramme nicht benötigt.

4. USB-SSD partitionieren

USB-SSD anschließen und Datenträger anzeigen:

lsblk -o NAME,SIZE,MODEL,TYPE,MOUNTPOINTS

Das Beispiel verwendet /dev/sdb als SSD. Die korrekte Gerätebezeichnung muss vor jeder Änderung geprüft werden.

Zieldatenträger festlegen:

DISK=/dev/sdb

Datenträger erneut kontrollieren:

lsblk "$DISK"

Die SSD darf keine eingehängten Partitionen enthalten.

Achtung: Die folgenden Befehle entfernen sämtliche Daten vom ausgewählten Datenträger.

Partitionstabelle erstellen:

parted -s "$DISK" mklabel msdos

Boot-Partition mit 1 GiB erstellen:

parted -s "$DISK" mkpart primary fat32 1MiB 1025MiB

Root-Partition mit dem restlichen Speicher:

parted -s "$DISK" mkpart primary 1025MiB 100%

Boot-Flag setzen:

parted -s "$DISK" set 1 boot on
partprobe "$DISK"
udevadm settle

Bei USB-SATA-Laufwerken heißen die Partitionen beispielsweise /dev/sdb1 und /dev/sdb2. Bei NVMe-Laufwerken heißen sie beispielsweise /dev/nvme0n1p1 und /dev/nvme0n1p2.

Die folgenden Variablen automatisch anhand der Gerätebezeichnung bilden:

case "$DISK" in
  *[0-9])
    BOOT="${DISK}p1"
    ROOT="${DISK}p2"
    ;;
  *)
    BOOT="${DISK}1"
    ROOT="${DISK}2"
    ;;
esac

lsblk "$DISK"

5. LUKS2 einrichten

Boot-Partition formatieren:

mkfs.vfat -F32 -n PVEBOOT "$BOOT"

Die zweite Partition mit LUKS2 und Argon2id verschlüsseln:

cryptsetup luksFormat \
--type luks2 \
--pbkdf argon2id \
--pbkdf-memory 262144 \
"$ROOT"

Eine lange, einzigartige Passphrase festlegen. Diese wird später für cryptroot-unlock benötigt.

LUKS-Partition öffnen:

cryptsetup open "$ROOT" cryptroot

Ext4-Dateisystem erstellen:

mkfs.ext4 -L pve-root /dev/mapper/cryptroot

Verschlüsselung prüfen:

cryptsetup status cryptroot
lsblk -f "$DISK"

6. Dateisysteme einhängen

Root-Dateisystem einhängen:

mkdir -p /mnt/pi4
mount /dev/mapper/cryptroot /mnt/pi4

Firmware-Verzeichnis erstellen:

mkdir -p /mnt/pi4/boot/firmware

Boot-Partition einhängen:

mount "$BOOT" /mnt/pi4/boot/firmware

Mountpoints kontrollieren:

findmnt /mnt/pi4
findmnt /mnt/pi4/boot/firmware

7. Debian 13 direkt installieren

Debian wird mit debootstrap direkt auf das verschlüsselte Root-Dateisystem installiert.

debootstrap \
--arch=arm64 \
trixie \
/mnt/pi4 \
https://deb.debian.org/debian

Die Installation erstellt ein minimales Debian-13-ARM64-System.

Die ARM64-Systemprogramme werden bei Bedarf über QEMU ausgeführt. Die Geschwindigkeit hängt vom Linux-Host, dessen CPU und der SSD ab.

8. ARM64-chroot vorbereiten

Die notwendigen Systemdateisysteme in das neue Debian einbinden:

for DIR in dev proc sys run; do
    mount --rbind "/$DIR" "/mnt/pi4/$DIR"
    mount --make-rslave "/mnt/pi4/$DIR"
done

DNS-Konfiguration übernehmen:

cp -L /etc/resolv.conf /mnt/pi4/etc/resolv.conf

ARM64-chroot starten:

chroot /mnt/pi4 /bin/bash

Architektur überprüfen:

dpkg --print-architecture

Erwartete Ausgabe:

arm64

Alle folgenden Installationsbefehle werden innerhalb dieser chroot-Umgebung ausgeführt.

Debian und QEMU können mehrere Prozessoren für parallele Aufgaben verwenden. Ein separater CPU-Parameter für chroot ist nicht erforderlich.

9. Debian-Paketquellen konfigurieren

APT-Quellen bearbeiten:

nano /etc/apt/sources.list

Die vorhandenen Einträge kontrollieren. Für Debian 13 können folgende Quellen verwendet werden:

deb https://deb.debian.org/debian trixie main non-free-firmware
deb https://deb.debian.org/debian trixie-updates main non-free-firmware
deb https://security.debian.org/debian-security trixie-security main non-free-firmware

Gleichwertige bereits vorhandene Einträge unter /etc/apt/sources.list.d dürfen nicht doppelt eingerichtet werden.

Paketlisten aktualisieren:

apt update

10. Kernel und Basispakete installieren

Den ARM64-Kernel, Raspberry-Pi-Firmware, Initramfs und Netzwerkdienste installieren:

apt install -y \
linux-image-arm64 \
raspi-firmware \
initramfs-tools \
cryptsetup-initramfs \
dropbear-initramfs \
openssh-server \
ifupdown2 \
systemd-sysv \
ca-certificates \
curl \
git \
nano \
less \
locales \
busybox \
e2fsprogs

Hostname festlegen:

echo pve-pi4 > /etc/hostname

Hostdatei bearbeiten:

nano /etc/hosts

Beispiel:

127.0.0.1 localhost
10.100.0.2 pve-pi4.home.arpa pve-pi4

Root-Passwort setzen:

passwd

SSH-Dienst für den Systemstart aktivieren:

systemctl enable ssh

11. SSH-Administration einrichten

Den zuvor erzeugten öffentlichen Administrationsschlüssel hinterlegen:

install -d -m 0700 /root/.ssh
nano /root/.ssh/authorized_keys

Den vollständigen Inhalt von id_pi4_admin.pub einfügen.

Dateirechte setzen:

chmod 0600 /root/.ssh/authorized_keys

SSH-Konfiguration ergänzen:

nano /etc/ssh/sshd_config.d/10-pi4-security.conf

Folgenden Inhalt verwenden:

PermitRootLogin prohibit-password
PasswordAuthentication no
KbdInteractiveAuthentication no
PubkeyAuthentication yes

Dadurch ist die Root-Anmeldung über SSH nur mit einem passenden Schlüssel möglich.

12. Boot-Konfiguration vorbereiten

Debian verwendet raspi-firmware zur Bereitstellung der Bootdateien.

Datei bearbeiten:

nano /etc/default/raspi-firmware

Folgende Werte setzen:

ROOTPART="/dev/mapper/cryptroot"
KERNEL="auto"
INITRAMFS="auto"
CMA=0

Der Parameter ROOTPART sorgt dafür, dass die generierte Kernel-Kommandozeile auf das entschlüsselte Root-Dateisystem zeigt.

Die Bootdateien werden später durch die Kernel- und Initramfs-Hooks in die Firmware-Partition übernommen.

13. Crypttab und Fstab konfigurieren

LUKS-UUID anzeigen:

cryptsetup luksUUID "$ROOT"

Falls die Variable ROOT nicht mehr verfügbar ist, auf dem Linux-Host die UUID der LUKS-Partition mit cryptsetup luksUUID ermitteln.

Crypttab bearbeiten:

nano /etc/crypttab

Eintrag hinzufügen:

cryptroot UUID=LUKS-UUID none luks,initramfs

LUKS-UUID durch die tatsächliche UUID der verschlüsselten Partition ersetzen.

Die UUID der FAT32-Boot-Partition wird auf dem Linux-Host mit blkid ermittelt.

Fstab bearbeiten:

nano /etc/fstab

Folgende Einträge verwenden:

/dev/mapper/cryptroot / ext4 defaults,noatime 0 1
UUID=BOOT-UUID /boot/firmware vfat defaults,umask=0077 0 2

BOOT-UUID durch die tatsächliche Dateisystem-UUID der FAT32-Partition ersetzen.

14. Netzwerk konfigurieren

Das Initramfs verwendet eth0 unmittelbar für die SSH-Entsperrung. Nach dem Entsperren verwendet Debian die Linux-Bridge vmbr0.

Beispielwerte:

IP-Adresse	10.100.0.2
Netzmaske	255.255.0.0
Gateway	10.100.0.1
Interface	eth0
Bridge	vmbr0

Die Beispielwerte an das eigene Netzwerk anpassen.

Netzwerkkonfiguration bearbeiten:

nano /etc/network/interfaces

Inhalt:

auto lo
iface lo inet loopback

iface eth0 inet manual

auto vmbr0
iface vmbr0 inet static
    address 10.100.0.2/16
    gateway 10.100.0.1
    bridge-ports eth0
    bridge-stp off
    bridge-fd 0

Den Netzwerkdienst aktivieren:

systemctl enable networking

Für die DNS-Auflösung einen erreichbaren DNS-Server in /etc/resolv.conf eintragen, beispielsweise den eigenen Router, sofern dieser DNS bereitstellt.

15. Initramfs-Netzwerk konfigurieren

Initramfs-Konfiguration öffnen:

nano /etc/initramfs-tools/initramfs.conf

Folgende Werte setzen:

MODULES=most
DEVICE=eth0
IP=10.100.0.2::10.100.0.1:255.255.0.0:pve-pi4:eth0:none

Für die Kernel-Kommandozeile wird zusätzlich dieselbe IP-Konfiguration hinterlegt.

Datei bearbeiten:

nano /etc/default/raspi-extra-cmdline

Inhalt als einzelne Zeile:

ip=10.100.0.2::10.100.0.1:255.255.0.0:pve-pi4:eth0:none

Das Initramfs verwendet eth0 für den Netzwerkzugriff, bevor cryptroot geöffnet wird.

16. Dropbear konfigurieren

Konfigurationsverzeichnis vorbereiten:

install -d -m 0700 /etc/dropbear/initramfs

Authorized-Keys-Datei bearbeiten:

nano /etc/dropbear/initramfs/authorized_keys

Den vollständigen öffentlichen Schlüssel aus id_initramfs_unlock_pi4.pub einfügen und folgende Optionen voranstellen:

no-port-forwarding,no-agent-forwarding,no-X11-forwarding,command="/bin/cryptroot-unlock" ssh-ed25519 SSH-PUBLIC-KEY

SSH-PUBLIC-KEY durch den echten Schlüssel ersetzen. Der gesamte Eintrag muss in einer einzelnen Zeile stehen.

Dateirechte setzen:

chmod 0600 /etc/dropbear/initramfs/authorized_keys

Dropbear-Konfiguration bearbeiten:

nano /etc/dropbear/initramfs/dropbear.conf

Folgende Einstellung verwenden:

DROPBEAR_OPTIONS="-p 2222 -s -j -k -I 120"

Der SSH-Zugriff ist damit auf Schlüsselanmeldung und den Entsperrbefehl beschränkt.

Der Dienst lauscht während der Initramfs-Phase auf Port 2222.

17. Dropbear-Hostkey prüfen

Der SSH-Hostkey für Dropbear wird normalerweise während der Paketinstallation erstellt.

Vorhandenen Schlüssel prüfen:

ls -l /etc/dropbear/initramfs/dropbear_ed25519_host_key

Falls kein Schlüssel existiert:

dropbearkey -t ed25519 \
-f /etc/dropbear/initramfs/dropbear_ed25519_host_key

Öffentlichen Hostkey und Fingerprint anzeigen:

dropbearkey -y \
-f /etc/dropbear/initramfs/dropbear_ed25519_host_key

Den Fingerprint für die spätere SSH-Verbindung dokumentieren.

18. Initramfs erzeugen

Installierte Kernel-Versionen anzeigen:

ls /lib/modules

Neueste installierte Kernel-Version ermitteln:

KVER=$(ls /lib/modules | sort -V | tail -n 1)
echo "$KVER"

Das Initramfs für diese Kernel-Version neu erstellen oder aktualisieren:

if [ -f "/boot/initrd.img-$KVER" ]; then
    update-initramfs -u -k "$KVER"
else
    update-initramfs -c -k "$KVER"
fi

Die Konfiguration des Firmwarepakets sollte dabei die Bootdateien nach /boot/firmware übernehmen.

Firmware-Verzeichnis kontrollieren:

ls -lh /boot/firmware

Die folgenden Dateien prüfen:

cat /boot/firmware/config.txt
cat /boot/firmware/cmdline.txt

config.txt muss den ARM64-Kernel und das passende Initramfs laden.

cmdline.txt muss Folgendes enthalten:

root=/dev/mapper/cryptroot

Außerdem muss die konfigurierte Initramfs-IP vorhanden sein.

Initramfs-Inhalt prüfen:

lsinitramfs "/boot/initrd.img-$KVER" | less

Im Initramfs müssen die benötigten Cryptsetup-Komponenten, Dropbear, authorized_keys und cryptroot-unlock enthalten sein.

Auch Treiber für Ethernet, USB, Datenträger, Device Mapper und ext4 müssen enthalten sein.

Wenn die Dateien oder Treiber fehlen, nicht mit dem ersten Boot fortfahren.

19. Installation abschließen

chroot verlassen:

exit

Die Variablen für die Partitionen bei Bedarf auf dem Linux-Host erneut festlegen.

UUIDs kontrollieren:

blkid "$BOOT"
cryptsetup luksUUID "$ROOT"

Prüfen, ob die hinterlegten Werte in crypttab und fstab korrekt sind.

Mountpoints anzeigen:

findmnt -R /mnt/pi4

Anschließend alle eingebundenen Dateisysteme sauber aushängen:

umount -R /mnt/pi4

LUKS-Mapping schließen:

cryptsetup close cryptroot

Schreibvorgänge abschließen:

sync

Die SSD kann nun mit dem Raspberry Pi verbunden werden.

20. LUKS über SSH entsperren

Nach dem Einschalten lädt der Raspberry Pi den Kernel und das Initramfs.

Dropbear verwendet die konfigurierte statische Adresse und wartet auf die SSH-Verbindung zur Entsperrung.

Vom Linux-Client verbinden:

ssh -t \
-p 2222 \
-i ~/.ssh/id_initramfs_unlock_pi4 \
root@10.100.0.2

Beim ersten Kontakt den Hostkey-Fingerprint mit dem zuvor dokumentierten Wert vergleichen.

Nach erfolgreicher SSH-Authentifizierung wird cryptroot-unlock gestartet.

Die LUKS-Passphrase eingeben. Anschließend wird die Root-Partition geöffnet und Debian startet.

21. SSH-Client konfigurieren

SSH-Konfiguration öffnen:

nano ~/.ssh/config

Folgende Hosts ergänzen:

Host pi4-unlock
    HostName 10.100.0.2
    User root
    Port 2222
    IdentityFile ~/.ssh/id_initramfs_unlock_pi4
    IdentitiesOnly yes
    RequestTTY force
    StrictHostKeyChecking yes

Host pi4
    HostName 10.100.0.2
    User root
    Port 22
    IdentityFile ~/.ssh/id_pi4_admin
    IdentitiesOnly yes
    StrictHostKeyChecking yes

Die beiden SSH-Dienste verwenden unterschiedliche Hostkeys. Deshalb sollten ihre Fingerprints getrennt überprüft werden.

Die SSH-Verbindung zur Entsperrung kann nach der erstmaligen Hostkey-Prüfung folgendermaßen geöffnet werden:

ssh pi4-unlock

Normale Administration nach dem Boot:

ssh pi4

22. Debian überprüfen

Nach dem erfolgreichen Entsperren über SSH am Debian-System anmelden.

Root-Dateisystem prüfen:

findmnt /

Verschlüsselung prüfen:

cryptsetup status cryptroot

Netzwerk überprüfen:

ip -br address
ip route show default

Die reguläre Management-IP sollte auf vmbr0 liegen.

Systempakete aktualisieren:

apt update
apt full-upgrade

Vor der Proxmox-Installation zunächst einen vollständigen Neustart mit erneuter LUKS-Entsperrung durchführen.

23. Proxmox-Pakete vorbereiten

Für den Raspberry Pi werden angepasste Proxmox-ARM64-Pakete aus dem Community-Projekt PXVIRT verwendet.

Pimox ARM64 RPI Control

PXVIRT

Das vollständige build.sh-Skript wird nicht verwendet, da es Schritte zur automatischen Root-Partitionserweiterung und Netzwerkkonfiguration enthält, die für dieses LUKS-System ungeeignet sind.

Repository herunterladen:

cd /root
git clone https://github.com/topa-LE/pve-arm64-rpi-control.git
cd pve-arm64-rpi-control

Aktuellen Commit anzeigen:

git rev-parse HEAD

Das Skript zur Einrichtung der Paketquelle untersuchen:

less scripts/06_add_proxmox_repo.sh

Die Paketquelle benötigt einen externen Signaturschlüssel. Dessen Fingerprint muss vor dem Hinterlegen unabhängig überprüft werden.

Erst nach entsprechender Prüfung die Paketquelle einrichten:

bash scripts/06_add_proxmox_repo.sh

Verfügbare Pakete prüfen:

apt update
apt-cache policy proxmox-ve

24. Proxmox installieren

Vor der Installation die geplanten Paketänderungen simulieren:

apt-get -s install proxmox-ve

Dabei dürfen der funktionierende Raspberry-Pi-Kernel, raspi-firmware, cryptsetup-initramfs und dropbear-initramfs nicht unkontrolliert entfernt oder ersetzt werden.

Wenn die Paketauflösung kompatibel ist, die Installation starten:

apt install proxmox-ve

Proxmox-Version anzeigen:

pveversion -v

Webdienst kontrollieren:

systemctl status pveproxy --no-pager

Nach der Installation das Initramfs und die Firmware-Konfiguration erneut prüfen, bevor das System neu gestartet wird.

25. Proxmox-Weboberfläche

Nach erfolgreicher Installation ist Proxmox über HTTPS erreichbar:

https://10.100.0.2:8006

Anmeldedaten:

• Benutzer: root
• Passwort: Root-Passwort des Debian-Systems
• Realm: Linux PAM

Das anfängliche TLS-Zertifikat kann selbstsigniert sein. Den Fingerprint vor dem ersten Verbindungsaufbau kontrollieren.

26. Sicherheit und Backups

• SSH-Private-Keys ausschließlich auf dem Client speichern.
• LUKS-Passphrase niemals in Skripten hinterlegen.
• Dropbear-Port 2222 nur aus dem Verwaltungsnetz erreichbar machen.
• Port 8006 nicht öffentlich ins Internet weiterleiten.
• Den LUKS-Header extern und geschützt sichern.
• Updates von Kernel und Initramfs durch einen Neustart überprüfen.
• Alle VM- und Containerdatenträger innerhalb des verschlüsselten Speichers ablegen.
• Keine unverschlüsselte Swap-Partition außerhalb von LUKS erstellen.
• Boot-Partition gegen unbefugte Manipulation schützen.

27. Weiterführende Dokumentation

• Debian – Installation auf ARM-SBCs
• Debian – Raspberry Pi 4
• Debian – ARM64 mit QEMU
• Debian – Cryptsetup und Remote-Unlock
• Pimox ARM64 RPI Control
• Proxmox VE Dokumentation

Stand: Oktober 2026. Installationskonzept für Debian 13 ARM64, LUKS2, Dropbear und Community-Proxmox. Der vollständige Installationsablauf wurde nicht auf der Zielhardware validiert.