Ein Mini-Computer, der nie schläft: Docker, Home Assistant & Jellyfin auf dem Raspberry Pi (Bonus)

Docker Tutorial Deutsch – Bonus: Das komplette Homelab auf dem Raspberry Pi

Ich hatte Docker auf meinem Windows-PC perfekt am Laufen. Home Assistant startete beim Hochfahren automatisch, Jellyfin streamte meine Filme, alles war gut. Außer einem kleinen, immer lauter werdenden Gedanken:

Mein PC läuft 24 Stunden am Tag – wegen Container, die einen Bruchteil seiner Leistung brauchen.

Ich hab mal nachgerechnet. Mein Desktop-PC zieht unter Last um die 150 Watt. Der läuft für Docker im Grunde nur auf Sparflamme – sagen wir 80 Watt im Durchschnitt. Im Monat sind das etwa 58 Kilowattstunden. Bei 30 Cent pro kWh reden wir von rund 17 Euro – jeden Monat, nur damit ein paar Container laufen.

Dann hab ich mir einen Raspberry Pi 4 mit 4 GB RAM hingestellt. Der zieht unter Last etwa 7 Watt. Im Monat: rund 5 Kilowattstunden. Kosten: unter zwei Euro.

Seither läuft mein Desktop-PC, wenn ich ihn brauche. Der Pi läuft immer.

Geht das überhaupt? Die ehrliche Antwort

Ja. Aber – und das ist ein wichtiges Aber – nicht ohne Einschränkungen. Ich möchte dir realistisch zeigen, was du erwarten kannst, bevor du Geld ausgibst.

Was problemlos funktioniert:

Home Assistant im Container läuft auf dem Raspberry Pi 4 und 5 ausgezeichnet. Das ist sogar eine der offiziell empfohlenen Plattformen – inklusive der vollwertigen HAOS-Variante mit Add-on-Store. Automationen, Dashboards, Geräte-Integrationen: alles da, alles flüssig.

Docker und Docker Compose laufen seit Jahren stabil auf dem Pi. Die meisten Container aus Docker Hub gibt es in ARM-Varianten – ARM ist die Prozessor-Architektur des Raspberry Pi, und wir kommen gleich darauf zurück.

Wo es hakelig wird:

Jellyfin läuft – aber die Performance beim Transkodieren ist begrenzt. Der Raspberry Pi 5 hat sogar seinen Hardware-Videodecoder im Vergleich zum Pi 4 verloren, was Transkodierung noch mehr zur CPU-Aufgabe macht. Die Jellyfin-Entwickler selbst sagen, dass die meisten Einplatinencomputer – einschließlich des Raspberry Pi 5 – für eine akzeptable Jellyfin-Erfahrung oft zu langsam sind, da die Hardware-Beschleunigung fehlt oder unzureichend unterstützt wird.

Das klingt hart. Was es in der Praxis bedeutet: Wenn du Dateien in einem Format streamst, das dein Abspielgerät direkt verarbeiten kann (sogenanntes Direct Play), läuft Jellyfin auch auf dem Pi 4 butterweich. Probleme entstehen erst, wenn Jellyfin on-the-fly konvertieren muss. Dazu kommen wir im Troubleshooting-Teil.

Welcher Pi ist der richtige?

Raspberry Pi 4 mit 4 GB RAM ist der Sweet Spot für dieses Setup. Preislich günstig, bewährt, und der Hardware-Videodecoder via V4L2 kann Jellyfin bei H.264-Inhalten wirklich entlasten.

Raspberry Pi 5 hat mehr CPU-Leistung und schnelleres Storage – aber eben keinen Hardware-Videoencoder mehr. Für Home Assistant ist der Pi 5 der bessere Kandidat. Für Jellyfin als Hauptaufgabe würde ich trotzdem zum Pi 4 tendieren.

Raspberry Pi 3 oder älter: Möglich, aber grenzwertig. Für reine Home-Assistant-Installations ohne viele gleichzeitige Automationen reicht ein Pi 3B+ theoretisch – aber für diese Anleitung gehe ich vom Pi 4 aus.

Die SD-Karten-Frage: Das Thema, das niemand gerne anspricht

Bevor wir auch nur eine Zeile tippen, muss ich über Speicher reden. Das ist wichtig – ich hab es auf die harte Tour gelernt.

Raspberry Pis booten standardmäßig von einer SD-Karte. SD-Karten sind schlecht für Docker-Workloads, weil Docker ständig kleine Dateien schreibt. SD-Karten haben eine begrenzte Anzahl von Schreibvorgängen, und billige Karten geben nach wenigen Monaten dauerhaften Docker-Betriebs den Geist auf. Du verlierst alles.

Mein erster Pi-Docker-Aufbau hat nach vier Monaten die SD-Karte zerschrieben. Keine Vorwarnung.

Meine Empfehlung: Eine externe SSD per USB anschließen.

Beim Pi 4 und 5 kannst du direkt von USB booten – ohne SD-Karte. Das ist die sauberste Lösung. Eine 120-GB-SSD kostet kaum mehr als eine hochwertige SD-Karte, ist massiv schneller und hält jahrelang.

Alternativ: Boote weiterhin von SD-Karte, aber leg alle Docker-Volumes (also alle Daten deiner Container) auf eine externe USB-Festplatte oder SSD. Die SD-Karte wird dann nur minimal beschrieben, die Volumes liegen auf robusterem Storage.

Für diese Anleitung gehe ich davon aus, dass du entweder von USB bootest oder eine externe USB-Festplatte unter /mnt/extern eingehängt hast.

Raspberry Pi OS vorbereiten

Ich setze voraus, dass du Raspberry Pi OS bereits installiert hast. Falls nicht: Lade den Raspberry Pi Imager von der offiziellen Raspberry Pi-Website herunter. Dort kannst du das Betriebssystem auf deine SD-Karte oder SSD flashen.

Wichtig: Wähle Raspberry Pi OS Lite (64-bit). Das ist die Version ohne grafische Oberfläche. Du brauchst keinen Desktop – dein Pi wird headless betrieben, also ohne Bildschirm, über SSH ferngesteuert. Das spart RAM und CPU für das, was zählt.

Im Raspberry Pi Imager kannst du vor dem Flashen direkt SSH aktivieren, WLAN konfigurieren und einen Benutzernamen vergeben. Nutze das – dann brauchst du beim ersten Start keinen Bildschirm anzuschließen.

Sobald der Pi hochgefahren ist, verbindest du dich über SSH. Auf Windows öffnest du PowerShell und tippst:

ssh pi@raspberrypi.local

Ersetze pi durch deinen gewählten Benutzernamen. Falls die Verbindung nicht klappt, nutze die IP-Adresse des Pi, die du in deiner Fritzbox oder deinem Router nachschauen kannst.

Zuerst aktualisierst du das System:

sudo apt update && sudo apt upgrade -y

Das dauert ein paar Minuten. Geh kurz Kaffee holen.

Docker installieren – der richtige Weg

Es gibt einen offiziellen Installations-Script von Docker, das den Prozess enorm vereinfacht. Dank eines praktischen Install-Scripts des Docker-Teams ist die Installation auf dem Raspberry Pi ausgesprochen einfach.

curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

Dieser Befehl lädt das Script herunter und führt es aus. Docker erkennt automatisch dein Betriebssystem und deine CPU-Architektur und installiert die passende Version.

Nach der Installation fügst du deinen Benutzer der Docker-Gruppe hinzu. Das erspart dir, bei jedem Docker-Befehl sudo schreiben zu müssen:

sudo usermod -aG docker $USER

Das $USER steht für deinen aktuell eingeloggten Benutzernamen – das brauchst du nicht ersetzen.

Damit die Gruppenänderung wirksam wird, musst du dich einmal abmelden und wieder anmelden. Am einfachsten:

sudo reboot

Nach dem Neustart verbindest du dich erneut per SSH und testest die Installation:

docker --version
docker run hello-world

Wenn du die Bestätigungsnachricht siehst, läuft Docker. Docker Compose ist seit einigen Versionen automatisch als Plugin enthalten – prüfe das kurz:

docker compose version

Du solltest eine Versionsnummer sehen. Wenn nicht, installiere das Plugin nach:

sudo apt install docker-compose-plugin

Ein wichtiger Hinweis: ARM-Architektur und Images

Das ist einer der wenigen Punkte, wo du auf dem Pi in eine Falle tappen kannst, die auf Windows nicht existiert.

Windows läuft auf x86-Prozessoren. Docker-Images, die für x86 gebaut wurden, laufen auf dem Raspberry Pi nicht – der nutzt ARM-Architektur. Wenn du ein x86-Image zu starten versuchst, bekommst du einen Fehler wie exec format error.

Die gute Nachricht: Die meisten populären Images auf Docker Hub existieren inzwischen als Multi-Arch-Images. Das bedeutet, Docker lädt automatisch die richtige Variante für deine Architektur – du musst nichts extra angeben.

Für Images, die du nicht kennst: Schau auf Docker Hub in die Tags und suche nach arm64 oder aarch64 (das ist das 64-Bit-ARM-Format). Wenn kein ARM-Tag existiert, wirst du das Image auf dem Pi nicht zum Laufen bringen.

Home Assistant und Jellyfin (LinuxServer) sind beide Multi-Arch und funktionieren problemlos.

Home Assistant auf dem Pi: Der native Weg

Hier kommt eine gute Nachricht für alle, die in Teil 3 die Add-on-Einschränkung bei der Container-Variante gelesen haben: Auf dem Raspberry Pi kannst du Home Assistant OS (HAOS) installieren – die vollwertige Variante mit Add-on-Store.

Das funktioniert so: Du flashst HAOS als Image direkt auf deine SD-Karte oder SSD (auch über den Raspberry Pi Imager), und HAOS bringt Docker bereits mitgebracht. Du erhältst die vollständige Home Assistant Erfahrung inklusive Supervisor, Add-ons und der eingebauten Backup-Funktion.

Aber das führt zu einer Entscheidung:

Option A: Home Assistant OS auf dem Pi – vollständigste HA-Erfahrung, alle Add-ons verfügbar, aber du läufst kein eigenes Docker-Setup. Der Pi ist dann dedicated für HA.

Option B: Raspberry Pi OS + Docker – du hast volle Kontrolle über den Pi, kannst beliebige Container betreiben, aber Home Assistant läuft in der eingeschränkteren Container-Variante ohne Add-ons.

Option C: Home Assistant OS als VM in Proxmox – für Fortgeschrittene. Proxmox ist ein kostenloses Virtualisierungssystem. Du installierst es auf dem Pi, läufst HAOS als VM darin, und betreibst Docker-Container direkt auf Proxmox. Das Beste aus beiden Welten – aber kein Einsteiger-Setup.

Für diesen Artikel bleibe ich bei Option B: Raspberry Pi OS mit Docker. Das ist die natürliche Weiterführung dieser Serie, und du gewinnst maximale Flexibilität.

Wenn du dir sicher bist, dass der Pi hauptsächlich für Home Assistant da ist, schau dir HAOS an – der Setup ist über den Pi-Imager buchstäblich vier Klicks.

Die Ordnerstruktur auf dem Pi anlegen

Ich lege meine Docker-Projekte auf dem Pi unter /opt/docker ab. /opt ist auf Linux der übliche Ort für optionale, selbst installierte Software.

sudo mkdir -p /opt/docker
sudo chown $USER:$USER /opt/docker

Der chown-Befehl gibt dir als Benutzer die Kontrolle über den Ordner. Danach kannst du ohne sudo darin arbeiten.

Erstelle jetzt die Projektordner:

mkdir -p /opt/docker/homeassistant/config
mkdir -p /opt/docker/jellyfin/config
mkdir -p /opt/docker/jellyfin/cache

Falls du eine externe Festplatte für Mediendateien nutzt, mount sie zunächst. Das geht über /etc/fstab – aber das würde diesen Artikel sprengen. Nutze einfach einen Pfad auf deiner Festplatte, zum Beispiel /mnt/extern/media.

Home Assistant: Die docker-compose.yml für den Pi

nano /opt/docker/homeassistant/docker-compose.yml

nano ist ein einfacher Texteditor im Terminal. Mit Strg + X, dann Y und Enter speicherst du die Datei.

Inhalt:

services:
  homeassistant:
    image: ghcr.io/home-assistant/home-assistant:stable
    container_name: homeassistant
    volumes:
      - ./config:/config
      - /etc/localtime:/etc/localtime:ro
    network_mode: host
    environment:
      TZ: Europe/Berlin
    restart: unless-stopped
    privileged: true

Der wichtigste Unterschied zu Teil 3 (Windows-Version): Hier verwenden wir network_mode: host. Auf Linux funktioniert das einwandfrei, und Home Assistant kann damit deutlich besser Geräte im Heimnetzwerk automatisch erkennen – Philips Hue, Fritzbox, Chromecast, Shelly-Steckdosen, alles was mDNS oder UPnP spricht.

Da wir network_mode: host nutzen, entfällt die ports:-Sektion – der Container teilt direkt das Netzwerk des Pi.

Starten:

cd /opt/docker/homeassistant
docker compose up -d

Home Assistant ist erreichbar unter http://[IP-des-Pi]:8123.

Jellyfin: Die docker-compose.yml für den Pi 4

Hier machen wir etwas, was auf Windows nicht möglich war: Wir reichen dem Container die Hardware-Video-Devices des Pi 4 durch.

nano /opt/docker/jellyfin/docker-compose.yml

services:
  jellyfin:
    image: lscr.io/linuxserver/jellyfin:latest
    container_name: jellyfin
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Europe/Berlin
    volumes:
      - ./config:/config
      - ./cache:/cache
      - /mnt/extern/media/filme:/data/movies
      - /mnt/extern/media/serien:/data/tvshows
      - /mnt/extern/media/musik:/data/music
    devices:
      - /dev/video10:/dev/video10
      - /dev/video11:/dev/video11
      - /dev/video12:/dev/video12
    group_add:
      - "video"
    ports:
      - "8096:8096"
    restart: unless-stopped

Die devices:-Sektion reicht die V4L2-Video-Devices des Pi 4 in den Container durch. Damit kann Jellyfin die Hardware-Beschleunigung für H.264 nutzen. Der Raspberry Pi 4 enthält einen Hardware-Video-Encoder/-Decoder über V4L2 – dieser übernimmt die Video-Transkodierung von der CPU, was die Last während der Wiedergabe erheblich reduziert.

group_add: "video" gibt dem Jellyfin-Prozess im Container Zugriff auf die Video-Geräte.

Hinweis für Pi 5 Nutzer: Die /dev/video10-12 Devices können auf dem Pi 5 anders heißen oder fehlen. Prüfe mit ls /dev/video* welche Video-Devices vorhanden sind. Falls keine auftauchen, lasse die devices:-Sektion weg – Jellyfin läuft dann ohne Hardware-Beschleunigung, nutzt aber auch so die CPU-Stärke des Pi 5.

Starten:

cd /opt/docker/jellyfin
docker compose up -d

Jellyfin erreichst du unter http://[IP-des-Pi]:8096.

Hardware-Beschleunigung in Jellyfin aktivieren

Nachdem Jellyfin läuft, musst du die Hardware-Beschleunigung noch in der Oberfläche einschalten. Das macht Jellyfin nicht automatisch.

Gehe in Jellyfin auf Dashboard → Wiedergabe → Transcodierung.

Unter „Hardwarebeschleunigung“ wähle Video4Linux2 (V4L2). Speichern.

Ab jetzt nutzt Jellyfin beim Transkodieren von H.264-Inhalten die Hardware des Pi – die CPU-Last sinkt spürbar.

Automatischer Start nach Stromausfall

Das ist ein Punkt, der auf einem Heimserver anders ist als auf einem Desktop-PC: Der Pi bootet nach einem Stromausfall automatisch neu. Docker ebenfalls – aber du musst sicherstellen, dass der Docker-Dienst beim Systemstart aktiv ist:

sudo systemctl enable docker
sudo systemctl enable containerd

Mit restart: unless-stopped in deinen Compose-Dateien starten alle Container nach einem Neustart automatisch. Kein manuelles Eingreifen nötig.

Teste das einmal bewusst: Fahre den Pi sauber herunter, ziehe den Strom, stecke ihn wieder ein. Nach etwa 60 Sekunden solltest du Home Assistant und Jellyfin wieder erreichen können.

Troubleshooting: Die Pi-spezifischen Probleme

exec format error beim Container-Start Du versuchst ein x86-Image auf dem ARM-Pi zu starten. Schau auf Docker Hub nach einer arm64-Version. Wenn es keine gibt, ist dieses Image auf dem Pi nicht lauffähig.

Jellyfin findet keine Mediendateien Prüfe zuerst, ob die externe Festplatte korrekt gemountet ist:

ls /mnt/extern/media/filme

Wenn das Verzeichnis leer ist oder einen Fehler wirft, ist die Festplatte nicht gemountet. Prüfe mit lsblk welche Geräte angeschlossen sind und wie du sie in /etc/fstab einträgst.

Jellyfin ruckelt trotz V4L2 Überprüfe zunächst, ob die V4L2-Devices wirklich vorhanden sind:

ls /dev/video*

Du solltest /dev/video10, /dev/video11 und /dev/video12 sehen. Wenn nicht, ist der Kernel-Treiber nicht geladen. Füge folgende Zeile zur Datei /boot/config.txt (Pi 4) oder /boot/firmware/config.txt (Pi 5) hinzu:

dtoverlay=vc4-kms-v3d

Starte den Pi neu. Außerdem: Prüfe in Jellyfin unter Dashboard → Transcodierung ob V4L2 ausgewählt ist und ob beim Abspielen tatsächlich transcodiert wird. Manche Clients können Dateien direct playen – dann wird gar nicht transkodiert, und die CPU-Last ist sowieso minimal.

SD-Karte voll Docker-Images können viel Platz verbrauchen. Prüfe den Speicherstand mit:

df -h
docker system df

Aufräumen mit:

docker system prune -a

Das löscht alle ungenutzten Images, Container und Netzwerke. Volumes bleiben davon unberührt.

Pi reagiert langsam oder friert ein Prüfe die Auslastung:

docker stats

Das zeigt CPU- und RAM-Verbrauch aller laufenden Container in Echtzeit. Falls ein Container zu viel RAM frisst, kannst du in der Compose-Datei ein Limit setzen:

deploy:
  resources:
    limits:
      memory: 512M

Home Assistant schreibt ständig auf die SD-Karte Home Assistant hat eine eingebaute SQLite-Datenbank, in die es ständig Messwerte schreibt. Das ist der Hauptkiller für SD-Karten. Langfristige Lösung: Die config-Volume auf eine externe SSD auslagern. Kurzfristige Lösung in der HA-Konfiguration: Die Aufzeichnungs-Dauer für den Recorder reduzieren (Einstellungen → System → Recorder).

Der Stromverbrauch – konkret nachgemessen

Ich hab das mit einer smarten Steckdose mit Energiemessung durchgezählt. Hier meine realen Werte für einen Raspberry Pi 4 (4 GB) mit laufendem Home Assistant Container, Jellyfin und Portainer:

• Leerlauf (alle Container aktiv, keine Streams): ca. 4–5 Watt
• Jellyfin streamt einen Film (Direct Play): ca. 6–7 Watt
• Jellyfin transkodiert aktiv: ca. 8–10 Watt
• Home Assistant verarbeitet viele Automationen: minimal spürbar, unter 1 Watt Mehrverbrauch

Im Jahresvergleich zum Desktop-PC, der für diese Aufgabe lief:

Der Pi hat sich durch die Stromersparnis in unter drei Monaten amortisiert.

Fazit: Klein, leise, immer an – und das völlig zu Recht

Ich bin ein großer Freund davon, Dinge auf dem eigenen Windows-PC auszuprobieren. Genau dafür war Teil 1 bis 3 dieser Serie gedacht: Du verstehst Docker, du lernst Compose, du siehst wie Container funktionieren – auf vertrautem Terrain.

Aber wenn das Homelab in den Dauerbetrieb gehen soll, ist der Raspberry Pi einfach die bessere Wahl. Wenig Strom, kein Lärm, 24/7 verfügbar, und die Docker-Kenntnisse aus dieser Serie überträgst du eins zu eins.

Die docker-compose.yml-Dateien aus Teil 3 funktionieren – mit den kleinen Anpassungen in diesem Artikel – nahezu identisch auf dem Pi. Du musst kein neues System lernen. Du nimmst, was du weißt, und pflanzt es auf neue Hardware.

Das ist die eigentliche Stärke von Docker: Dein Setup reist mit.

Wenn du noch weiterdenken möchtest: Ein Raspberry Pi als Basis lässt sich hervorragend mit einem Nginx Proxy Manager ergänzen, der dir erlaubt, alle Dienste sauber unter einem Port erreichbar zu machen – optional mit HTTPS-Zertifikat, auch im Heimnetz. Oder mit Pi-hole, dem DNS-basierten Werbeblocker fürs gesamte Heimnetzwerk. Beides: Docker Container, beide: einfach per Compose deploy-bar.

Das Rabbit Hole ist tief. Ich finde das gut so.

[← Teil 3 – Home Assistant & Jellyfin im Docker Container auf Windows]

[← Teil 2 – Docker Compose einrichten für Selfhosting]

[← Teil 1 – Docker Grundlagen und Installation unter Windows]