Raspberry Pi Tutorials

Headless-Pis im Schrank, am Mast oder im Serverrack haben ein Problem: Wenn der Kernel hart einfriert, hilft nur noch Strom ziehen. Der Broadcom-SoC bringt aber einen Hardware-Watchdog-Timer mit, der den Pi nach einem echten Aufhaenger selbststaendig neu startet. Dieses Tutorial richtet sich an Profis, die headless betriebene Pis stabil halten wollen — mit dem eingebauten Watchdog plus systemd, also ohne externe Relais oder Reset-Schaltung.

Wie der Watchdog funktioniert

• Der SoC (BCM2835 und Nachfolger) enthaelt einen Countdown-Timer. Laeuft er auf 0, loest die Hardware einen harten Reset aus — unabhaengig davon, ob die CPU noch reagiert.
• Solange das System lebt, schreibt ein Daemon regelmaessig auf /dev/watchdog0 und setzt den Zaehler zurueck („Kicken“). Bleibt das Kicken aus, rebootet der Pi.
• Das Kernelmodul heisst bcm2835_wdt. Der maximale Timeout betraegt 15 Sekunden — das ist die Hardware-Grenze des SoC, hoehere Werte sind nicht moeglich.
• Du brauchst nur eine Software, die den Watchdog fuettert: entweder systemd (hier gezeigt) oder das separate watchdog-Paket. Niemals beide gleichzeitig — sie streiten sich um /dev/watchdog0.

Schritt 1: Watchdog im Boot-Config aktivieren

Per Default ist das Watchdog-Device nicht angelegt. Aktiviere es ueber den Device-Tree-Parameter.

1. Config-Datei oeffnen. Auf Raspberry Pi OS Bookworm/Trixie liegt sie unter /boot/firmware/config.txt, auf aelteren Systemen unter /boot/config.txt:

   sudo nano /boot/firmware/config.txt

2. Folgende Zeile ans Ende setzen:

   dtparam=watchdog=on

3. Neu starten, damit der Device-Tree neu geladen wird:

   sudo reboot

Schritt 2: Device und Modul pruefen

Nach dem Reboot verifizierst du, dass Hardware und Kernel zusammenspielen.

1. Device-Datei vorhanden?

   ls -l /dev/watchdog*

   Es sollten /dev/watchdog und /dev/watchdog0 erscheinen.
2. Kernel-Log pruefen:

   dmesg | grep -i watchdog

   Erwartete Meldung: bcm2835-wdt bcm2835-wdt: Broadcom BCM2835 watchdog timer.
3. Status mit wdctl (aus dem Paket util-linux, meist schon installiert):

   wdctl

   Ausgabe zeigt u.a. Identity: Broadcom BCM2835 Watchdog timer und Timeout: 15 seconds.

Schritt 3: systemd als Watchdog-Daemon einspannen

systemd kann den Hardware-Watchdog direkt fuettern und zusaetzlich seine eigene Liveness ueberwachen — kein zusaetzliches Paket noetig.

1. Konfiguration oeffnen:

   sudo nano /etc/systemd/system.conf

2. Diese beiden Zeilen setzen (vorhandene, auskommentierte Eintraege entkommentieren und anpassen):

   RuntimeWatchdogSec=14
   ShutdownWatchdogSec=2min

   Wichtig: RuntimeWatchdogSec muss ≤ 15 bleiben, sonst akzeptiert die Hardware den Wert nicht und der Watchdog laeuft im schlimmsten Fall gar nicht. 14 ist ein robuster Wert; systemd kickt den Timer dann etwa alle 7 Sekunden.
3. ShutdownWatchdogSec haelt den Watchdog beim Reboot/Shutdown aktiv — bleibt der Pi beim Herunterfahren haengen, erzwingt der Timer trotzdem den Neustart.
4. Aenderung ohne Reboot uebernehmen:

   sudo systemctl daemon-reexec

5. Pruefen, dass systemd den Watchdog nutzt:

   systemctl show | grep -i watchdog

   RuntimeWatchdogUSec sollte jetzt einen Wert ungleich 0 zeigen.

Schritt 4: Den Reboot scharf testen

Erst der Test beweist, dass der Watchdog wirklich greift. Simuliere einen echten Kernel-Hang ueber den Magic-SysRq-Trigger.

1. SysRq freischalten und Crash ausloesen (als root):

   echo 1 | sudo tee /proc/sys/kernel/sysrq
   echo c | sudo tee /proc/sysrq-trigger

2. Der Kernel paniced, die SSH-Verbindung bricht ab — und der Pi rebootet nach Ablauf des Timeouts (max. ~15 s) von selbst.

Warnung: echo c > /proc/sysrq-trigger erzeugt einen sofortigen Kernel-Crash. Alle nicht geschriebenen Daten gehen verloren und Dateisysteme werden unsauber ausgehaengt — fuehre den Test nur auf einem System ohne laufende Schreiblast und niemals im Produktivbetrieb aus. Profi-Tipp: Der Watchdog rettet nur vor echten Aufhaengern (Kernel-Hang, harter Lockup). Eine vollgelaufene Disk, ein abgestuerzter Dienst oder ein toter Netzwerk-Stack bei laufendem Kernel werden nicht erkannt — dafuer brauchst du das separate watchdog-Paket mit Ping-/Last-/Prozess-Checks (aber dann systemd-Watchdog deaktivieren, sonst Konflikt) oder zusaetzliche systemd-Service-Watchdogs.

Hersteller-Apps schalten Cloud-Dienste ab, Geraete werden zu Briefbeschwerern, deine Lichtschalter brauchen ploetzlich US-Server zum Funktionieren. Dieses Tutorial zeigt dir den Gegenentwurf fuer Fortgeschrittene: Home Assistant auf einem Raspberry Pi als lokale Steuerzentrale, ein Zigbee-Koordinator als eigenes Funknetz und eine Geraete-Auswahl, die auch dann weiterlaeuft, wenn dein Internet ausfaellt. Alles lokal, kein Hersteller-Login, keine Cloud-Abhaengigkeit.

1. Home Assistant OS auf den Pi bringen

Empfohlen ist Home Assistant OS (HAOS) — ein schlankes, dediziertes Betriebssystem inklusive Supervisor und Add-on-Store. Du brauchst mindestens einen Raspberry Pi 4 (4 GB ist der Sweet Spot) oder einen Pi 5, sowie schnellen Speicher (SSD per USB ist langlebiger als microSD).

1. Lade den Raspberry Pi Imager herunter und installiere ihn.
2. Im Imager: Choose OS → Other specific-purpose OS → Home assistants and home automation → Home Assistant OS → die zu deinem Pi-Modell passende Version waehlen.
3. Unter Choose Storage dein Medium auswaehlen und schreiben. Wichtig: Nimm hier keine Anpassungen vor (kein SSH, kein WLAN, kein Benutzer) — HAOS richtet das selbst ueber die Weboberflaeche ein.
4. Pi per LAN-Kabel an den Router (Zigbee/Setup laufen stabiler verkabelt), dann Strom anschliessen.
5. Beim ersten Boot laedt HAOS automatisch die aktuelle Core-Version — das dauert 5 bis 15 Minuten.
6. Danach im Browser http://homeassistant.local:8123 oeffnen und dem Assistenten folgen (Konto, Standort, fertig).

Findest du homeassistant.local nicht (mDNS-Probleme), nutze die IP direkt: http://:8123. Die IP siehst du in der DHCP-Liste deines Routers.

2. Den richtigen Zigbee-Koordinator waehlen

Der Koordinator ist der USB-Stick, der dein eigenes Zigbee-Funknetz aufspannt — komplett lokal, ohne Hersteller-Hub und ohne Cloud. Bewaehrte Optionen Stand 2026:

• Home Assistant Connect ZBT-2 — der offizielle Adapter (Silicon Labs MG24-Chip), Nachfolger des eingestellten ZBT-1/SkyConnect. Unterstuetzt ZHA, Zigbee2MQTT und Thread (aber nicht Zigbee und Thread gleichzeitig). Hoechste Performance, eigene Antenne.
• Sonoff ZBDongle-E — guenstiger Klassiker (MG21-Chip), seit Jahren rock-solid, treibt Netze mit 100+ Geraeten. Top Preis-Leistung, wenn du kein Thread brauchst.

Praxisregel: Stecke den Stick nie direkt in den Pi, sondern ueber ein USB-Verlaengerungskabel (50 cm oder laenger). USB-3.0-Ports und SSDs strahlen genau im 2,4-GHz-Band und stoeren Zigbee massiv.

3. Zigbee einbinden: ZHA oder Zigbee2MQTT

Nach dem Einstecken erkennt Home Assistant den Koordinator meist automatisch. Du hast zwei Integrationen zur Wahl:

• ZHA — direkt in Home Assistant eingebaut, kein Broker noetig, in wenigen Klicks startklar. Ideal fuer den Einstieg.
• Zigbee2MQTT — laeuft als Add-on (braucht zusaetzlich einen MQTT-Broker wie Mosquitto), unterstuetzt dafuer mehr Geraete und liefert oft schneller Support fuer Exoten.

1. In Home Assistant: Einstellungen → Geraete & Dienste → die automatisch entdeckte Integration bestaetigen oder ueber Integration hinzufuegen manuell waehlen.
2. Den seriellen Port des Sticks auswaehlen (z. B. /dev/ttyUSB0 oder /dev/ttyACM0) und die passende Firmware/Adapter-Variante bestaetigen.
3. Geraet in den Anlern-Modus versetzen (meist langer Tastendruck am Geraet), in HA auf Geraet hinzufuegen klicken und koppeln.

Entscheide dich am Anfang fuer eine Integration. ZHA und Zigbee2MQTT koennen nicht denselben Stick teilen, und ein spaeterer Wechsel bedeutet, alle Geraete neu anzulernen.

4. Geraete-Auswahl: Was wirklich offline funktioniert

Das Protokoll entscheidet ueber deine Cloud-Unabhaengigkeit:

• Zigbee (z. B. IKEA TRADFRI, Aqara, Philips Hue, Sonoff) — funkt nur lokal zu deinem eigenen Koordinator. Kein Internet noetig, Automationen laufen auch bei DSL-Ausfall weiter.
• WLAN-Cloud-Geraete (viele Tuya-, Kamera- und Sprachassistenten) — brauchen die Hersteller-Server als "Gehirn". Kappst du das Internet, sind sie tot. Viele lassen sich aber mit Open-Source-Firmware (Tasmota, ESPHome) cloudfrei flashen.
• Matter/Thread — local-by-design und herstelleruebergreifend; ein guter Weg fuer neue Geraete, sofern sie lokale Steuerung (ohne Bridge-Cloud) unterstuetzen.

Beim Kauf gilt: auf "local control", Zigbee 3.0 oder Matter achten und Geraete meiden, die zwingend eine Hersteller-App mit Konto-Login zum reinen Schalten verlangen.

5. Absichern: VLAN, Firewall und Backups

Lokal heisst nicht automatisch sicher. Trenne deine IoT-Geraete vom Hauptnetz:

• Richte ein eigenes IoT-VLAN ein (braucht prosumer-Hardware mit 802.1Q, etwa UniFi oder TP-Link Omada). Eine Firewall-Regel erlaubt IoT → Home Assistant, blockiert aber IoT → vertrauenswuerdiges Netz.
• Da mDNS keine VLAN-Grenzen ueberquert, aktiviere einen mDNS-Reflector/-Repeater am Router, sonst sieht Home Assistant die Geraete im IoT-VLAN nicht.
• Cloud-pflichtige Geraete kannst du am Router gezielt vom Internet abklemmen — teste vorher, ob sie dann noch tun, was du brauchst.

Und: Lege vor jedem Update ein Backup an. Einstellungen → System → Backups → Backup erstellen. So holst du Zigbee-Netzwerk und Automationen nach einem Fehlschlag in Minuten zurueck.

Profi-Tipp: Sichere den Zigbee-Netzwerkschluessel (Backup ueber die ZHA-/Zigbee2MQTT-Einstellungen) getrennt vom Pi. Stirbt die SD-Karte ohne aktuelles Backup, musst du sonst jedes einzelne Geraet physisch neu anlernen — bei 50+ Sensoren ein verlorener Nachmittag.

Was ist Pi-hole?

Pi-hole ist ein DNS-basierter Werbeblocker. Alle Geräte im Netzwerk nutzen den Pi als DNS-Server — Werbung wird direkt geblockt, bevor sie geladen wird.

Installation (ein Befehl)

curl -sSL https://install.pi-hole.net | bash

Hinweis: curl | bash führt ein Skript direkt aus dem Internet aus. Prüfe bei Bedenken den Quellcode vorher unter github.com/pi-hole.

Der Installer führt durch alle Schritte. Am Ende wird ein Passwort für das Web-Interface angezeigt.

Router auf Pi-hole umbiegen

1. Router-Einstellungen öffnen (meistens 192.168.1.1)
2. DNS-Server auf die IP des Pi setzen
3. Alle Geräte nutzen jetzt automatisch Pi-hole

Web-Interface

Erreichbar unter http://pi.hole/admin oder http://IP-DES-PI/admin.

• Dashboard mit Statistiken (blockierte Anfragen, Top-Domains)
• Whitelist/Blacklist verwalten
• Blocklisten hinzufügen

Pi-hole blockiert ca. 30–50% aller DNS-Anfragen — das Internet fühlt sich spürbar schneller an.

NAS-Voraussetzungen

• Raspberry Pi 4/5 (mindestens 2 GB RAM)
• Externe USB-Festplatte oder SSD
• Raspberry Pi OS Lite installiert

OpenMediaVault installieren

sudo apt update && sudo apt upgrade -y
wget -O - https://github.com/OpenMediaVault-Plugin-Developers/installScript/raw/master/install | sudo bash

Sicherheit: Dieser Installer wird direkt aus dem Internet ausgeführt. Vertraue nur der offiziellen Quelle — oder lade das Skript erst herunter und sieh es dir an, bevor du es ausführst.

Nach der Installation: Web-Interface unter http://IP-DES-PI (Standard-Login: admin / openmediavault).

Freigaben einrichten

1. Speichermedien → Dateisysteme → USB-Platte einbinden
2. Freigegebene Ordner erstellen
3. Dienste → SMB/CIFS aktivieren → Freigabe hinzufügen

Zugriff

• Windows: Win + R → \\IP-DES-PI
• Mac: Finder → Gehe zu → Mit Server verbinden → smb://IP-DES-PI
• Linux: Dateimanager → Andere Orte → smb://IP-DES-PI

Für bessere Performance eine SSD statt HDD verwenden und den Pi per Ethernet-Kabel verbinden.

RetroPie installieren

1. RetroPie-Image herunterladen (retropie.org.uk)
2. Mit Raspberry Pi Imager auf SD-Karte flashen
3. SD-Karte einsetzen und Pi starten
4. Controller verbinden (USB oder Bluetooth)

Unterstützte Systeme (Auswahl)

ROMs hinzufügen

• Über Netzwerk: \\retropie\roms im Datei-Explorer
• Per USB-Stick: Ordner retropie erstellen, einstecken, warten, ROMs kopieren

Controller konfigurieren

Beim ersten Start führt EmulationStation durch die Tastenbelegung. Für Bluetooth-Controller: RetroPie-Menü → Bluetooth.

Nur ROMs von Spielen verwenden, die du physisch besitzt. Das Herunterladen von urheberrechtlich geschützten ROMs ist illegal.

PiVPN installieren

curl -L https://install.pivpn.io | bash

Wähle WireGuard (schneller und moderner als OpenVPN). Der Installer fragt nach Port (Standard: 51820) und DNS-Server.

Client hinzufügen

pivpn add -n MeinHandy

Erzeugt eine .conf-Datei und einen QR-Code zum Scannen.

QR-Code anzeigen

pivpn -qr MeinHandy

In der WireGuard-App (iOS/Android) scannen — fertig.

Router-Port-Forwarding für VPN

• Port-Forwarding: UDP Port 51820 an die IP des Pi weiterleiten
• DynDNS: Falls keine statische öffentliche IP → DynDNS-Dienst nutzen (z.B. DuckDNS)

Verwaltung

pivpn list      # Alle Clients anzeigen
pivpn remove    # Client entfernen
pivpn debug     # Fehlerdiagnose

WireGuard ist deutlich schneller als OpenVPN und verbraucht weniger Akku auf Mobilgeräten.

CUPS installieren

sudo apt update
sudo apt install cups -y
sudo usermod -aG lpadmin $USER

Remote-Zugriff aktivieren

sudo cupsctl --remote-any
sudo systemctl restart cups

Drucker einrichten

1. USB-Drucker an den Pi anschließen
2. Web-Interface öffnen: https://IP-DES-PI:631
3. Verwaltung → Drucker hinzufügen → USB-Drucker wählen
4. Treiber auswählen (oft automatisch erkannt)
5. "Diesen Drucker freigeben" aktivieren

Vom Client drucken

• Windows: Drucker hinzufügen → Netzwerkdrucker → http://IP-DES-PI:631/printers/Druckername
• Mac/Linux: Wird oft automatisch per Bonjour/Avahi erkannt
• iOS: AirPrint funktioniert oft direkt über CUPS

Tipp: Für AirPrint-Unterstützung zusätzlich avahi-daemon installieren: sudo apt install avahi-daemon.

Nextcloud-Voraussetzungen

• Raspberry Pi 4/5 mit mindestens 4 GB RAM
• Externe SSD (SD-Karte zu langsam für Datenbank)
• Domain mit DynDNS (für HTTPS)

Stack installieren

sudo apt install apache2 mariadb-server php php-gd php-mysql \
  php-curl php-mbstring php-intl php-gmp php-bcmath php-xml \
  php-imagick php-zip php-apcu php-redis redis-server -y

Datenbank einrichten

sudo mysql -u root
CREATE DATABASE nextcloud;
CREATE USER 'ncuser'@'localhost' IDENTIFIED BY 'HIER_EIGENES_SICHERES_PASSWORT';
GRANT ALL ON nextcloud.* TO 'ncuser'@'localhost';
FLUSH PRIVILEGES;
EXIT;

Nextcloud herunterladen

cd /var/www/
sudo wget https://download.nextcloud.com/server/releases/latest.tar.bz2
sudo tar -xjf latest.tar.bz2
sudo chown -R www-data:www-data nextcloud/

HTTPS mit Let's Encrypt

sudo apt install certbot python3-certbot-apache -y
sudo certbot --apache -d deine-domain.de

Redis-Cache aktivieren (config.php)

'memcache.local' => '\OC\Memcache\APCu',
'memcache.locking' => '\OC\Memcache\Redis',
'redis' => [
    'host' => 'localhost',
    'port' => 6379,
],

Nextcloud auf dem Pi ist langsamer als kommerzielle Cloud-Dienste, aber deine Daten bleiben bei dir. Für 1–5 Nutzer völlig ausreichend.

GPIO-Pins Überblick

Der Raspberry Pi hat 40 Pins (26 GPIO-Pins). Nummerierung beachten: BCM (Chip) vs. BOARD (physische Position).

# Pin-Belegung anzeigen
pinout

LED blinken lassen (Python)

from gpiozero import LED
from time import sleep

led = LED(17)  # GPIO 17

while True:
    led.on()
    sleep(1)
    led.off()
    sleep(1)

DHT22 Temperatursensor

sudo pip3 install adafruit-circuitpython-dht
sudo apt install libgpiod2 -y

import adafruit_dht
import board

sensor = adafruit_dht.DHT22(board.D4)  # GPIO 4

temperatur = sensor.temperature
luftfeuchtigkeit = sensor.humidity
print(f"Temp: {temperatur}°C, Feuchte: {luftfeuchtigkeit}%")

Relais steuern

from gpiozero import OutputDevice
from time import sleep

relais = OutputDevice(18)  # GPIO 18

relais.on()    # Gerät einschalten
sleep(5)
relais.off()   # Gerät ausschalten

Wichtig: GPIO-Pins arbeiten mit 3.3V, nicht 5V! Falsche Spannung kann den Pi beschädigen. Immer Vorwiderstände für LEDs verwenden.

Was brauchst du?

• Mindestens 2 Raspberry Pis (3B+, 4 oder 5)
• Ethernet-Switch und Kabel (WLAN ist zu instabil)
• Raspberry Pi OS Lite auf allen Pis
• Cluster-Gehäuse oder Stapelhalterungen

K3s installieren (leichtgewichtiges Kubernetes)

Master-Node:

curl -sfL https://get.k3s.io | sh -

Sicherheit: Dieser Installer wird direkt aus dem Internet ausgeführt. Vertraue nur der offiziellen Quelle — oder lade das Skript erst herunter und sieh es dir an, bevor du es ausführst.

Token auslesen:

sudo cat /var/lib/rancher/k3s/server/node-token

Worker-Nodes:

curl -sfL https://get.k3s.io | K3S_URL=https://MASTER-IP:6443 \
  K3S_TOKEN=DEIN-TOKEN sh -

kubectl Basics

Erstes Deployment

kubectl create deployment nginx --image=nginx --replicas=3
kubectl expose deployment nginx --port=80 --type=NodePort

K3s verbraucht deutlich weniger Ressourcen als Standard-Kubernetes und ist perfekt für ARM-Geräte.

Auf eigene Gefahr: Eine fehlerhafte Regelreihenfolge sperrt dich sofort per SSH aus — alles auf eigene Gefahr. Halte während der gesamten Einrichtung Tastatur und Monitor am Pi bereit, füge die SSH-Allow-Regel IMMER vor dem default-drop ein und lade neue Rulesets nur über den im Tutorial gezeigten timed-rollback (`sleep 60 && nft flush ruleset`), damit du dich nach 60 Sekunden automatisch wieder befreist.

Überblick & Topologie

Wir bauen einen einfachen Router/Firewall auf Raspberry Pi OS (Bookworm, 64-Bit). Der onboard-Ethernet-Port eth0 wird zum WAN (Richtung deinem bestehenden Router/Internet), der USB-3-Gigabit-Adapter eth1 wird zum LAN für deine Clients. nftables übernimmt Paketfilter und NAT.

1. LAN-Interface statisch konfigurieren

Raspberry Pi OS Bookworm nutzt NetworkManager. Vergib dem LAN-Adapter eine feste IP, das WAN bleibt auf DHCP:

sudo nmcli con add type ethernet ifname eth1 con-name lan \
  ipv4.method manual ipv4.addresses 192.168.50.1/24
sudo nmcli con up lan
ip -br addr   # Kontrolle: eth1 trägt jetzt 192.168.50.1/24

2. IP-Forwarding aktivieren

Damit der Pi Pakete zwischen den Interfaces weiterleitet, schalte IPv4-Forwarding dauerhaft ein:

echo 'net.ipv4.ip_forward=1' | sudo tee /etc/sysctl.d/99-router.conf
sudo sysctl --system
sysctl net.ipv4.ip_forward   # muss "= 1" liefern

3. nftables installieren

sudo apt update
sudo apt install -y nftables
sudo systemctl enable nftables

4. Sauberes Ruleset (default-drop + NAT)

Wichtig ist die Reihenfolge: erst die SSH-Erlaubnis, dann die policy drop. Lege die Datei /etc/nftables.conf an:

#!/usr/sbin/nft -f
flush ruleset

define WAN = "eth0"
define LAN = "eth1"

table inet filter {
    chain input {
        type filter hook input priority 0; policy drop;

        ct state established,related accept
        iif "lo" accept
        ip protocol icmp accept

        # SSH NUR vom LAN zulassen (vor jedem drop!)
        iifname $LAN tcp dport 22 accept

        # weitere LAN-Dienste (DHCP/DNS), falls du sie auf dem Pi betreibst
        iifname $LAN udp dport { 67, 68, 53 } accept
        iifname $LAN tcp dport 53 accept
    }

    chain forward {
        type filter hook forward priority 0; policy drop;

        ct state established,related accept
        # LAN darf raus ins WAN
        iifname $LAN oifname $WAN accept
    }

    chain output {
        type filter hook output priority 0; policy accept;
    }
}

table inet nat {
    chain postrouting {
        type nat hook postrouting priority 100; policy accept;
        oifname $WAN masquerade
    }
}

5. Mit timed-rollback testen (Aussperr-Schutz)

Lade das Ruleset niemals blind. Starte zuerst eine Sicherung, die nach 60 Sekunden alles wieder freiräumt — bestätigst du innerhalb der Zeit, dass SSH noch geht, brichst du sie ab:

# Notbremse: setzt die Firewall nach 120 s automatisch zurück.
# Sperrst du dich aus, hast du nach spätestens 120 s wieder Zugriff.
( sleep 120 && sudo nft flush ruleset ) &
ROLLBACK=$!

# Regeln laden
sudo nft -f /etc/nftables.conf

# In einer ZWEITEN SSH-Sitzung testen, ob der Zugriff bleibt.
# Wenn ja, Notbremse stoppen (sonst Reset nach 120 s):
kill "$ROLLBACK""

Verlierst du die Verbindung, wartest du 60 Sekunden — die Firewall wird geleert und du kommst wieder rein (notfalls über die direkt angeschlossene Tastatur). Prüfe das geladene Regelwerk mit:

sudo nft list ruleset

6. Regeln persistent machen

Der nftables.service lädt beim Boot genau /etc/nftables.conf. Da unsere Regeln bereits dort liegen, reicht ein Neustart des Dienstes:

sudo systemctl restart nftables
sudo systemctl status nftables   # active (exited) = ok

Nach einem Reboot stehen die Regeln automatisch. Änderst du das Ruleset, editiere immer die Datei und teste erneut mit dem timed-rollback aus Schritt 5.

7. SSH härten — damit du den Zugang behältst

Da der Pi jetzt ein Routing-Gerät ist, ist SSH-Härtung Pflicht. Hinterlege zuerst deinen Public Key (ssh-copy-id pi@192.168.50.1), prüfe den Login per Key, und passe dann /etc/ssh/sshd_config.d/99-hardening.conf an:

PermitRootLogin no
PasswordAuthentication no
PubkeyAuthentication yes
# Optional: SSH ausschließlich auf der LAN-IP lauschen
ListenAddress 192.168.50.1

sudo sshd -t                  # Syntax prüfen, bevor du neu lädst
sudo systemctl reload ssh

Optional: DHCP/DNS fürs LAN

Damit LAN-Clients automatisch IPs bekommen, installiere dnsmasq und binde es an eth1 mit Range 192.168.50.50–150 und Gateway/DNS 192.168.50.1. Die nötigen Ports 67/68/53 sind im Ruleset oben bereits für das LAN freigegeben.