Pi-hole v6 mit Unbound

Pi-hole V6 Mit Unbound

Pi-hole v6 mit Unbound (Docker Compose)

Pi-hole wurde vor kurzem von Version 5 auf v6 gehievt. Vor dem Update muss man ein paar Sachen in der docker-compose.yml anpassen. Das ist in den Docs ganz gut beschrieben. Mein yaml-Dings für Pihole und Unbound sieht momentan so aus:

services:
  pihole:
    depends_on:
      - unbound
    image: pihole/pihole:latest
    container_name: pihole
    hostname: dns1
    ports:
      - 53:53/tcp
      - 53:53/udp
      - 8080:80/tcp
    environment:
      TZ: Europe/Berlin
      FTLCONF_webserver_api_password: 'super-strong-password'
      FTLCONF_dns_upstreams: 'unbound'
      FTLCONF_dns_revServers: 'true,192.168.x.0/16,192.168.x.1,fritz.box'
    volumes:
      - ./pihole_etc:/etc/pihole
      - ./pihole_dnsmasq:/etc/dnsmasq.d
    restart: unless-stopped

  unbound:
    container_name: unbound
    restart: unless-stopped
    image: klutchell/unbound
    networks:
      default:
        ipv4_address: 172.x.0.53

networks:
  default:
       ipam:
         config:
           - subnet: 172.x.0.0/24

Läuft alles sehr geschmeidig und voll fluffig im heimischen Internetz.

Wallos: Personal Subscription Tracker

Wallos

Wallos: Personal Subscription Tracker

Wallos ist ein hilfreiches Tool, um deine Abonnements übersichtlich zu verwalten. Ob Streaming-Dienste, Software-Abos oder Fitness-Mitgliedschaften – Wallos hilft dir, Kosten, Zahlungsfristen und Laufzeiten im Blick zu behalten. Mit einer einfachen Benutzeroberfläche kannst du Abos schnell hinzufügen und wirst rechtzeitig an bevorstehende Zahlungen erinnert. So behältst du nicht nur die Kontrolle über deine Finanzen, sondern vermeidest auch unerwartete Abbuchungen. Wallos ist die ideale Lösung für alle, die ihre Abos unkompliziert und effizient organisieren möchten.

Aber nicht erschrecken! Mit Wallos wird einem das finanzielle Desaster der Abo-Modelle direkt und knallhart angezeigt.

Installation mit Docker Compose

Wallos lässt sich ganz lässig mit Docker Compose installieren:

services:
  wallos:
    container_name: wallos
    image: bellamy/wallos:latest
    ports:
      - "8282:80/tcp"
    environment:
      TZ: 'Europe/Berlin'
    # Volumes store your data between container upgrades
    volumes:
      - './db:/var/www/html/db'
      - './logos:/var/www/html/images/uploads/logos'
    restart: unless-stopped

Sie sehen gerade einen Platzhalterinhalt von YouTube. Um auf den eigentlichen Inhalt zuzugreifen, klicken Sie auf die Schaltfläche unten. Bitte beachten Sie, dass dabei Daten an Drittanbieter weitergegeben werden.

Mehr Informationen

Beszel – server resource monitoring hub

Beszel - server resource monitoring hub - docker-compose.yml

Beszel – server resource monitoring hub

Die Kombination aus Grafana und Prometheus war/ist mir immer etwas zu mächtig für das Monitoring meiner drei Raspberry Pi’s und ein/zwei Maschinen bei Hetzner. Also habe ich auf jedem „Gerät“ Glances installiert. Schön schlank und mit vielen Informationen, aber leider nicht zentral auf einem Dashboard darzustellen.

Vor kurzem lief mir Beszel (»A lightweight server resource monitoring hub«) über den Weg. Seit Sonnabend läuft das Ding -wie vorhin schon mal angeteasert – im persönlichen Netzwerk und ich bin schon mal sehr zufrieden.

Beszel?

Beszel ist ein leichtgewichtiges Server-Überwachungssystem mit folgenden Hauptmerkmalen:

  • Ressourcenschonend im Vergleich zu anderen Lösungen
  • Docker-Statistiken für CPU- und Speichernutzung
  • Konfigurierbare Alarme für Ressourcenauslastung
  • Mehrbenutzer-Unterstützung mit Adminrechten
  • Einfache Einrichtung ohne öffentliche Erreichbarkeit
  • OAuth/OIDC-Authentifizierung
  • Automatische Backups (lokal oder S3-kompatibel)
  • REST-API für eigene Anwendungen

Beszel - server resource monitoring hub - All Systems

Beszel - server resource monitoring hub - One Server View

Das System besteht aus zwei Komponenten:

  • Hub: Web-Anwendung für das Dashboard
  • Agent: Läuft auf den zu überwachenden Systemen

Einrichtung

Die Einrichtung erfolgt durch Starten des Hubs, Erstellen eines Admin-Benutzers, Hinzufügen von Systemen und Ausführen des Agenten (entweder als Docker-Container oder Binärdatei) auf den Zielsystemen. Hier laufen natürlich beide Komponenten in Docker Containern.

Hier die easy peasy docker-compose.yml für den Hub:

services:
  beszel:
    image: 'henrygd/beszel'
    container_name: 'beszel'
    restart: unless-stopped
    ports:
      - '8090:8090'
    volumes:
      - ./beszel_data:/beszel_data

Für den Agent wird eine docker-compose.yml beim Hinzufügen eines Servers automatisch erstellt. Das sieht dann ungefähr so aus:

services:
  beszel-agent:
    image: 'henrygd/beszel-agent'
    container_name: 'beszel-agent'
    restart: unless-stopped
    network_mode: host
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
    environment:
      PORT: 45876
      KEY: 'ssh-ed25519 YOUR_PUBLIC_KEY'
      # FILESYSTEM: /dev/sda1 # set to the correct filesystem for disk I/O stats

Auf der Github-Seite des Projekts ist das alles nochmal lässig und in voller Gänze beschrieben. Läuft voll schnafte!

Sie sehen gerade einen Platzhalterinhalt von YouTube. Um auf den eigentlichen Inhalt zuzugreifen, klicken Sie auf die Schaltfläche unten. Bitte beachten Sie, dass dabei Daten an Drittanbieter weitergegeben werden.

Mehr Informationen

WireGuard Easy

WireGuard Easy

WireGuard Easy (Docker Compose)

I know, man kann ganz einfach in der Fritz!Box eine VPN-Verbindung mit WireGuard einrichten. Aber noch einfacher und auch etwas schöner funktioniert das mit WireGuard Easy. Schon bei der Installation mit Docker Compose (z.B. auf dem heimischen Raspberry Pi) kann man nicht viel falsch machen (docker-compose.yml). Hier muss man nicht mit mehreren Container rumhantieren, sondern es ist alles notwendige in einer „Maschine“ verfügbar. Ein oder zwei Sachen anpassen und gut ist es. Für die Einrichtung von VPN Verbindungen darf man zudem die sehr übersichtliche Weboberfläche von wg-easy nutzen. Alles ganz Easy!

docker-compose.yml

version: "3.8"
services:
  wg-easy:
    environment:
      - WG_HOST=vpn.example.com
      - PASSWORD=EinSicheresPasswortFürDieWebUI
      - WG_PORT=51820
      - WG_DEFAULT_DNS=1.1.1.1,1.0.0.1 #DNSServerDerWahl
      - WG_MTU=1280
      - LANG=de #SpracheinstellungFürDieWebUI

    image: ghcr.io/wg-easy/wg-easy
    container_name: wg-easy
    volumes:
      - ./wireguard:/etc/wireguard
    ports:
      - "51820:51820/udp" #WireGuardPort
      - "51821:51821/tcp" #WebUIPort
    restart: unless-stopped
    cap_add:
      - NET_ADMIN
      - SYS_MODULE
    sysctls:
      - net.ipv4.ip_forward=1
      - net.ipv4.conf.all.src_valid_mark=1

Basics: WireGuard

WireGuard ist ein fortschrittliches, schnelles und schlankes Virtual Private Network (VPN)-Protokoll, das für sichere Netzwerkverbindungen entwickelt wurde. Im Vergleich zu älteren VPN-Technologien wie OpenVPN oder IPSec bietet WireGuard eine einfachere Codebasis und eine verbesserte Leistung. Es wurde entwickelt, um einfach einzurichten und zu verwenden zu sein, während es gleichzeitig starke Sicherheit und Datenschutz bietet.

Einige der Hauptmerkmale von WireGuard sind seine Geschwindigkeit, Effizienz und Modernität. Es ist in den Linux-Kernel integriert und wurde auch für andere Plattformen wie Windows, macOS, Android und iOS portiert. WireGuard verwendet moderne kryptographische Techniken, um Sicherheit zu gewährleisten und bietet eine schnellere Verbindungsgeschwindigkeit im Vergleich zu älteren VPN-Protokollen.

Dank seiner Einfachheit und Effizienz wird WireGuard in verschiedenen Anwendungen eingesetzt, von privaten VPN-Verbindungen bis hin zu Unternehmensnetzwerken und sogar in einigen Fällen von kommerziellen VPN-Diensten. Es hat sich schnell zu einem beliebten VPN-Protokoll entwickelt, das für seine Leistung und Sicherheit geschätzt wird.

Bitwarden Unified (Beta)

Bitwarden Unified

Bitwarden Unified (Beta / Docker)

Bisher hatte ich für meine Passwörter einen Vaultwarden-Container auf dem heimischen Raspberry Pi 4 am laufen. Ab heute läuft das Original: Bitwarden Unified (Self Host Beta).

Die Installation ging überraschend einfach. docker-compose.yml und settings.env anpassen, mit docker compose up -d anwerfen und fertig ist die Passwort-Halde. Hamma!

Bitwarden Unified

Bitwarden Unified

docker-compose.yml

version: "3.8"

services:
  bitwarden:
    depends_on:
      - db
    env_file:
      - settings.env
    image: bitwarden/self-host:beta
    container_name: bitwarden
    restart: always
    ports:
      - "8080:8080"
      - "8443:8443"
    volumes:
      - ./bitwarden:/etc/bitwarden
      - ./logs:/var/log/bitwarden

  db:
    image: postgres:latest
    container_name: bitwarden_db
    environment:
      POSTGRES_USER: "bitwarden"
      POSTGRES_PASSWORD: "bitwarden"
      POSTGRES_DB: "bitwarden"
    restart: always
    volumes:
      - ./data:/var/lib/postgresql/data

volumes:
  bitwarden:
  logs:
  data:

settings.env

#####################
# Required Settings #
#####################

# Server hostname
BW_DOMAIN=bitwarden.example.com

# Database
# Available providers are sqlserver, postgresql, mysql/mariadb, or sqlite
BW_DB_PROVIDER=postgresql
BW_DB_SERVER=db
BW_DB_DATABASE=bitwarden
BW_DB_USERNAME=bitwarden
BW_DB_PASSWORD=bitwarden

# Installation information
# Get your ID and key from https://bitwarden.com/host/
BW_INSTALLATION_ID=xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
BW_INSTALLATION_KEY=xxxxxxxxxxxxxxxxxxxx

#####################
# Optional Settings #
#####################
# Learn more here: https://bitwarden.com/help/environment-variables/

# Container UID/GID
#UID=1000
#GID=1000

# Webserver ports
BW_PORT_HTTP=8080
BW_PORT_HTTPS=8443

# SSL
#BW_ENABLE_SSL=true
#BW_ENABLE_SSL_CA=true
#BW_SSL_CERT=ssl.crt
#BW_SSL_KEY=ssl.key
#BW_SSL_CA_CERT=ca.crt

# Services
# Some services, namely for enterprise use cases, are disabled by default. Defaults shown below.
BW_ENABLE_ADMIN=true
BW_ENABLE_API=true
#BW_ENABLE_EVENTS=false
BW_ENABLE_ICONS=true
#BW_ENABLE_IDENTITY=true
BW_ENABLE_NOTIFICATIONS=true
#BW_ENABLE_SCIM=false
#BW_ENABLE_SSO=false

#BW_ICONS_PROXY_TO_CLOUD=false

# Mail
globalSettings__mail__replyToEmail=bitwarden@example.com
globalSettings__mail__smtp__host=smtp.example.com
globalSettings__mail__smtp__port=587
globalSettings__mail__smtp__ssl=true
globalSettings__mail__smtp__username=username
globalSettings__mail__smtp__password=password

# Yubikey
#globalSettings__yubico__clientId=REPLACE
#globalSettings__yubico__key=REPLACE

# Other
globalSettings__disableUserRegistration=false
#globalSettings__hibpApiKey=REPLACE
adminSettings__admins=bitwarden@example.com

Basics: Bitwarden

Bitwarden ist eine Open-Source-Passwort-Manager-Software, die entwickelt wurde, um Benutzern zu helfen, ihre Passwörter sicher zu verwalten und zu speichern. Mit Bitwarden können Benutzer ihre Passwörter, Kreditkarteninformationen und andere vertrauliche Daten in einem verschlüsselten Tresor speichern, der durch ein Master-Passwort geschützt ist. Die Software bietet Funktionen wie das automatische Ausfüllen von Anmeldeinformationen, die Generierung sicherer Passwörter, die Synchronisierung über verschiedene Geräte hinweg und die Möglichkeit, sichere Notizen zu erstellen. Bitwarden ist auf verschiedenen Plattformen verfügbar, einschließlich Webbrowser-Erweiterungen, Desktop-Anwendungen, Mobile-Apps und Selbst gehosteten Instanzen für fortgeschrittene Benutzer.

Pi-hole mit Unbound

Pi-hole mit Unbound (Docker Compose)

Pi-hole mit Unbound (Docker Compose)

Nachdem ich hier schon mal kurz die Docker-Fummelei für Adguard Home und Unbound skizziert hatte, habe ich mich jetzt an das Docker-Projekt Pi-hole mit Unbound gewagt. Sicher, es gibt schon die Ein-Container-Lösung von Chris Crowe. Aber ich finde die Zwei-Container-Variante mit dem Original Pihole etwas eleganter und leichter zu pflegen. Here we go … (docker-compose.yml)
blank

docker-compose.yml

version: "3"

volumes:
  pihole_etc:
  pihole_dnsmasq:

services:
  pihole: 
    depends_on:
    - unbound
    image: pihole/pihole:latest
    container_name: pihole
    hostname: pihole
    domainname: pihole.domain
    ports:
      - 53:53/tcp
      - 53:53/udp
      - 1010:80/tcp
    environment:
      ServerIP: 192.168.xxx.xxx
      TZ: Europe/Berlin
      WEBPASSWORD: password
      REV_SERVER: "true"
      REV_SERVER_TARGET: 192.168.xxx.1
      REV_SERVER_DOMAIN: fritz.box
      REV_SERVER_CIDR: 192.168.xxx.0/16
      DNS1: 172.25.0.53
      DNS2: 172.25.0.53
      DNSSEC: "true"
      DNSMASQ_LISTENING: "all"
    volumes:
      - pihole_etc:/etc/pihole:rw
      - pihole_dnsmasq:/etc/dnsmasq.d:rw
    restart: unless-stopped
    
  unbound:
    container_name: unbound
    restart: unless-stopped
    image: klutchell/unbound
    networks:
      default:
        ipv4_address: 172.25.0.53

networks:
  default:
       ipam:
         config:
           - subnet: 172.25.0.1/24 

Basics: Pi-hole

Pi-hole ist eine Open-Source-Software, die als DNS sinkhole fungiert und entwickelt wurde, um lästige Werbung und Tracking-Domains auf Netzwerkebene zu blockieren. Durch die Verwendung von Blacklists filtert Pi-hole DNS-Anfragen und verhindert so das Laden von Werbung und anderen unerwünschten Inhalten auf allen Geräten im Netzwerk. Diese effektive Lösung verbessert nicht nur die Benutzererfahrung, indem sie lästige Werbung eliminiert, sondern trägt auch zur Sicherheit und Privatsphäre im Netzwerk bei, indem potenziell schädliche Inhalte blockiert werden.

Glances (Monitoring)

Glances (Monitoring)

Glances (Monitoring)

Eigentlich möchte ich doch nur wissen, ob meine Raspberry Pis online sind, nicht anfangen zu kochen und ob ein bisschen anderes Gedöns (RAM, SSD usw.) einigermassen rund läuft. Bisher hatte ich Netdata (Docker) installiert. Aber irgendwie dünkt mir, dass sich eben dieses Netdata überwiegend selbst überwacht und dabei unheimlich speicherhungrig unterwegs ist. Also muss eine Alternative her, die ich mit Glances gefunden habe. Nicht so fancy im Anblick, aber sehr schlank, im Web erreichbar und mit (für mich) ausreichenden Informationen an Bord.

»Glances is a cross-platform monitoring tool which aims to present a large amount of monitoring information through a curses or Web based interface. The information dynamically adapts depending on the size of the user interface.«

Easypeasy Installation mit Docker-Compose ist natürlich auch verfügbar. Hamma!

AdGuard Home mit Unbound

Adguard home mit unbound docker

AdGuard Home mit Unbound

Über AdGuard Home hab ich hier schon kurz berichtet. Jetzt habe ich das Ding noch ein bisschen aufgebohrt und Unbound als  zuständigen Upstream-DNS-Server installiert.

blank

Ziemliche Docker-Fummelei. Das (für mich) funktionierende Ergebnis habe ich mal in eine hübsche docker-compose.yml gepackt:

blank
Dann nur noch die (beispielhafte) 172.20.0.53 als Upstream-DNS-Server bei AdGuard eintragen und fertig ist die private DNS-Butze. Läuft hier übrigens auf einem Raspberry Pi 4b (Debian 11 / bullseye / aarch64).

blank

Die Ports, Volumes und IP-Adressen könnt ihr natürlich nach Euren Bedürfnissen anpassen. Ich lass das jetzt (erst) mal  so …

docker-compose.yml

version: "3"

volumes:
  work:
  conf:

services:
  adguardhome:
    depends_on:
    - unbound
    image: adguard/adguardhome
    container_name: adguardhome
    ports:
      - 53:53/tcp
      - 53:53/udp
      - 784:784/udp
      - 853:853/tcp
      - 3333:3000/tcp
      - 1010:80/tcp
      - 4443:443/tcp
    volumes:
      - ./work:/opt/adguardhome/work
      - ./conf:/opt/adguardhome/conf
    restart: unless-stopped

  unbound:
    container_name: unbound
    restart: unless-stopped
    image: klutchell/unbound
    networks:
      default:
        ipv4_address: 172.20.0.53


networks:
  default:
       ipam:
         config:
           - subnet: 172.20.0.1/24

Basics: AdGuard Home

AdGuard Home ist eine DNS-Filter- und Werbeblockierungssoftware, die auf einem lokalen Server (z.B. Raspberry Pi) läuft. Es blockiert Anzeigen, Tracker und schädliche Websites, bevor sie auf Ihre Geräte gelangen, und bietet so einen verbesserten Datenschutz und eine schnellere Internetnutzung.

Basics: Unbound

Unbound ist ein Open-Source-DNS-Resolver, der oft als Alternative zu standardmäßigen DNS-Resolvern wie BIND verwendet wird. Es ist darauf spezialisiert, DNS-Anfragen schnell und sicher aufzulösen, indem es die DNS-Anfragen von Benutzern an externe DNS-Server weiterleitet und dabei Sicherheitsfunktionen wie DNSSEC unterstützt.

Uptime Kuma

Uptime Kuma

Uptime Kuma

Uptime Kuma: »It is a self-hosted monitoring tool like „Uptime Robot“.«

Läuft hier fluffig auf dem heimischen Raspberry Pi als Docker Container. Ich überwache damit ein paar heimische Geräte/Dienste und diverse Webseiten. Vollste Zufriedenheit!

  • Monitoring uptime for HTTP(s) / TCP / HTTP(s) Keyword / Ping / DNS Record / Push / Steam Game Server.
  • Fancy, Reactive, Fast UI/UX.
  • Notifications via Telegram, Discord, Gotify, Slack, Pushover, Email (SMTP), and 90+ notification services
  • 20 second intervals.
  • Multi Languages
  • Multiple Status Pages
  • Map Status Page to Domain
  • Ping Chart
  • Certificate Info
  • Proxy Support
  • 2FA available

Github: https://github.com/louislam/uptime-kuma

Live Demo: https://uptime.kuma.pet