Raspberry Pi Heimserver: Docker, AdGuard & Traefik

Ein Raspberry Pi eignet sich hervorragend als energiesparender Heimserver. In dieser Anleitung zeige ich dir, wie du einen Raspberry Pi mit Docker, AdGuard Home (DNS-Server / Werbeblocker), Traefik (Reverse Proxy), Heimdall (Dashboard) und einer UFW-Firewall aufsetzt - Schritt für Schritt, von der OS-Installation bis zum produktiven Betrieb.

Möchtest du lieber zuschauen? Eine Anleitung gibt es auch als YouTube-Video.

Key Takeaways

• Ein Raspberry Pi 4 oder 5 verbraucht nur 3-10 Watt und eignet sich ideal als 24/7-Heimserver
• Docker mit AdGuard Home blockiert Werbung netzwerkweit auf DNS-Ebene
• Traefik v3 als Reverse Proxy verwaltet Domains und SSL-Zertifikate automatisch
• UFW-Firewall schützt den Server, muss aber speziell für Docker konfiguriert werden
• Gesamtkosten: ca. 10-17 € Stromkosten pro Jahr bei Dauerbetrieb

Voraussetzungen und Hardware-Empfehlungen

Für einen zuverlässigen Heimserver brauchst du nicht zwingend den neuesten Raspberry Pi. Als Minimum empfehle ich einen Raspberry Pi 4 mit mindestens 4 GB RAM - mehr Arbeitsspeicher zahlt sich aus, wenn du mehrere Dienste parallel betreiben willst. Grundsätzlich funktioniert diese Anleitung auch auf anderen Geräten mit Debian-basiertem Betriebssystem, etwa Mini-PCs.

Finger weg von SD-Karten als Systemspeicher! SD-Karten sind für den Dauerbetrieb und die vielen kleinen Schreibzugriffe eines Servers ungeeignet. Sie haben begrenzte Schreib-/Lesezyklen und fallen bei intensiver Nutzung oft unerwartet aus. Stattdessen empfehle ich dringend eine externe SSD über USB 3.0. Die Vorteile: höhere Geschwindigkeit, längere Lebensdauer, geringeres Risiko von Datenverlust.

Ein großer Vorteil des Raspberry Pi bleibt sein geringer Stromverbrauch. Ein Raspberry Pi 5 benötigt etwa 4-5 Watt im Leerlauf und bis zu 10 Watt unter Volllast. Gemessen an einem ausgewachsenen Server oder einem alten Laptop ist das immer noch sehr sparsam. Bei einem Strompreis von 40 Cent/kWh kostet jeder Watt ca. 3,50 € im Jahr. Läuft ein Gerät 24 Stunden am Tag an 365 Tagen steigen die Stromkosten um ca. 17 € pro Jahr.

Berechne hier deine ungefähren jährlichen Stromkosten:

Betriebssystem installieren: Headless-Setup mit Raspberry Pi OS

Der Raspberry Pi Imager ist über die Jahre deutlich komfortabler geworden und erlaubt viele Vorkonfigurationen direkt beim Erstellen des Boot-Mediums.

1. Lade den aktuellen Raspberry Pi Imager von der offiziellen Website herunter und installiere ihn.
2. Wähle dein Raspberry Pi Modell aus.
3. Wähle als Betriebssystem “Raspberry Pi OS Lite (64-bit)” (unter “Raspberry Pi OS (other)”). Die 64-Bit-Version ist mittlerweile die Standardempfehlung. Die Lite-Version kommt ohne grafische Oberfläche aus und spart wertvolle Systemressourcen.
4. Wähle als Speichermedium deine angeschlossene externe SSD aus.
5. Klicke auf “Weiter” und dann auf “Einstellungen bearbeiten”. Hier nimmst du wichtige Voreinstellungen vor:
   • Hostname: Gib deinem Pi einen Namen (z.B. raspberrypi.local).
   • Benutzername und Passwort: Lege einen sicheren Benutzernamen und ein starkes Passwort fest. Vermeide den alten Standard “pi”.
   • WLAN konfigurieren: Gib deine WLAN-Daten ein, falls du kein LAN-Kabel verwendest. LAN ist für den Serverbetrieb empfohlen.
   • Locale-Einstellungen: Setze Sprache und Tastaturlayout (z.B. de, Europe/Berlin).
   • Dienste: Aktiviere SSH unbedingt! Wähle “Passwort-Authentifizierung verwenden”. Ohne SSH brauchst du Monitor und Tastatur.
6. Speichere die Einstellungen und klicke auf “Ja” bzw. “Schreiben”, um den Vorgang zu starten.

Nach Abschluss kann die SSD an den Raspberry Pi (an einen blauen USB 3.0 Port!) angeschlossen und der Pi gestartet werden.

Raspberry Pi ans Netzwerk anschließen

Nach dem ersten Start verbindest du dich per SSH mit deinem Pi. Die IP-Adresse findest du in der Oberfläche deines Routers. Unter Windows, macOS oder Linux geht das im Terminal:

ssh dein_benutzername@ip-adresse-des-pi
# Beispiel: ssh pi-admin@192.168.178.50

Bestätige beim ersten Verbinden den Fingerprint mit yes.

Feste IP-Zuweisung

Es empfiehlt sich, dem Raspberry Pi eine dauerhafte IP-Adresse zuzuweisen. Das geht in den meisten Routereinstellungen. In einer Fritz!Box findest du das unter Heimnetz > Netzwerk > Netzwerkeinstellungen, wenn du auf die Details des Geräts klickst.

Problem: Vodafone Station

Mein Raspberry Pi bekam an der Vodafone Station nach einer Neuinstallation keine IP-Adresse mehr zugewiesen. Ich vermute, es hängt mit dem DHCP-Server der Vodafone Station zusammen. Falls du dasselbe Problem hast: Prüfe, ob du im Router die MAC-Adresse des Pi manuell einer festen IP zuweisen kannst.

Grundkonfiguration des Raspberry Pi OS

Nach der erfolgreichen SSH-Verbindung bringen wir das System auf den neuesten Stand:

sudo apt update -y
sudo apt upgrade -y
sudo apt autoremove -y

Das kann einige Zeit dauern. Im Anschluss prüfen wir wichtige Systemeinstellungen:

# Zeitzone überprüfen (sollte durch Imager korrekt sein)
date

# Falls doch nötig, Zeitzone manuell setzen:
# sudo timedatectl set-timezone 'Europe/Berlin'

# Systemauslastung beobachten (mit Strg+C beenden)
htop

# CPU-Temperatur überwachen
cat /sys/class/thermal/thermal_zone0/temp

Der letzte Befehl zeigt die CPU-Temperatur in Milligrad Celsius an. Teile den Wert durch 1000 (z.B. 52123 = 52.123 °C). Bei längerer Nutzung unter Last, besonders beim Raspberry Pi 5, ist eine adäquate Kühlung (passiv oder aktiv) unerlässlich, um Leistungsdrosselung zu vermeiden.

sudo apt install zsh
curl -fsSL https://raw.githubusercontent.com/zimfw/install/master/install.zsh | zsh
chsh -s /usr/bin/zsh
exec bash

mkdir -p ~/.zsh/completion
curl -L https://raw.githubusercontent.com/docker/compose/1.29.1/contrib/completion/zsh/_docker-compose -o ~/.zsh/completion/_docker-compose

fpath=(~/.zsh/completion $fpath)
autoload -Uz compinit && compinit -i

sudo reboot

Docker und Docker Compose installieren

Docker ist der De-facto-Standard für die Containerisierung von Anwendungen. Es erlaubt uns, Dienste isoliert in Containern laufen zu lassen, ohne uns um Abhängigkeitskonflikte kümmern zu müssen. Die Installation erfolgt über die offiziellen Docker-Repositories:

# 1. Notwendige Pakete installieren
sudo apt update
sudo apt install -y ca-certificates curl gnupg

# 2. Dockers offiziellen GPG-Schlüssel hinzufügen
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

# 3. Docker Repository hinzufügen
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/debian \
  $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 4. Docker Engine, CLI, Containerd und Compose Plugin installieren
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Docker Compose ist heute als Plugin direkt in Docker integriert und muss nicht mehr separat installiert werden.

Überprüfe die Installation:

docker --version
docker compose version

Wir erstellen eine Grundstruktur für unsere Docker-Konfigurationen:

mkdir -p ~/docker
cd ~/docker

AdGuard Home als netzwerkweiter Werbeblocker einrichten

Statt Blocky oder Pi-hole setzen wir auf AdGuard Home. Es blockiert Werbung und Tracker auf DNS-Ebene für dein gesamtes Netzwerk, bietet eine moderne Weboberfläche und wird aktiv weiterentwickelt.

1. Verzeichnisse erstellen:

   mkdir -p ~/docker/adguard/{work,conf}
   cd ~/docker/adguard

2. Docker Compose Datei erstellen:

   nano docker-compose.yml

   Füge folgende Konfiguration ein:

   # ~/docker/adguard/docker-compose.yml
   services:
       adguard:
           image: adguard/adguardhome:latest
           container_name: adguard-home
           restart: unless-stopped
           ports:
               - "53:53/tcp"
               - "53:53/udp"
               - "3000:3000/tcp"
           volumes:
               - ./work:/opt/adguardhome/work
               - ./conf:/opt/adguardhome/conf
           environment:
               TZ: Europe/Berlin
           networks:
               - proxy
           labels:
               - "traefik.enable=true"
               - "traefik.http.routers.adguard-http.rule=Host(`adguard.home`)"
               - "traefik.http.routers.adguard-http.entrypoints=web"
               - "traefik.http.services.adguard.loadbalancer.server.port=80"
   
   networks:
       proxy:
           external: true

3. Gemeinsames Docker-Netzwerk erstellen:

   sudo docker network create proxy

4. AdGuard Home starten:

   sudo docker compose up -d

5. Ersteinrichtung: Öffne im Browser http://<IP-Adresse-des-Pi>:3000. Wähle als Listen-Interface für das Webinterface Port 80 und für den DNS-Server Port 53. Lege einen Benutzernamen und ein sicheres Passwort fest.

6. Router konfigurieren: Trage die IP-Adresse deines Raspberry Pi in den DHCP-Einstellungen deines Routers als einzigen DNS-Server ein. Bei der Fritz!Box unter Heimnetz > Netzwerk > Netzwerkeinstellungen > IPv4-Adressen.

7. Filterlisten konfigurieren: Im AdGuard Dashboard unter Filter > DNS-Sperrlisten die “AdGuard DNS filter”-Liste hinzufügen. Ergänzend empfiehlt sich eine eigene Whitelist wie zum Beispiel diese hier, um Fehlfunktionen durch zu aggressives Blocken zu vermeiden:

   https://raw.githubusercontent.com/deployn/adguardhomelist/main/whitelist.txt

8. DNS-Umschreibung für lokale Domains: Damit Domains wie traefik.home oder heimdall.home funktionieren, füge in AdGuard unter Filter > DNS-Umschreibungen eine Regel hinzu:

   • Domain: *.home
   • IP-Adresse: Die IP-Adresse deines Raspberry Pi (z.B. 192.168.178.50)

cd ~/docker
mkdir blocky && cd blocky
mkdir whitelists blacklists logs
docker network create blocky_net
nano docker-compose.yml

services:
    blocky:
        container_name: blocky
        image: spx01/blocky
        restart: unless-stopped
        networks:
            - blocky_net
        ports:
            - "53:53/tcp"
            - "53:53/udp"
            - "4000:4000/tcp"
        environment:
            - TZ=Europe/Berlin
        volumes:
            - ./config.yml:/app/config.yml
            - logs:/logs
            - ./blacklists:/app/blacklists/
            - ./whitelists:/app/whitelists/

Traefik als Reverse Proxy einrichten

Ein Reverse Proxy wie Traefik nimmt Anfragen aus dem Netzwerk entgegen und leitet sie an den richtigen internen Dienst weiter. Das erspart uns, für jeden Dienst einen eigenen Port freigeben zu müssen. Wir verwenden Traefik v3 wegen seiner exzellenten Docker-Integration.

1. Verzeichnis erstellen:

   mkdir -p ~/docker/traefik
   cd ~/docker/traefik

2. Docker Compose Datei erstellen:

   nano docker-compose.yml

   # ~/docker/traefik/docker-compose.yml
   services:
       traefik:
           image: traefik:v3.0
           container_name: traefik
           restart: unless-stopped
           ports:
               - "80:80"
               - "443:443"
           volumes:
               - /var/run/docker.sock:/var/run/docker.sock:ro
               - ./traefik.yml:/etc/traefik/traefik.yml:ro
               - ./acme.json:/acme.json
           networks:
               - proxy
           labels:
               - "traefik.enable=true"
               - "traefik.http.routers.traefik-http.rule=Host(`traefik.home`)"
               - "traefik.http.routers.traefik-http.entrypoints=web"
               - "traefik.http.services.traefik.loadbalancer.server.port=8080"
   
   networks:
       proxy:
           external: true

3. Traefik Konfigurationsdatei erstellen:

   nano traefik.yml

   # ~/docker/traefik/traefik.yml
   entryPoints:
       web:
           address: ":80"
       websecure:
           address: ":443"
   
   api:
       dashboard: true
       insecure: true
   
   providers:
       docker:
           endpoint: "unix:///var/run/docker.sock"
           exposedByDefault: false
           network: proxy
   
   log:
       level: INFO

4. Leere Datei für SSL-Zertifikate erstellen:

   touch acme.json
   chmod 600 acme.json

5. Traefik starten:

   sudo docker compose up -d

Das Traefik Dashboard sollte nun unter http://traefik.home erreichbar sein.

cd ~/docker
mkdir nginx-proxy-manager && cd nginx-proxy-manager
mkdir data/mysql -p
mkdir letsencrypt
docker network create npm_net
nano docker-compose.yml

services:
    nginx-proxy-manager:
        container_name: nginx-proxy-manager
        image: jc21/nginx-proxy-manager
        restart: always
        networks:
            - npm_net
            - internal
        ports:
            - "80:80"
            - "443:443"
            - "81:81"
        environment:
            DB_MYSQL_HOST: npm_db
            DB_MYSQL_PORT: 3306
            DB_MYSQL_USER: npm
            DB_MYSQL_PASSWORD: deine_datenbank_passwort
            DB_MYSQL_NAME: npm
        volumes:
            - ./data:/data
            - ./letsencrypt:/etc/letsencrypt
        depends_on:
            - npm_db

    npm_db:
        container_name: npm_db
        image: yobasystems/alpine-mariadb
        restart: always
        networks:
            - internal
        environment:
            MYSQL_ROOT_PASSWORD: dein_root_passwort
            MYSQL_DATABASE: npm
            MYSQL_USER: npm
            MYSQL_PASSWORD: deine_datenbank_passwort
        volumes:
            - ./data/mysql:/var/lib/mysql

Heimdall als Dashboard einrichten

Um den Überblick über unsere wachsenden Dienste zu behalten, installieren wir Heimdall als zentrales Dashboard mit Kacheln für alle Anwendungen.

1. Verzeichnis erstellen:

   mkdir -p ~/docker/heimdall/config
   cd ~/docker/heimdall

2. Docker Compose Datei erstellen:

   nano docker-compose.yml

   Ersetze 1000 bei PUID/PGID mit deinen Werten (id -u bzw. id -g):

   # ~/docker/heimdall/docker-compose.yml
   services:
       heimdall:
           image: linuxserver/heimdall:latest
           container_name: heimdall
           restart: unless-stopped
           volumes:
               - ./config:/config
           environment:
               - PUID=1000
               - PGID=1000
               - TZ=Europe/Berlin
           networks:
               - proxy
           labels:
               - "traefik.enable=true"
               - "traefik.http.routers.heimdall.rule=Host(`heimdall.home`)"
               - "traefik.http.routers.heimdall.entrypoints=web"
               - "traefik.http.services.heimdall.loadbalancer.server.port=80"
   
   networks:
       proxy:
           external: true

3. Heimdall starten:

   sudo docker compose up -d

Heimdall ist nun unter http://heimdall.home erreichbar. Klicke auf “Add Application” oder das Zahnrad, um Kacheln für AdGuard, Traefik und weitere Dienste hinzuzufügen.

cd ~/docker
mkdir homer && cd homer
mkdir assets
nano docker-compose.yml

services:
    homer:
        container_name: homer
        image: b4bz/homer
        restart: unless-stopped
        ports:
            - 8080:8080
        environment:
            - UID=1000
            - GID=1000
        volumes:
            - ./config.yml:/www/config.yml
            - ./assets/:/www/assets

Firewall mit UFW einrichten

Jetzt benötigen wir eine Firewall. Die uncomplicated firewall (UFW) ist die beste Wahl für unseren Heimserver.

sudo apt install ufw
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw allow 22/tcp
sudo ufw logging medium
sudo ufw default deny incoming
sudo ufw enable

Docker und UFW: Ein wichtiges Problem

Docker verändert die iptables-Regeln selbstständig, sobald ein Port in einer Docker-Compose-Datei freigegeben wird. Dadurch umgeht Docker die UFW-Firewall - das ist ein bekanntes Sicherheitsrisiko. Prüfe das, indem du nach einem Neustart versuchst, {IP-Adresse}:3000 (AdGuard Setup-Port) im Browser aufzurufen. Überraschung: Es klappt trotz Firewall.

Die beste Lösung dafür ist das Repository chaifeng/ufw-docker. Öffne die Datei:

sudo nano /etc/ufw/after.rules

Füge diesen Code am Ende ein:

# BEGIN UFW AND DOCKER
*filter
:ufw-user-forward - [0:0]
:ufw-docker-logging-deny - [0:0]
:DOCKER-USER - [0:0]
-A DOCKER-USER -j ufw-user-forward

-A DOCKER-USER -j RETURN -s 10.0.0.0/8
-A DOCKER-USER -j RETURN -s 172.16.0.0/12
-A DOCKER-USER -j RETURN -s 192.168.0.0/16

-A DOCKER-USER -p udp -m udp --sport 53 --dport 1024:65535 -j RETURN

-A DOCKER-USER -j ufw-docker-logging-deny -p tcp -m tcp --tcp-flags FIN,SYN,RST,ACK SYN -d 192.168.0.0/16
-A DOCKER-USER -j ufw-docker-logging-deny -p tcp -m tcp --tcp-flags FIN,SYN,RST,ACK SYN -d 10.0.0.0/8
-A DOCKER-USER -j ufw-docker-logging-deny -p tcp -m tcp --tcp-flags FIN,SYN,RST,ACK SYN -d 172.16.0.0/12
-A DOCKER-USER -j ufw-docker-logging-deny -p udp -m udp --dport 0:32767 -d 192.168.0.0/16
-A DOCKER-USER -j ufw-docker-logging-deny -p udp -m udp --dport 0:32767 -d 10.0.0.0/8
-A DOCKER-USER -j ufw-docker-logging-deny -p udp -m udp --dport 0:32767 -d 172.16.0.0/12

-A DOCKER-USER -j RETURN

-A ufw-docker-logging-deny -m limit --limit 3/min --limit-burst 10 -j LOG --log-prefix "[UFW DOCKER BLOCK] "
-A ufw-docker-logging-deny -j DROP

COMMIT
# END UFW AND DOCKER

Danach den Raspberry neu starten:

sudo reboot

Diese Regeln erlauben den Zugriff auf Docker-Dienste aus dem lokalen Netzwerk (192.168.0.0/16, 10.0.0.0/8, 172.16.0.0/12), blockieren aber Zugriffe von außen. Da die Ports 80 und 443 für den Proxy freigegeben werden sollen, ergänzen wir:

sudo ufw route allow 80/tcp
sudo ufw route allow 443/tcp
sudo ufw reload

Damit ist die Firewall vollständig konfiguriert und der Server abgesichert.

Automatische Updates und Wartung

Ein Heimserver braucht regelmäßige Pflege.

Betriebssystem-Updates:

sudo apt update && sudo apt upgrade -y && sudo apt autoremove -y

Docker-Container aktualisieren (pro Dienst):

cd ~/docker/adguard
sudo docker compose pull
sudo docker compose up -d --remove-orphans

Wiederhole das für Traefik und Heimdall in ihren Verzeichnissen.

Docker Systembereinigung:

sudo docker system prune -af

Dieser Befehl entfernt alle gestoppten Container, ungenutzten Netzwerke, Images und den Build-Cache.

Öffentlicher Zugang zu deinen Diensten (Optional)

Möchtest du Dienste wie Heimdall sicher von unterwegs erreichen?

1. DynDNS: Da sich deine öffentliche IP-Adresse ändern kann, brauchst du einen DynDNS-Dienst (z.B. DuckDNS, No-IP, Cloudflare DDNS).
2. Port-Weiterleitung: Leite in deinem Router die Ports 80 und 443 an die IP-Adresse deines Raspberry Pi weiter. Achtung: Das Öffnen von Ports birgt Sicherheitsrisiken.
3. SSL mit Let’s Encrypt & Traefik: Bearbeite ~/docker/traefik/traefik.yml und entkommentiere den certificatesResolvers-Abschnitt. Trage deine E-Mail-Adresse ein und starte Traefik neu. Für jeden Dienst, der öffentlich erreichbar sein soll, passe die Labels in der jeweiligen docker-compose.yml an.

Alternative ohne öffentliche IP/Portweiterleitung: Dienste wie Pangolin erlauben den Zugriff über einen sicheren Tunnel, ohne Ports öffnen zu müssen. Das stelle ich in einem eigenen YouTube-Video vor.

Fazit

Du hast nun einen modernen, effizienten und abgesicherten Heimserver auf Basis eines Raspberry Pi eingerichtet. Die Kombination aus Docker für Flexibilität, AdGuard Home für ein werbefreies Netz, Traefik für zentrale Zugriffssteuerung, Heimdall als Übersicht und UFW als Firewall bietet eine solide Grundlage. Von hier aus lassen sich weitere Dienste wie Portainer, Paperless oder Home Assistant ergänzen.