Ein Raspberry Pi als Homeserver ist leise, sparsam und erstaunlich leistungsfähig. In diesem Guide nehme ich dich mit durch das komplette Setup: von der Auswahl der Hardware über die Absicherung per SSH bis hin zu Backups und Performance-Tuning. Alles praxisnah, mit echten Befehlen und Konfigurationen.

Die richtige Hardware wählen

Meine klare Empfehlung ist der Raspberry Pi 5 mit 8 GB RAM. Der Quad-Core Cortex-A76 bei 2,4 GHz liefert genug Leistung für mehrere Services gleichzeitig. Dazu gehört ein gutes Netzteil (das offizielle 27W USB-C), eine schnelle microSD-Karte (A2-Rating) oder – noch besser – eine NVMe-SSD über den PCIe-Anschluss. Der Pi 4 funktioniert ebenfalls, stößt aber bei PostgreSQL und mehreren Containern schnell an seine Grenzen.

Tipp: Investiert in ein passives Aluminiumgehäuse. Ohne aktive Kühlung throttled der Pi 5 unter Dauerlast bei etwa 80°C.

Raspberry Pi OS Lite installieren

Wir brauchen keine Desktop-Umgebung. Raspberry Pi OS Lite (64-bit, Debian Bookworm-basiert) ist die richtige Wahl. Mit dem Raspberry Pi Imager könnt ihr direkt beim Flashen SSH aktivieren und einen Benutzer anlegen:

  1. Raspberry Pi Imager öffnen und Raspberry Pi OS Lite (64-bit) auswählen
  2. Unter OS-Einstellungen: Hostname setzen, SSH aktivieren, Benutzer und Passwort anlegen
  3. Auf die SD-Karte schreiben, einlegen, booten

Nach dem ersten Boot das System aktualisieren:

sudo apt update && sudo apt full-upgrade -y
sudo reboot

SSH härten

Passwort-Login über SSH ist ein Einfallstor für Brute-Force-Angriffe. Wir schalten auf Key-Only-Authentifizierung um.

SSH-Key generieren (auf deinem Rechner)

ssh-keygen -t ed25519 -C "homeserver"
ssh-copy-id -i ~/.ssh/id_ed25519.pub deinuser@pi-ip

SSH-Daemon konfigurieren

Auf dem Pi die Datei /etc/ssh/sshd_config.d/hardening.conf anlegen:

# /etc/ssh/sshd_config.d/hardening.conf
Port 2222
PermitRootLogin no
PasswordAuthentication no
PubkeyAuthentication yes
AuthenticationMethods publickey
MaxAuthTries 3
ClientAliveInterval 300
ClientAliveCountMax 2
X11Forwarding no

Danach den SSH-Dienst neu starten:

sudo systemctl restart sshd

Wichtig: Testet die Verbindung in einer neuen Session, bevor ihr die alte schließt. Sonst sperrt ihr euch aus.

Firewall mit ufw einrichten

Die Uncomplicated Firewall macht es einfach, nur die nötigen Ports zu öffnen:

sudo apt install ufw -y
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow 2222/tcp comment 'SSH'
sudo ufw allow 80/tcp comment 'HTTP'
sudo ufw allow 443/tcp comment 'HTTPS'
sudo ufw enable
sudo ufw status verbose

Alles andere ist dicht. Weitere Ports öffnet ihr nur bei Bedarf – zum Beispiel 5222/tcp und 5269/tcp für XMPP oder 5432/tcp falls PostgreSQL von außen erreichbar sein soll (was ich nicht empfehle).

Essenzielle Dienste installieren

nginx als Reverse Proxy

sudo apt install nginx -y
sudo systemctl enable nginx

Eine minimale Site-Konfiguration unter /etc/nginx/sites-available/example.conf:

server {
    listen 80;
    server_name example.deinedomain.de;

    location / {
        proxy_pass http://127.0.0.1:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}
sudo ln -s /etc/nginx/sites-available/example.conf /etc/nginx/sites-enabled/
sudo nginx -t && sudo systemctl reload nginx

PostgreSQL

sudo apt install postgresql postgresql-contrib -y
sudo systemctl enable postgresql
sudo -u postgres createuser --interactive
sudo -u postgres createdb meine_datenbank

SSL-Zertifikate mit certbot

sudo apt install certbot python3-certbot-nginx -y
sudo certbot --nginx -d example.deinedomain.de
sudo certbot renew --dry-run

Certbot richtet automatisch einen systemd-Timer ein, der die Zertifikate vor Ablauf erneuert. Mit systemctl list-timers könnt ihr das überprüfen.

Dynamisches DNS einrichten

Die meisten Heimanschlüsse haben eine dynamische IP. Dienste wie DuckDNS, Desec.io oder die DynDNS-Funktion eures Routers lösen das. Beispiel mit DuckDNS als Cronjob:

# /usr/local/bin/duckdns-update.sh
#!/bin/bash
DOMAIN="deinname"
TOKEN="dein-token-hier"
curl -s "https://www.duckdns.org/update?domains=${DOMAIN}&token=${TOKEN}&ip=" \
  > /var/log/duckdns.log 2>&1
chmod +x /usr/local/bin/duckdns-update.sh
(crontab -l; echo "*/5 * * * * /usr/local/bin/duckdns-update.sh") | crontab -

Alternativ bietet desec.io eine datenschutzfreundliche Option mit API-Token und dedns-Client. Vergesst nicht, in eurem Router die entsprechenden Ports (80, 443, ggf. 2222) auf den Pi weiterzuleiten.

Stromversorgung und USV

Ein Homeserver, der bei jedem Stromausfall unsauber herunterfährt, riskiert Dateisystem-Korruption. Eine kleine USV (Uninterruptible Power Supply) schafft Abhilfe:

  • PiJuice HAT – direkt auf den GPIO-Header, mit LiPo-Akku und Software für sauberes Shutdown
  • USB-Powerbank mit Pass-Through – günstige Variante, aber ohne automatischen Shutdown
  • Klassische USV (z.B. APC Back-UPS) – overkill, aber zuverlässig, per USB-HID mit apcupsd oder nut ansteuerbar

Für den PiJuice HAT den Daemon installieren:

sudo apt install pijuice-base -y
# Shutdown bei niedrigem Akkustand in /etc/pijuice/pijuice_config.JSON konfigurieren

Außerdem empfiehlt es sich, das Dateisystem abzusichern. Bei einer SD-Karte kann overlayfs (read-only root) die Lebensdauer drastisch verlängern.

Backup-Strategien

Kein Backup, kein Mitleid. Mein Setup: tägliche inkrementelle Backups mit rsync auf eine externe USB-Festplatte, plus wöchentliche Datenbankdumps.

rsync-Backup-Skript

#!/bin/bash
# /usr/local/bin/backup.sh
BACKUP_DIR="/mnt/backup/homeserver"
TIMESTAMP=$(date +%Y-%m-%d_%H%M)
LOG="/var/log/backup.log"

mkdir -p "${BACKUP_DIR}"

echo "[${TIMESTAMP}] Backup gestartet" >> "${LOG}"

# Datenbank dumpen
sudo -u postgres pg_dumpall | gzip > "${BACKUP_DIR}/postgres_${TIMESTAMP}.sql.gz"

# Wichtige Verzeichnisse sichern
rsync -az --delete \
  --exclude='/proc' \
  --exclude='/sys' \
  --exclude='/tmp' \
  /etc/ "${BACKUP_DIR}/etc/"

rsync -az --delete \
  /home/ "${BACKUP_DIR}/home/"

rsync -az --delete \
  /var/www/ "${BACKUP_DIR}/www/"

echo "[${TIMESTAMP}] Backup abgeschlossen" >> "${LOG}"

# Alte DB-Dumps aufräumen (älter als 30 Tage)
find "${BACKUP_DIR}" -name "postgres_*.sql.gz" -mtime +30 -delete
sudo chmod +x /usr/local/bin/backup.sh
# Täglich um 03:00 Uhr ausführen
(sudo crontab -l; echo "0 3 * * * /usr/local/bin/backup.sh") | sudo crontab -

Tipp: Testet regelmäßig, ob ihr aus euren Backups wiederherstellen könnt. Ein Backup, das niemand testet, ist kein Backup.

Performance-Tipps für ARM

Der Pi ist kein Xeon-Server. Ein paar Maßnahmen helfen, das Maximum herauszuholen:

  • NVMe statt SD-Karte: Der PCIe-Anschluss des Pi 5 liefert bis zu 800 MB/s statt der ~40 MB/s einer SD-Karte. Für Datenbanken ein enormer Unterschied.
  • zram statt Swap auf der SD: Komprimierter RAM als Swap reduziert I/O-Last erheblich.
  • tmpfs für /tmp: Flüchtige Daten gehören in den RAM.
  • PostgreSQL tunen: In postgresql.conf die shared_buffers auf 25% des RAMs setzen (z.B. 2GB bei 8 GB Pi), work_mem auf 64MB.
  • nginx Worker: worker_processes auto; nutzt alle 4 Kerne.

Zram aktivieren:

sudo apt install zram-tools -y
# In /etc/default/zramswap anpassen:
# ALGO=zstd
# PERCENT=50
sudo systemctl restart zramswap

tmpfs in der /etc/fstab:

tmpfs /tmp tmpfs defaults,noatime,nosuid,nodev,size=512M 0 0

Überprüft die Temperatur regelmäßig – Thermal Throttling kostet euch bis zu 50% Leistung:

vcgencmd measure_temp
# Sollte unter Last dauerhaft unter 75°C bleiben

Fazit

Ein Raspberry Pi 5 mit gehärtetem SSH, Firewall, nginx, PostgreSQL und automatischen Backups ist eine solide Grundlage für euer Selfhosting-Projekt. Die initiale Einrichtung dauert ein bis zwei Stunden. Danach läuft das Ding monatelang stabil – bei Stromkosten von unter 3 Euro im Monat. In zukünftigen Posts gehe ich tiefer in einzelne Services: XMPP, Gitea, Monitoring mit Prometheus und mehr.