Anleitung: Wie Sie ein Backup Ihres BananaPi M1 virtualisieren und als VM zum Laufen bringen

Haben Sie einen Banana Pi M1, der zuverlässig seine Dienste verrichtet, aber Sie machen sich Gedanken über Datensicherheit, Hardwareausfälle oder möchten einfach eine Testumgebung schaffen? Dann ist dieser Artikel genau das Richtige für Sie! Wir zeigen Ihnen Schritt für Schritt, wie Sie ein Backup Ihres Banana Pi M1 erstellen, dieses virtualisieren und als virtuelle Maschine (VM) auf einem Standard-Linux-Host zum Laufen bringen. Dies eröffnet Ihnen ungeahnte Möglichkeiten – von der einfachen Wiederherstellung bis hin zur Entwicklung und zum Testen von Software in einer sicheren, isolierten Umgebung.

Die Virtualisierung eines ARM-basierten Einplatinencomputers wie des Banana Pi M1 auf einem x86-64-Host ist keine direkte Virtualisierung im klassischen Sinne, sondern vielmehr eine Emulation. Das bedeutet, Ihr Host-Computer imitiert die ARM-Architektur des Banana Pi, um dessen Betriebssystem und Anwendungen auszuführen. Dies ist ein leistungsstarkes Werkzeug, das Ihnen Flexibilität und Redundanz bietet, auch wenn die Performance aufgrund der Emulation nicht mit der nativen Hardware vergleichbar sein wird.

Warum Sie Ihren Banana Pi M1 virtualisieren sollten

Es gibt viele gute Gründe, ein Backup als VM zu betreiben:

• Disaster Recovery: Im Falle eines Hardwaredefekts Ihres Banana Pi M1 können Sie Ihr System schnell auf einem anderen Host als VM starten und so Ausfallzeiten minimieren.
• Testumgebung: Bevor Sie kritische Updates oder neue Software auf Ihrem physischen Banana Pi installieren, können Sie diese gefahrlos in der VM testen.
• Entwicklung: Entwickeln Sie Anwendungen für Ihren Banana Pi, ohne ständig eine SD-Karte wechseln oder neu flashen zu müssen.
• Migration: Eine virtualisierte Instanz ist oft einfacher auf neue Hardware (oder zurück auf einen anderen Banana Pi) zu migrieren.
• Archivierung: Bewahren Sie funktionierende Konfigurationen Ihres Banana Pi als jederzeit startbereite VMs auf.

Voraussetzungen für die Virtualisierung

Bevor wir loslegen, stellen Sie sicher, dass Sie die folgenden Dinge zur Hand haben:

• Einen Banana Pi M1 mit einer funktionierenden SD-Karte, von der Sie das Backup erstellen möchten.
• Einen leistungsstarken Linux-Host-Computer (z.B. Ubuntu, Debian oder Fedora) mit ausreichend Speicherplatz (mindestens 20-30 GB für das Image und temporäre Dateien) und Arbeitsspeicher (mindestens 4 GB RAM, besser 8 GB oder mehr).
• Einen SD-Kartenleser für Ihren Linux-Host.
• Grundlegende Linux-Kenntnisse und die Fähigkeit, das Terminal zu bedienen.
• Eine Internetverbindung, um benötigte Pakete zu installieren.

Schritt 1: Erstellen Sie ein vollständiges Image Ihrer Banana Pi SD-Karte

Der erste und wichtigste Schritt ist das Erstellen eines präzisen Backups Ihrer SD-Karte. Dies wird das Quell-Image für Ihre zukünftige VM sein.

1. Banana Pi herunterfahren und SD-Karte entnehmen

   Stellen Sie sicher, dass Ihr Banana Pi M1 ordnungsgemäß heruntergefahren ist (sudo shutdown now) und trennen Sie ihn von der Stromversorgung. Entnehmen Sie anschließend die SD-Karte.

2. SD-Karte an den Linux-Host anschließen

   Stecken Sie die entnommene SD-Karte in den Kartenleser Ihres Linux-Host-Computers.

3. Gerätenamen der SD-Karte identifizieren

   Bevor Sie mit dem Klonen beginnen, müssen Sie den korrekten Gerätenamen Ihrer SD-Karte identifizieren. Seien Sie hierbei äußerst vorsichtig, da die falsche Auswahl zu Datenverlust auf Ihrem Host-System führen kann! Öffnen Sie ein Terminal und geben Sie ein:

   lsblk

   oder

   sudo fdisk -l

   Suchen Sie nach einem Gerät, dessen Größe der Ihrer SD-Karte entspricht (z.B. 8 GB, 16 GB, 32 GB). Es könnte als /dev/sdX (wobei X ein Buchstabe wie ‘b’, ‘c’, ‘d’ usw. ist) oder /dev/mmcblk0 erscheinen. Nehmen wir an, es ist /dev/sdb. Überprüfen Sie dies mehrfach!

4. SD-Karten-Image erstellen

   Nun klonen wir die gesamte SD-Karte in eine Image-Datei. Verwenden Sie dafür den dd-Befehl. Ersetzen Sie /dev/sdb durch den zuvor identifizierten Gerätenamen Ihrer SD-Karte und /pfad/zum/backup/banana_pi_backup.img durch den gewünschten Speicherort und Dateinamen für Ihr Image.

   sudo dd if=/dev/sdb of=/pfad/zum/backup/banana_pi_backup.img bs=4M status=progress

   Dieser Vorgang kann je nach Größe und Geschwindigkeit der SD-Karte sowie Ihres Hosts einige Zeit in Anspruch nehmen. Der Parameter status=progress zeigt Ihnen den Fortschritt an.

   Nachdem der Vorgang abgeschlossen ist, haben Sie eine exakte Kopie Ihrer SD-Karte als .img-Datei.

Schritt 2: Vorbereiten des Images für die Virtualisierung (QEMU)

Wir werden QEMU verwenden, um die ARM-Architektur zu emulieren und Ihr Banana Pi Image als VM zu starten. QEMU ist ein Open-Source-Emulator und Virtualisierer, der auch die Emulation verschiedener CPU-Architekturen unterstützt.

1. QEMU installieren

   Installieren Sie QEMU auf Ihrem Linux-Host. Für Debian/Ubuntu-basierte Systeme:

   sudo apt update
   sudo apt install qemu-system-arm qemu-utils

   Für Fedora/RHEL-basierte Systeme:

   sudo dnf install qemu-system-arm qemu-img

2. Image-Format konvertieren (optional, aber empfohlen)

   Das Roh-Image (.img) funktioniert, aber das QCOW2-Format (QEMU Copy On Write) ist effizienter, da es dynamisch wächst, Snapshots unterstützt und Kompression bietet. Konvertieren Sie Ihr Image:

   qemu-img convert -f raw -O qcow2 /pfad/zum/backup/banana_pi_backup.img /pfad/zum/vm/banana_pi_vm.qcow2

   Speichern Sie die .qcow2-Datei in einem dedizierten Verzeichnis für Ihre VMs.

3. ARM-Kernel und Initramfs für QEMU beschaffen

   Dies ist der kniffligste Teil. QEMU kann das Betriebssystem auf Ihrem Image nicht direkt starten, ohne einen kompatiblen ARM-Kernel und ein Initramfs (initial RAM filesystem) bereitzustellen, die für die QEMU-Emulation geeignet sind. Die Kernel auf Ihrer SD-Karte sind oft zu spezifisch für die physische Banana Pi Hardware und funktionieren möglicherweise nicht direkt in der QEMU-Emulationsumgebung.

   Sie benötigen generische ARM-Kernel für die QEMU-Maschinentypen. Suchen Sie in den Paketquellen Ihrer Linux-Distribution nach Kerneln für qemu-system-arm. Oft sind diese in Paketen wie linux-image-armhf (für 32-Bit ARM) oder spezifischeren QEMU-Kernelpaketen enthalten. Manchmal finden Sie diese auch unter /usr/lib/qemu-system-arm/ oder in ähnlichen Verzeichnissen, oder Sie müssen sie manuell herunterladen (z.B. von offiziellen Debian-Quellen, die für QEMU-Emulation vorgesehen sind).

   Ein bewährter Ansatz: Suchen Sie nach „virt” Kerneln für ARM. Für Debian/Ubuntu könnten Sie z.B. nach Paketen wie linux-image-*-armhf suchen. Nach der Installation finden Sie die Kernel- und Initramfs-Dateien meistens in /boot/ auf Ihrem Host oder in einem speziellen QEMU-Verzeichnis.

   Für unser Beispiel nehmen wir an, Sie haben einen passenden Kernel (vmlinuz-qemu-arm) und ein Initramfs (initrd.img-qemu-arm) im selben Verzeichnis wie Ihre .qcow2-Datei.

   Tipp: Wenn Sie keinen passenden Kernel finden, kann eine Suchmaschine mit „qemu arm kernel initrd debian” oder „qemu arm kernel ubuntu” oft weiterhelfen, oder Sie können die Kernel-Dateien von einer offiziellen Debian- oder Armbian-QEMU-Seite herunterladen, die für die `virt` Maschine gedacht sind.
   Ein häufig verwendeter generischer Kernel für ARMv7 ist z.B. `vmlinuz-linux-armhf` und `initrd.img-linux-armhf` wenn Sie ein `armhf` System auf Ihrem Banana Pi haben. Versuchen Sie diese aus einem entsprechenden Debian/Ubuntu ARM-Paket zu extrahieren oder herunterzuladen.

Schritt 3: Starten der Banana Pi VM mit QEMU

Jetzt ist es Zeit, Ihre virtualisierte Banana Pi M1-Instanz zu starten. Wir verwenden einen QEMU-Befehl, der verschiedene Parameter für die Emulation festlegt.

1. QEMU-Befehl zusammenstellen

   Öffnen Sie ein Terminal im Verzeichnis, in dem sich Ihre .qcow2-Datei, der Kernel und das Initramfs befinden. Der Befehl ist komplex, also erklären wir die einzelnen Teile:

   qemu-system-arm 
   -M virt 
   -cpu cortex-a7 
   -smp 2 
   -m 1024M 
   -kernel ./vmlinuz-qemu-arm 
   -initrd ./initrd.img-qemu-arm 
   -append "root=/dev/sda2 rw console=ttyAMA0,115200" 
   -drive file=banana_pi_vm.qcow2,if=sd,format=qcow2 
   -netdev user,id=net0 
   -device virtio-net-device,netdev=net0 
   -nographic

   • qemu-system-arm: Startet QEMU für die ARM-Architektur.
   • -M virt: Wählt das generische „virt”-Maschinenmodell, das gut mit QEMU zusammenarbeitet.
   • -cpu cortex-a7: Emuliert eine Cortex-A7 CPU, passend zum Allwinner A20 des Banana Pi M1.
   • -smp 2: Weist der VM 2 virtuelle CPUs zu (der A20 ist Dual-Core).
   • -m 1024M: Weist der VM 1024 MB RAM zu (anpassbar, max. 1 GB für den Banana Pi M1).
   • -kernel ./vmlinuz-qemu-arm: Pfad zum ARM-Kernel, den Sie zuvor beschafft haben.
   • -initrd ./initrd.img-qemu-arm: Pfad zum ARM-Initramfs.
   • -append "root=/dev/sda2 rw console=ttyAMA0,115200": Dies sind Kernel-Parameter.
     • root=/dev/sda2: Wichtig! Dies teilt dem Kernel mit, wo das Root-Dateisystem liegt. Auf den meisten Banana Pi/Raspberry Pi Images ist das Root-Dateisystem auf der zweiten Partition. Um sicherzugehen, können Sie das Image mounten oder mit fdisk -l /pfad/zum/backup/banana_pi_backup.img die Partitionen prüfen. Wenn das Original-Root-FS auf /dev/mmcblk0p2 war, wird es in QEMU wahrscheinlich zu /dev/sda2.
     • rw: Schreibt das Dateisystem im Lese-Schreib-Modus.
     • console=ttyAMA0,115200: Leitet die Konsolenausgabe an die serielle Schnittstelle um, die wir mit -nographic abfangen.
   • -drive file=banana_pi_vm.qcow2,if=sd,format=qcow2: Bindet Ihre QCOW2-Datei als SD-Karte (if=sd) in die VM ein.
   • -netdev user,id=net0: Richtet ein benutzerbasiertes Netzwerk ein (einfachste Option).
   • -device virtio-net-device,netdev=net0: Fügt eine VirtIO-Netzwerkkarte hinzu (schneller).
   • -nographic: Zeigt die Konsolenausgabe direkt im Terminal an, ohne ein GUI-Fenster. Für den ersten Start und die Fehlersuche ist dies oft am besten.

   Achtung: Die genauen Pfade für Kernel und Initramfs müssen korrekt sein. Passen Sie root=/dev/sdaX an, falls Ihr Root-Dateisystem auf einer anderen Partition liegt (z.B. /dev/sda1).

2. Erster Start und Login

   Führen Sie den QEMU-Befehl aus. Wenn alles richtig konfiguriert ist, sollten Sie die Boot-Meldungen Ihres Banana Pi Betriebssystems im Terminal sehen. Nach einer Weile sollte ein Login-Prompt erscheinen. Melden Sie sich mit den Standard-Anmeldedaten Ihres Banana Pi OS an (z.B. Benutzer pi, Passwort raspberry für Raspbian oder root, 1234 für Armbian, oder die von Ihnen festgelegten).

Schritt 4: Konfiguration und Troubleshooting nach dem ersten Start

Nach dem erfolgreichen Start gibt es ein paar Dinge, die Sie anpassen sollten.

1. Anpassung der fstab

   Ihr originaler Banana Pi verwendete möglicherweise Gerätenamen wie /dev/mmcblk0p1 oder UUIDs in /etc/fstab. In der QEMU-VM werden diese Partitionen als /dev/sda1, /dev/sda2 usw. erscheinen. Es ist ratsam, /etc/fstab in der VM anzupassen, um die korrekten Gerätenamen zu verwenden oder auf UUIDs/PARTUUIDs umzusteigen, die konsistenter sind.

   Bearbeiten Sie die Datei mit sudo nano /etc/fstab und stellen Sie sicher, dass die Root-Partition (und andere, falls vorhanden) korrekt gemountet wird, z.B. /dev/sda2 / ext4 defaults,noatime 0 1. Oder verwenden Sie UUID=..., was robuster ist.

2. Netzwerkkonfiguration

   Mit der Option -netdev user erhält Ihre VM eine IP-Adresse im Netzwerkbereich 10.0.2.x, und der Host leitet Anfragen für sie weiter. Dies ist ideal für ausgehenden Internetzugriff, aber der Host kann die VM nicht direkt erreichen, es sei denn, Sie richten Port-Weiterleitungen ein (-netdev user,id=net0,hostfwd=tcp::2222-:22 würde SSH auf Port 22 der VM auf Port 2222 des Hosts weiterleiten).

   Wenn Sie direkten Netzwerkzugriff auf die VM benötigen, sollten Sie eine Bridge-Netzwerkkonfiguration auf Ihrem Host einrichten. Dies ist komplexer und erfordert, dass Ihr Host-System eine Bridge erstellt, in die die VM eingebunden wird, sodass sie eine IP-Adresse im selben Subnetz wie Ihr Host erhält.

3. SSH-Zugriff

   Sobald die Netzwerkkonfiguration funktioniert und SSH auf der VM aktiviert ist (Standard für die meisten Linux-Distributionen), können Sie sich per SSH mit der VM verbinden. Wenn Sie Port-Weiterleitung eingerichtet haben (z.B. Port 2222 auf dem Host zu Port 22 der VM), verwenden Sie:

   ssh -p 2222 user@localhost

   Andernfalls, wenn Sie eine Bridge eingerichtet haben, verbinden Sie sich mit der direkten IP-Adresse der VM.

4. Installieren von QEMU Guest Agent (falls möglich)

   Wenn das Gastbetriebssystem einen QEMU Guest Agent zur Verfügung stellt (auf ARM-Distributionen seltener), können Sie diesen installieren, um eine bessere Kommunikation zwischen Host und Gast zu ermöglichen (z.B. sauberes Herunterfahren).

5. Grafische Ausgabe (optional)

   Wenn Sie eine grafische Oberfläche für Ihren Banana Pi eingerichtet hatten, möchten Sie diese möglicherweise auch in der VM nutzen. Ersetzen Sie -nographic durch -vnc :0 und verbinden Sie sich mit einem VNC-Client zu localhost:5900, oder verwenden Sie -sdl, um ein SDL-Fenster zu öffnen.

Schritt 5: Virtualisierung dauerhaft und komfortabel gestalten

Um die VM nicht ständig über die Kommandozeile starten zu müssen, können Sie ein Shell-Skript erstellen, das den QEMU-Befehl enthält. Sie könnten auch Tools wie virt-manager nutzen, allerdings ist dessen Unterstützung für ARM-Emulation auf x86-Hosts oft begrenzt und erfordert manuelle XML-Konfiguration.

Ein einfaches Startskript (start_banana_pi_vm.sh):

#!/bin/bash
QEMU_PATH="/usr/bin" # Oder wo qemu-system-arm installiert ist
KERNEL="./vmlinuz-qemu-arm"
INITRD="./initrd.img-qemu-arm"
IMAGE="./banana_pi_vm.qcow2"

"$QEMU_PATH/qemu-system-arm" 
-M virt 
-cpu cortex-a7 
-smp 2 
-m 1024M 
-kernel "$KERNEL" 
-initrd "$INITRD" 
-append "root=/dev/sda2 rw console=ttyAMA0,115200" 
-drive file="$IMAGE",if=sd,format=qcow2 
-netdev user,id=net0,hostfwd=tcp::2222-:22 
-device virtio-net-device,netdev=net0 
-nographic

Machen Sie das Skript ausführbar (chmod +x start_banana_pi_vm.sh) und starten Sie es bei Bedarf.

Fazit

Die Virtualisierung Ihres Banana Pi M1 als QEMU-VM ist ein leistungsstarkes Verfahren, um Ihre Projekte zu sichern, zu testen und zu entwickeln. Auch wenn die Einrichtung aufgrund der ARM-Emulation auf einem x86-Host etwas komplexer ist als bei reiner Virtualisierung, ist der Nutzen immens. Sie haben nun eine flexible und unabhängige Kopie Ihres Systems, die Sie nach Belieben manipulieren können, ohne das Risiko, Ihre physische Hardware zu beeinträchtigen.

Experimentieren Sie mit den QEMU-Parametern, um die beste Performance und Funktionalität für Ihre spezifischen Bedürfnisse zu finden. Denken Sie daran, dass regelmäßige Backups der .qcow2-Datei ebenso wichtig sind wie das Original auf der SD-Karte. So sind Sie bestens für alle Eventualitäten gerüstet und können das volle Potenzial Ihres Banana Pi M1 ausschöpfen!