Kapitel 02Free Rohtext.md aktualisiert

Kapitel 02Free Rohtext.md

@@ -0,0 +1,530 @@
+# Kapitel 2 – Pi-hole + Unbound (Rohtext)
+
+## Einleitung
+Werbung im Browser, Tracking auf dem Smartphone, Datenabfragen im Smart-TV – all das läuft im Hintergrund über DNS. Jeder Aufruf einer Webseite, jeder Klick in einer App löst eine DNS-Anfrage aus. Genau hier setzt **Pi-hole** an: es fängt diese Anfragen ab und filtert bekannte Werbe- und Trackingadressen heraus, bevor sie überhaupt geladen werden können. Das entlastet die Geräte, spart Bandbreite und sorgt für ein aufgeräumtes Netz.
+
+Zusammen mit **Unbound** als lokalem DNS-Resolver wird daraus eine besonders saubere Lösung. Unbound fragt nicht einfach einen externen DNS-Dienst wie Google oder Cloudflare, sondern löst jede Anfrage selbst von der Wurzel des Domain Name Systems bis zur Zieladresse auf. Damit bleiben die Daten im eigenen Netz, die Privatsphäre steigt deutlich, und es entsteht ein kleiner Geschwindigkeitsvorteil, weil der Weg kürzer ist.
+
+Für Content Creator und Streamer bedeutet das: weniger Ablenkung durch Werbung, stabile Netzwerkperformance und ein professionellerer Workflow. Für Privatnutzer: mehr Ruhe beim Surfen, besserer Schutz vor Tracking und ein Stück digitale Selbstbestimmung im eigenen Heimnetz.
+
+---
+
+## Voraussetzungen
+Bevor wir mit der Einrichtung starten, stellen wir sicher, dass die Grundlagen stimmen:
+
+- **Proxmox** ist bereits installiert und erreichbar (siehe Kapitel 1).
+- **Zugang zur Proxmox-Weboberfläche** über einen Browser im Heimnetz.
+- **Internetverbindung** für den Download des Container-Templates.
+- Grundverständnis: Was ist eine **IP-Adresse** und was ist eine **Domain**?
+- Ein wenig Geduld und Bereitschaft, sich durch die Proxmox-GUI zu klicken – wir führen durch jeden Schritt.
+
+Optional hilfreich:
+- Ein zweites Gerät (z. B. Tablet oder Smartphone), um die Anleitung nebenher geöffnet zu haben, während man in Proxmox arbeitet.
+
+---
+## Schritt für Schritt
+### Container anlegen
+Jetzt legen wir den Container an, in dem Pi-hole und Unbound **gemeinsam** laufen werden.
+
+1) **CT erstellen** anklicken  
+   👉 *Screenshot geeignet: Schaltfläche „CT erstellen“ oben rechts.*
+
+2) **Allgemein**  
+   - **Knoten:** (dein Proxmox-Host)  
+   - **CT ID:** automatisch vergeben oder nach Wunsch anpassen  
+   - **Hostname:** `pihole`  
+   - **Unprivilegierter Container:** aktivieren (empfohlen)  
+   - **Passwort:** Root-Passwort vergeben und merken  
+   - **SSH-Schlüssel:** optional (falls vorhanden)  
+   👉 *Screenshot geeignet: Reiter „Allgemein“.*
+
+3) **Vorlage**  
+   - **Speicher:** z. B. `local-lvm`  
+   - **Vorlage:** `Debian 12.7.1 Standard` auswählen  
+   👉 *Screenshot geeignet: Reiter „Vorlage“.*
+
+4) **Root-Disk**  
+   - **Größe:** 6–8 GB reichen vollkommen  
+   👉 *Screenshot geeignet: Reiter „Root-Disk“.*
+
+5) **CPU**  
+   - **Kerne:** 1  
+   - Rest auf Standard belassen  
+   👉 *Screenshot geeignet: Reiter „CPU“.*
+
+6) **Arbeitsspeicher**  
+   - **RAM:** 512 MB – 1 GB  
+   - **Swap:** 0–256 MB (optional)  
+   👉 *Screenshot geeignet: Reiter „Arbeitsspeicher“.*
+
+7) **Netzwerk**  
+   - **Bridge:** `vmbr0` (Standard)  
+   - **IPv4:** `Statisch`  
+   - **IPv4/CIDR:** feste Adresse eintragen, z. B. `192.168.1.5/24`  
+   - **Gateway (IPv4):** Router-IP, z. B. `192.168.1.1`  
+   - **IPv6:** `DHCP` (für spätere Nutzung, z. B. Proxy Manager)  
+   👉 *Screenshot geeignet: Reiter „Netzwerk“ mit statischer IPv4 und IPv6 DHCP.*
+
+> [!WARNING]  
+> **Wichtig:** Pi-hole benötigt unbedingt eine **feste IPv4-Adresse**.  
+> Ohne feste IP können Router und Clients den DNS-Traffic nicht korrekt weiterleiten.
+
+> [!TIP]  
+> Reserviere die feste IPv4 auch in deinem Router (DHCP-Reservierung), damit sie nicht doppelt vergeben wird.
+
+8) **DNS**  
+   - **DNS-Server:** leer lassen  
+   - **Suchdomäne:** leer lassen  
+   👉 *Screenshot geeignet: Reiter „DNS“.*
+
+> [!NOTE]  
+> Es wird kein DNS-Server eingetragen.  
+> Zunächst nutzt der Container die Host-Einstellungen von Proxmox.  
+> Später, nach der Installation, stellen wir den Container auf `127.0.0.1` um, damit er Pi-hole/Unbound selbst nutzt.
+
+9) **Bestätigen**  
+   - Übersicht prüfen  
+   - Mit **Fertigstellen** abschließen  
+   👉 *Screenshot geeignet: Reiter „Bestätigen“.*
+
+### Prüfen
+- Container erscheint links in der Server-Ansicht.  
+- Über **Start** → Container hochfahren.  
+- Über **Konsole** → Login mit `root` und vergebenem Passwort.
+
+### Erster Zugriff
+
+Direkt nach dem Anlegen ist der Container über die **Proxmox-Konsole** erreichbar.  
+Ein SSH-Dienst läuft bereits, aber Root darf sich nicht per SSH anmelden.  
+Darum legen wir uns zuerst in der Proxmox-Konsole einen eigenen Benutzer an.
+
+1. Container in der Proxmox-Weboberfläche auswählen → oben **Konsole** anklicken.  
+   👉 *Screenshot geeignet: geöffnete Konsole in Proxmox.*
+
+2. In der Konsole einen neuen Benutzer erstellen:  
+
+   ```bash
+   adduser adminuser
+   ```
+   - Passwort vergeben  
+   - Alle weiteren Fragen (Name, Raum, etc.) mit Enter überspringen
+
+3. Diesem Benutzer Admin-Rechte geben:  
+
+   ```bash
+   usermod -aG sudo adminuser
+   ```
+
+#### Verbindung vom Mac/PC aus
+
+- **macOS / Linux (Terminal):**
+
+  ```bash
+  ssh adminuser@192.168.1.5
+  ```
+  👉 *Screenshot geeignet: Terminal mit erfolgreichem SSH-Login.*
+
+- **Windows (WinSCP):**  
+  - Neue Sitzung → Protokoll **SFTP**  
+  - Hostname: `192.168.1.5`  
+  - Benutzername: `adminuser`  
+  - Passwort: das beim `adduser` vergebene  
+  👉 *Screenshot geeignet: WinSCP-Loginfenster mit Benutzer „adminuser“.*
+
+#### Optional: Root-SSH erlauben
+
+Falls Root-Zugang per SSH benötigt wird:
+
+1. Konfiguration öffnen:  
+
+   ```bash
+   nano /etc/ssh/sshd_config
+   ```
+
+2. Mit `Strg+W` nach `PermitRootLogin` suchen.  
+3. Wert auf `yes` setzen.  
+4. Speichern mit `Strg+O`, Enter → Beenden mit `Strg+X`.  
+5. SSH neu starten:  
+
+   ```bash
+   systemctl restart ssh
+   ```
+
+- **macOS / Linux (Terminal):**
+
+  ```bash
+  ssh root@192.168.1.5
+  ```
+
+- **Windows (WinSCP):**  
+  Mit Benutzer `root` verbinden.
+
+> [!WARNING]  
+> Root-SSH ist unsicher, wenn dein Netzwerk nicht geschützt ist. Verwende diese Option nur, wenn es unbedingt notwendig ist.
+
+### Installation Pi-hole
+
+Bevor wir Pi-hole installieren, aktualisieren wir zuerst das System im Container.
+
+```bash
+apt update
+apt upgrade -y
+```
+
+Danach laden wir das Installationsskript von Pi-hole und starten es:
+
+```bash
+curl -sSL https://install.pi-hole.net | bash
+```
+
+> [!TIP]  
+> Sollte `curl` nicht installiert sein, kannst du es mit `apt install curl -y` nachholen.
+
+Das Installationsskript startet eine geführte Einrichtung im Terminal.  
+Hier werden wir Schritt für Schritt durch die Grundkonfiguration geführt (z. B. Netzwerkkarte, Upstream-DNS, Blocklisten).  
+
+👉 *Screenshot geeignet: Start des Pi-hole Installationsskripts im Terminal.*
+
+#### Konfiguration während der Installation
+
+Das Installationsskript führt dich durch mehrere Auswahlmenüs.  
+Alle Eingaben machst du mit den Pfeiltasten und bestätigst mit **Enter**.
+
+1. **Netzwerkschnittstelle wählen**  
+   - Wähle die Schnittstelle aus, die du bei der Container-Erstellung konfiguriert hast (meist `eth0`).  
+   👉 *Screenshot geeignet: Auswahl der Netzwerkschnittstelle.*
+
+2. **Statische IP bestätigen**  
+   - Die feste IPv4-Adresse, die wir beim Anlegen des Containers vergeben haben, wird hier angezeigt.  
+   - Bestätige diese Einstellung.  
+   👉 *Screenshot geeignet: Anzeige der statischen IP.*
+
+3. **Upstream DNS-Server**  
+   - Für den Moment kannst du einen externen Resolver auswählen (z. B. Quad9 oder Cloudflare).  
+   - Später ersetzen wir diesen durch unseren eigenen Unbound-Resolver.  
+   👉 *Screenshot geeignet: Auswahl Upstream-DNS.*
+
+4. **Blocklisten**  
+   - Die Standard-Blockliste von Pi-hole reicht für den Anfang.  
+   - Weitere Listen können später im Webinterface hinzugefügt werden.
+
+5. **Protokollierung**  
+   - Empfehlung: **Anonymisierte Logs** aktivieren, damit Statistiken vorhanden sind, aber keine kompletten Client-IPs gespeichert werden.  
+   👉 *Screenshot geeignet: Auswahl der Logging-Einstellungen.*
+
+Am Ende zeigt das Skript eine Übersicht und bestätigt die Installation.
+
+> [!NOTE]  
+> Nach Abschluss der Installation erhältst du die **Admin-Weboberfläche** von Pi-hole und ein **Web-Admin-Passwort**.  
+> Dieses Passwort unbedingt notieren – ohne kannst du dich später nicht anmelden.
+
+### Installation Unbound
+
+#### Was ist Unbound?
+
+Unbound ist ein sogenannter **rekursiver DNS-Resolver**.  
+Im Gegensatz zu externen DNS-Anbietern (z. B. Google 8.8.8.8 oder Cloudflare 1.1.1.1) löst Unbound deine DNS-Anfragen **selbstständig** auf.  
+Das bedeutet:  
+
+1. Unbound fragt direkt bei den **Root-Servern** des Internets nach.  
+2. Von dort bekommt er die Adresse der zuständigen **Top-Level-Domain-Server** (z. B. `.com`).  
+3. Dann fragt er bei diesen nach dem **autoritativen Server** für die gesuchte Domain (z. B. `example.com`).  
+4. Schließlich liefert Unbound die endgültige IP-Adresse zurück.  
+
+Damit fallen externe DNS-Dienste komplett weg.  
+Alle Auflösungen passieren lokal in deinem Netzwerk.  
+Das sorgt für **mehr Privatsphäre** und macht dich unabhängiger von Dritten.  
+
+👉 *Screenshot geeignet: Netzwerkaufbau mit und ohne Unbound – links der Weg über externe DNS-Server, rechts der direkte Weg über Unbound mit Root-Servern.*
+
+> [!NOTE]  
+> Der **erste Aufruf einer Domain** kann über Unbound etwas länger dauern, da die komplette Kette abgefragt werden muss.  
+> Danach wird das Ergebnis zwischengespeichert (Caching), sodass weitere Aufrufe sofort beantwortet werden.
+
+---
+
+#### Unbound installieren
+
+Unbound wird über die Paketverwaltung installiert:
+
+```bash
+apt install unbound -y
+```
+
+Zusätzlich benötigt Unbound die Root-Hints, also die Adressen der Root-Server des Internets:
+
+```bash
+wget https://www.internic.net/domain/named.cache -O /var/lib/unbound/root.hints
+```
+
+---
+
+#### Unbound konfigurieren
+
+Jetzt erstellen wir eine Konfigurationsdatei, die speziell auf Pi-hole abgestimmt ist:
+
+```bash
+nano /etc/unbound/unbound.conf.d/pi-hole.conf
+```
+
+Folgenden Inhalt einfügen:
+
+```bash
+server:
+    verbosity: 0
+    interface: 127.0.0.1
+    port: 5335
+    do-ip4: yes
+    do-udp: yes
+    do-tcp: yes
+    do-ip6: yes
+    root-hints: "/var/lib/unbound/root.hints"
+    harden-glue: yes
+    harden-dnssec-stripped: yes
+    use-caps-for-id: no
+    edns-buffer-size: 1232
+    prefetch: yes
+    num-threads: 2
+    so-rcvbuf: 1m
+```
+
+- **interface 127.0.0.1 & port 5335** → Unbound lauscht nur lokal und nicht im gesamten Netzwerk, was die Sicherheit erhöht.  
+- **root-hints** → verweist auf die Root-Server-Datei.  
+- **harden-Optionen** → sorgen für zusätzliche Sicherheit und DNSSEC-Unterstützung.  
+- **prefetch** → häufig angefragte Domains werden im Cache aktuell gehalten.  
+
+Datei speichern mit **Strg+O**, Enter → Beenden mit **Strg+X**.
+
+---
+
+#### Unbound starten
+
+Unbound aktivieren und starten:
+
+```bash
+systemctl enable unbound
+systemctl restart unbound
+systemctl status unbound
+```
+
+> [!TIP]  
+> Wenn alles funktioniert, zeigt der Status **active (running)**.  
+> Falls Fehler auftreten, können sie mit `journalctl -xe` angezeigt werden.
+
+#### Unbound testen
+
+Bevor wir Pi-hole mit Unbound verbinden, prüfen wir, ob Unbound korrekt läuft.  
+Dafür nutzen wir das Tool `dig`, das DNS-Abfragen testet.  
+
+Falls es noch nicht installiert ist:  
+
+```bash
+apt install dnsutils -y
+```
+
+Jetzt eine Testabfrage direkt an Unbound:  
+
+```bash
+dig @127.0.0.1 -p 5335 example.com
+```
+
+Wichtige Punkte in der Ausgabe:  
+- **Status: NOERROR** → bedeutet, die Domain wurde erfolgreich aufgelöst.  
+- **SERVER: 127.0.0.1#5335** → zeigt, dass Unbound selbst geantwortet hat.  
+- **ANSWER SECTION** enthält die IP-Adresse von `example.com`.  
+
+👉 *Screenshot geeignet: Terminalausgabe eines erfolgreichen dig-Befehls.*
+
+> [!NOTE]  
+> Beim **ersten Aufruf einer Domain** dauert die Antwort etwas länger, da Unbound den kompletten Weg von den Root-Servern bis zur Ziel-Domain abfragt.  
+> Jeder weitere Aufruf ist sofort im Cache und dadurch schneller.
+
+### Erster Login in die Pi-hole Weboberfläche
+
+Nach der Installation von Pi-hole erreichen wir die Weboberfläche im Browser:
+
+```
+http://192.168.1.5/admin
+```
+
+👉 *Screenshot geeignet: Loginseite der Pi-hole Weboberfläche.*
+
+Das Passwort wurde am Ende der Installation im Terminal angezeigt.  
+Falls du es nicht notiert hast, kannst du es im Container neu setzen:
+
+```bash
+pihole -a -p
+```
+
+#### Blocklisten & Whitelist einrichten
+
+Die meiste Arbeit erledigen wir bequem in der Pi-hole Weboberfläche.
+
+1. **Blocklisten hinzufügen**  
+   - Menü öffnen: **Group Management → Adlists**  
+   - Jede URL einzeln eintragen und als Gruppe **Default** auswählen.  
+   - Mit **Add** bestätigen.  
+
+   👉 *Screenshot geeignet: Adlists-Seite mit mehreren eingetragenen Listen.*
+
+2. **Listen aktualisieren (Gravity Update)**  
+   - Menü: **Tools → Update Gravity**  
+   - Button **Update** anklicken.  
+   - Nach kurzer Zeit ist die Datenbank aktualisiert.  
+   👉 *Screenshot geeignet: Update Gravity mit Fortschrittsanzeige.*
+
+3. **Wichtige Dienste freigeben (Whitelist)**  
+   - Menü: **Group Management → Domains → Whitelist**  
+   - Beispiele für Regex-Einträge, um WhatsApp oder Facebook zuverlässig freizugeben:  
+     ```
+     (^|\.)whatsapp\.com$
+     (^|\.)facebook\.com$
+     ```
+   👉 *Screenshot geeignet: Domain-Management mit Regex-Whitelist.*
+
+> [!TIP]  
+> Fast alles in Pi-hole lässt sich über die Weboberfläche erledigen.  
+> Das Terminal ist nur Plan B, falls die GUI mal nicht erreichbar ist.
+#### Logging
+Unter **Settings → Privacy** stellst du ein, wie Pi-hole mit Logs umgeht:
+
+- **Anonymous mode** (empfohlen): Anfragen werden gezählt, aber ohne Client-IP gespeichert.  
+- **Show everything**: nur nutzen, wenn du detaillierte Fehleranalysen machen willst.  
+
+👉 *Screenshot geeignet: Auswahlfeld „Privacy mode“.*
+
+
+#### Upstream-DNS auf Unbound setzen
+Jetzt verbinden wir Pi-hole mit unserem lokalen Resolver:
+
+1. Gehe zu **Settings → DNS**.  
+2. Entferne alle externen Upstream-Server (Cloudflare, Google usw.).  
+3. Trage stattdessen ein:  
+   ```
+   127.0.0.1#5335
+   ```
+4. Speichern.  
+
+👉 *Screenshot geeignet: Pi-hole DNS-Konfiguration mit 127.0.0.1#5335.*
+
+### Router auf Pi-hole umstellen
+
+Damit Pi-hole Anfragen bearbeiten kann, müssen wir den DNS-Server im Netzwerk ändern.  
+Dafür gibt es zwei Möglichkeiten:
+
+1. **Am Router (empfohlen)**  
+   - Im Router-Interface den Bereich **Netzwerk / DHCP / DNS-Server** öffnen.  
+   - Als primären DNS-Server die feste IP des Containers eintragen (z. B. `192.168.1.5`).  
+   - Speichern und Router kurz neu starten.  
+   👉 *Screenshot geeignet: Router-Einstellung DNS-Server.*
+
+   > [!TIP]  
+   > So nutzt jedes Gerät im Netzwerk automatisch Pi-hole, ohne dass man sie einzeln konfigurieren muss.
+
+2. **Am einzelnen Gerät (für Tests)**  
+   - In den Netzwerkeinstellungen des PCs oder Smartphones manuell als DNS-Server `192.168.1.5` eintragen.  
+   - Verbindung trennen und neu verbinden.  
+
+### Funktion prüfen
+
+- Öffne eine Webseite am PC/Smartphone, das den neuen DNS-Server nutzt.  
+- Im Pi-hole-Dashboard (**http://192.168.1.5/admin**) sollten jetzt die ersten Anfragen sichtbar sein.  
+- Dort erkennst du: Blockierte Anfragen, durchgelassene Anfragen und die Gesamtzahl.  
+👉 *Screenshot geeignet: Pi-hole Dashboard mit ersten Anfragen.*
+
+### Troubleshooting
+
+Auch wenn Pi-hole und Unbound sehr stabil laufen, können beim ersten Einsatz typische Probleme auftreten.  
+Dieser Abschnitt zeigt dir, wie du sie erkennst und behebst – Schritt für Schritt.
+
+#### Problem: Die Pi-hole Weboberfläche lädt nicht
+**Symptom:** Du öffnest `http://192.168.1.5/admin`, aber die Seite bleibt weiß oder der Browser meldet „nicht erreichbar“.
+
+**Ursachen & Lösungen:**
+1. Prüfen, ob der Container läuft. In der Proxmox-Weboberfläche sollte er grün markiert sein.  
+   👉 *Screenshot geeignet: Container-Übersicht mit Status.*
+2. Falls er gestoppt ist: Container auswählen → **Start** anklicken.  
+3. Stimmt die feste IP? Überprüfe in den Netzwerkeinstellungen des Containers, ob die IPv4 mit der eingestellten Adresse übereinstimmt (z. B. `192.168.1.5`).  
+4. Versuch die Weboberfläche mit der direkten IP: `http://<Container-IP>/admin`.
+
+#### Problem: Im Dashboard erscheinen keine Anfragen
+**Symptom:** Das Dashboard bleibt leer, obwohl Geräte im Netzwerk aktiv sind.
+
+**Ursachen & Lösungen:**
+1. Wahrscheinlich verteilt der Router noch den Provider-DNS oder einen externen Server.  
+2. Prüfe die Router-Einstellungen → DHCP / DNS-Server.  
+   - Als primären DNS muss die Container-IP eingetragen sein.  
+   - Beispiel: `192.168.1.5`  
+   👉 *Screenshot geeignet: Router-Einstellung für DNS-Server.*
+3. Nach dem Speichern ggf. Router kurz neu starten.  
+4. Alternativ: Testweise am PC/Smartphone den DNS manuell auf `192.168.1.5` setzen und neu verbinden.  
+
+#### Problem: Unbound startet nicht
+**Symptom:** Pi-hole läuft, aber Anfragen werden nicht beantwortet, oder `systemctl status unbound` zeigt „failed“.
+
+**Ursachen & Lösungen:**
+1. Häufig liegt ein Tippfehler in der Konfigurationsdatei `/etc/unbound/unbound.conf.d/pi-hole.conf`.  
+   - Öffne sie mit `nano` und vergleiche sie mit dem Tutorial.  
+   - Achte besonders auf den Pfad der Root-Hints (`/var/lib/unbound/root.hints`).  
+2. Prüfe die Logs:  
+   ```bash
+   journalctl -xe
+   ```  
+   👉 *Screenshot geeignet: Logausgabe mit Fehlermeldung.*
+3. Nach Korrekturen Unbound neu starten:  
+   ```bash
+   systemctl restart unbound
+   ```
+
+#### Problem: Webseiten laden sehr langsam
+**Symptom:** Erste Aufrufe dauern ungewöhnlich lange.
+
+**Ursachen & Lösungen:**
+1. Das ist beim **allerersten Aufruf** einer Domain normal – Unbound fragt den kompletten Weg ab (Root → TLD → autoritativer Server).  
+2. Danach werden Ergebnisse im Cache gespeichert. Jeder weitere Aufruf derselben Domain ist sofort da.  
+3. Falls es dauerhaft langsam bleibt:  
+   - Stelle sicher, dass die Zeile `edns-buffer-size: 1232` in der Unbound-Konfig enthalten ist.  
+   - Diese Einstellung vermeidet Fragmentierungsprobleme bei IPv6 und großen Antworten.
+
+#### Problem: Apps wie WhatsApp oder Facebook funktionieren nicht
+**Symptom:** Nachrichten werden nicht zugestellt oder bestimmte Apps laden nicht richtig.
+
+**Ursachen & Lösungen:**
+1. Manche Blocklisten sind sehr strikt und sperren Domains, die für diese Dienste nötig sind.  
+2. Lösung: In der Pi-hole Weboberfläche unter **Group Management → Domains → Whitelist** Regex-Ausnahmen eintragen:  
+   ```
+   (^|\.)whatsapp\.com$
+   (^|\.)facebook\.com$
+   ```
+3. Danach Blocklisten neu laden: **Tools → Update Gravity**.  
+   👉 *Screenshot geeignet: Domain-Management mit Whitelist-Einträgen.*
+
+> [!TIP]  
+> Viele Probleme erkennst du direkt im **Query Log** der Pi-hole Weboberfläche.  
+> Dort siehst du, welche Domains blockiert wurden – und kannst entscheiden, ob sie auf die Whitelist gehören.
+
+## Ergebnis
+
+Wir haben nun ein funktionierendes System aus **Pi-hole und Unbound** in einem einzigen Container:
+
+- Pi-hole filtert Werbung und Tracking netzwerkweit.  
+- Unbound löst alle DNS-Anfragen rekursiv auf – direkt von den Root-Servern bis zur Ziel-Domain.  
+- Durch die Kombination sind wir unabhängig von externen DNS-Anbietern und behalten die volle Kontrolle über unsere Daten.  
+- Blocklisten sorgen für eine starke Filterwirkung, Regex-Whitelist-Einträge stellen sicher, dass wichtige Dienste wie WhatsApp oder Facebook weiterhin nutzbar bleiben.  
+- Über die Weboberfläche können alle Einstellungen komfortabel gepflegt und jederzeit erweitert werden.  
+
+👉 *Screenshot geeignet: Pi-hole Dashboard mit laufenden Statistiken (Anfragen gesamt, blockierte Anfragen, verwendete Listen).*
+
+> [!NOTE]  
+> **Nicht alle Werbung kann gefiltert werden.**  
+> Dienste wie YouTube oder Spotify liefern Werbung über dieselben Server wie die eigentlichen Inhalte.  
+> Pi-hole kann solche Werbung nicht zuverlässig blockieren, ohne auch die Inhalte selbst zu unterbrechen.
+
+> [!TIP]  
+> Ab jetzt läuft die gesamte DNS-Auflösung deines Heimnetzes durch Pi-hole + Unbound.  
+> Jede Anfrage, die im Dashboard erscheint, bestätigt: dein Netzwerk filtert erfolgreich.
+
+## Ausblick
+
+Im nächsten Kapitel kümmern wir uns um den **Nginx Proxy Manager (NPM)**.  
+Damit stellen wir die Weichen, um alle unsere Dienste sicher und übersichtlich nach außen verfügbar zu machen – mit HTTPS-Zertifikaten und zentralem Zugriffspunkt.