Raspberry Pi Tutorials

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.