Eigener Homeserver - Setup Teil 2 Raspberry Pi

In dieser Anleitungsreihe geht es darum seine Homeserver-Umgebung einzurichten. Damit ein Blogpost nicht zu lang wird, habe ich das Set-up in mehrere Beiträge unterteilt. Hier beschäftige ich mich mit meinem Raspberry Pi. Es soll dabei insbesondere als Proxy Manager und Werbeblocker dienen.

Voraussetzungen

Für einen Proxy Manager oder Werbeblocker benötigt man nicht zwangsweise einen Raspberry Pi, grundsätzlich sollte es mit jedem Gerät klappen, auf dem sich Docker installieren lässt.

Ein Raspberry Pi hat den Vorteil, dass er günstig ist und relativ wenig Strom verbraucht. Ein Raspberry Pi 3b+ benötigt knapp 2 Watt im Leerlauf, ein Raspberry Pi 4b knapp 3 Watt. Unter Last steigen die Werte auf ca. 5–6 Watt (3b+) respektive 6–7 Watt (4b). Läuft ein Gerät 24h am Tag an 365 Tagen, kostet jeder Watt ca. 2,45 € im Jahr bei einem Strompreis von 28 Cent/kWh. Das bedeutet selbst unter ständiger Vollast (ziemlich unwahrscheinlich) würden die Stromkosten im Jahr um maximal 17 € steigen. Hinzu kommen noch die angeschlossenen Geräte.

Hier Daten eintragen, um die Stromkosten zu berechnen:

OS installieren

Zuerst muss ein Betriebssystem auf den Raspberry Pi installiert werden. Als Speichermedium kann ein USB-Stick (oder USB-Festplatte) oder eine microSD-Karte genutzt werden. Bei einem älteren Modell als dem Raspberry Pi 4b können dabei Limitierungen zu beachten sein. Ansonsten ist nur darauf zu achten, dass die Stromversorgung ausreichend ist.

Ich nutze eine Crucial SSD mit 128 GB Speicherplatz, die ich in ein externes Gehäuse gepackt habe.

Sie hat früher in einem anderen Gerät gearbeitet und wird dadurch nicht angezeigt, wenn ich im weiteren Verlauf ein Betriebssystem installieren möchte. Falls du auch Windows nutzt und dasselbe Problem hast, öffnest du über die Systemsteuerung die Verwaltung.

Dort interessiert uns die Verknüpfung zur „Computerverwaltung“. Auf der linken Seite ist der Menüpunkt „Datenträgerverwaltung“ zu sehen.

Den Datenträger möchte ich für meinen Raspberry Pi nutzen, also lösche ich erst die einzelnen Volumes.

Nun folgt der Download des Raspberry Pi Imagers und seine Installation. Auf dieser Seite findet sich der Download-Button.

Das offizielle Betriebssystem Raspberry Pi OS (ehemals Raspbian) gibt es in drei verschiedenen Varianten: Lite, Desktop (normal), Full. Die Lite Variante hat keine grafische Oberfläche und weniger Programme vorinstalliert. Dafür verbraucht es weniger Speicherplatz und Arbeitsspeicher. Full enthält zusätzlich zum Desktop auch noch weitere ggf. nützliche Programme. Die 64-Bit Version ist momentan leider nur als Beta verfügbar. Raspberry Pi OS basiert darüber hinaus auf Debian.

Sollte man zwangsweise ein 64-Bit Betriebssystem nutzen, wenn man mehr als 3 GB RAM hat? Nein, denn das System kann weiterhin den gesamten RAM nutzen.

Our default operating system image uses a 32-bit LPAE kernel and a 32-bit userland. This allows multiple processes to share all 8GB of memory, subject to the restriction that no single process can use more than 3GB — Raspberry Blog

Ich wähle die Lite Variante vom Raspberry Pi OS, da eine Oberfläche nicht benötigt wird.

Als „SD-Karte“ wähle ich die gerade gelöschte Festplatte und drücke auf „Schreiben“. Nachdem der Schreibvorgang fertig ist, entferne ich die Festplatte und schließe sie wieder an. Dadurch sehe ich sie im Daten-Explorer mit der Beschriftung “system-boot”.

Sollte das Laufwerk nicht zu sehen sein, muss der Partition system-boot ein Laufwerkbuchstabe zugeteilt werden.

Nachdem ich über den Ansicht-Tab die Anzeige für Dateinamenerweiterungen einschalte, erstelle ich eine neue Datei.

Diese Datei muss ssh heißen.

Die Dateiendung muss gelöscht werden, es handelt sich nicht um eine Textdatei.

Damit ist die Installation abgeschlossen.

Raspberry Pi ans Netzwerk anschließen

Ich nutze für diese Anleitung einen Raspberry Pi 4b mit 8 GB RAM.

Das eben geflashte Laufwerk verbinde ich mit dem USB3-Port des Raspberrys und mit einem Netzwerkkabel verbinde ich ihm mit meinem Router oder einem Switch. Nun benötige ich die IP-Adresse des Raspberrys. Dazu öffne ich das Terminal (alternativ PowerShell).

Darüber möchte ich die Gateway-Adresse herausfinden.

ipconfig

Jetzt müsste dort das Standard-Gateway stehen, in meinem Fall “192.168.0.1”. Diese Adresse muss im Browser aufgerufen werden, um im Normalfall den Router zu erreichen. Nachdem man sich dort angemeldet hat, sieht man eine Auflistung der Geräte im Netzwerk. In der Liste müsste auch der neue Raspberry Pi vorhanden sein.

In meinem Fall hat er die Adresse 192.168.0.47 zugeteilt bekommen.

Problem Vodafone Station

Mein Raspberry Pi bekommt an der Vodafone Station, nachdem ich ihn neu installiert habe, keine IP-Adresse mehr zugewiesen. Ich vermute, es hat etwas mit der Vodafone Station als DHCP-Server zu tun. Das Problem der Raspberry Pis ohne IP-Adresse habe ich öfter gelesen, eine einfache Lösung habe ich nicht gefunden.

Feste IP-Zuweisung

Es empfiehlt sich eine dauerhafte IP-Adresse zu vergeben, sofern das in den Routereinstellungen möglich ist.

In einer Fritz!Box ist das im Menü Heimnetz/Netzwerk/Netzwerkeinstellungen möglich, wenn man auf die Details vom Gerät klickt.

Nachdem die IP-Adresse bekannt ist, wird es Zeit das System einzurichten

Raspberry Pi OS einrichten

Sollte man kein Raspberry Pi OS nutzen, lässt sich die Anleitung auch größtenteils auf Ubuntu oder Debian übertragen.

Verbinden

Zunächst müssen wir uns mit dem Raspberry Pi verbinden. Die Anmeldedaten zum Raspberry Pi sind Benutzername: pi, Passwort: raspberry. Das ist im Übrigen auch ein Grund dafür, warum ssh standardmäßig deaktiviert ist. Benutzername und Passwort sind nicht sicher. Zur Anmeldung ein Terminal öffnen:

ssh pi@192.168.0.47
yes
raspberry

Update

Nun aktualisieren wir zunächst die Pakete.

sudo apt update
sudo apt upgrade
sudo apt dist-upgrade

Gegebenenfalls mit Y bestätigen.

Passwort

Jetzt ist es vorerst wichtig das Passwort zu ändern, falls es nicht am Anfang der SSH Session passiert ist.

passwd
raspberry
neuesPasswort
neuesPasswort

Das neue Passwort sollte etwas sicherer sein.

Zeiteinstellung

Jetzt stellen wir bei Bedarf die richtige Zeit ein.

date

Falls nicht die richtige Zeit angezeigt wird:

tzselect

Über die Zahlen könnt ihr eure Zeitzone auswählen.

sudo timedatectl set-timezone 'Europe/Berlin'

Monitoring

Über den Befehl htop sehen wir die Systemauslastung.

htop

Damit lässt sich gut verfolgen, wie stark die CPU und der RAM beansprucht werden. Mit F10 oder STRG + C verlässt du die Ansicht wieder. Wichtig ist aber nicht nur die Auslastung, sondern auch die Temperatur.

cat /sys/class/thermal/thermal_zone0/temp

Dadurch wird die Temperatur in Grad Celsius * 100 angezeigt.

Git

Als Nächstes benötigen wir git.

sudo apt install git

Host Name

Außerdem können wir unseren Raspberry umbenennen.

sudo nano /etc/hostname

In Nano wird die Datei mit Strg + X verlassen. Nano wird Fragen, ob du die Änderungen speichern möchtest (mit Y bestätigen) und wie die Datei genannt werden soll. Da wir sie überschreiben möchten, ändern wir den Namen nicht und bestätigen einfach mit Enter.

Docker

Jetzt benötigen wir Docker.

curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
rm get-docker.sh

Bei curl ist Vorsicht geboten, da man sich irgendetwas Gefährliches runterladen könnte Der Befehl sudo docker version sollte nun die Version von Docker ausgeben.

Als nächstes brauchen wir Docker-Compose. Unter diesem Link sehen wir, welche Version die neuste ist. Leider würden wir über apt install docker-compose eine ältere Version erhalten. Deshalb nutzen wir pip.

sudo apt install -y python3-pip libffi-dev
sudo pip3 install docker-compose

Das kann etwas dauern. Gebe ich jetzt docker-compose ein, erscheint ein Fehler, weil das Programm nicht gefunden wird.

Also erstelle ich einen Link zum wirklichen Ort und gebe zur Sicherheit Rechte zum Ausführen.

sudo chmod +x /usr/local/bin/docker-compose
sudo ln -s /usr/local/bin/docker-compose /usr/bin/docker-compose

Als Nächstes benötigen wir eine Benutzergruppe für Docker (die eventuell schon angelegt ist) und fügen unser Benutzerkonto dort hinzu.

sudo groupadd docker
sudo usermod -aG docker pi
newgrp docker
# warten

Wenn der Nutzer nicht “pi” heißt, dann muss der Befehl geändert werden. Bei der Eingabe von id müsste nun in der Aufzählung der Gruppen auch docker erscheinen.

Jetzt kann man noch Lazydocker installieren, das ist ein Management-Programm für Docker in der Shell.

curl https://raw.githubusercontent.com/jesseduffield/lazydocker/master/scripts/install_update_linux.sh | bash
lazydocker

Zsh

Ich möchte auch eine andere Shell.

sudo apt install zsh
curl -fsSL https://raw.githubusercontent.com/zimfw/install/master/install.zsh | zsh
chsh -s /usr/bin/zsh
exec bash

Nun soll sie auch meine Befehle für Docker automatisch vervollständigen.

mkdir -p ~/.zsh/completion
curl \ -L https://raw.githubusercontent.com/docker/compose/1.29.1/contrib/completion/zsh/_docker-compose \ -o ~/.zsh/completion/_docker-compose

fpath=(~/.zsh/completion $fpath)

Nun fügen wir noch autoload -Uz compinit && compinit -i in die Konfiguration hinzu.

nano ~/.zshrc

Jetzt sollte der Server neu gestartet werden.

sudo reboot
### warten ###
ssh pi@192.168.0.47

Proxy Manager

Der Home-Ordner dürfte zu diesem Zeitpunkt nur mit versteckten Ordnern gefüllt sein. Das können wir mit ls -Al überprüfen (ls listet die Dateien und Ordner des momentanen Verzeichnises auf)

Ich möchte gerne den Ordner Docker erstellen.

mkdir docker
ls -l

Der Ordner ist nun vorhanden Ich könnte ihn auch wieder löschen.

rm -r docker
# sollte der Ordner bereits Dateien enthalten, kann er mit rm -rf docker gelöscht werden
ls -l

Der Ordner ist weg Aber ich brauche ihn, also erstelle ich ihn wieder.

mkdir docker

Der Gruppe Docker benötigt die Rechte für den Ordner.

sudo apt install acl
sudo setfacl -Rdm g:docker:rwx ~/docker
sudo chmod -R 775 ~/docker

Im Gegensatz zu meiner Anleitung mit Traefik möchte ich hier lieber den Ansatz verfolgen, dass jeder Dienst seinen eigenen Ordner bekommt. Also benötige ich einen für einen Proxy Manager. Es gibt mehrere Proxy Manager, wie Traefik, Caddy oder Nginx. Dies möchte ich Nginx als Proxy benutzen, da ich aber keine Lust habe, manuell die Konfigurationsdatei von Nginx zu schreiben und mich um meine Lets Encrypt Zertifikate zu kümmern, greife ich auf den Nginx Proxy Manager zurück.

cd ~/docker
mkdir nginx-proxy-manager
cd nginx-proxy-manager

Übrigens lassen sich mit Tab Befehle vervollständigen. Wenn ich mich im Home-Ordner befinde cd ~ kann ich cd d eingeben und dann Tab drücken. Mit der zuvor installierten Erweiterung sind auch Docker-Befehle schnell ausgewählt. Wenn ich docker mit einem Leerzeichen am Ende eingebe und zweimal Tab drücke, erscheint eine Liste mit Möglichkeiten. Mit der Pfeiltaste nach oben kann man durch die letzten eingegebenen Befehle klicken.

Also zurück zum neuen Nginx Ordner

cd ~/docker/nginx-proxy-manager

Wir benötigen drei weitere Ordner für persistente Daten.

mkdir data/mysql -p
mkdir letsencrypt

Jetzt erstellen wir ein neues Docker-Netzwerk für NPM.

docker network create npm_net

Wir brauchen noch eine Umgebungsdatei mit den Passwörtern für die Datenbank.

touch .env
% echo "DB_PWD=$(openssl rand -hex 16)" >> .env
% echo "DB_ROOT_PWD=$(openssl rand -hex 16)" >> .env

Letztlich fehlt nur noch die Docker-Compose Datei.

nano docker-compose.yml

version: "3.9"

### Networks ###
networks:
    npm_net:
        external:
            name: npm_net
    internal:
        external: false
    default:
        driver: bridge

### Services ###
services:
    nginx-proxy-manager:
        container_name: nginx-proxy-manager
        image: jc21/nginx-proxy-manager
        restart: always
        networks:
            - npm_net
            - internal
        ports:
            - "80:80"
            - "443:443"
            - "81:81"
        environment:
            DB_MYSQL_HOST: npm_db
            DB_MYSQL_PORT: 3306
            DB_MYSQL_USER: npm
            DB_MYSQL_PASSWORD: $DB_PWD
            DB_MYSQL_NAME: npm
            # DISABLE_IPV6: true
        volumes:
            - ./data:/data
            - ./letsencrypt:/etc/letsencrypt
        depends_on:
            - npm_db

    npm_db:
        container_name: npm_db
        image: yobasystems/alpine-mariadb:10.4.17-arm32v7
        # image: yobasystems/alpine-mariadb
        restart: always
        networks:
            - internal
        environment:
            MYSQL_ROOT_PASSWORD: $DB_ROOT_PWD
            MYSQL_DATABASE: npm
            MYSQL_USER: npm
            MYSQL_PASSWORD: $DB_PWD
        volumes:
            - ./data/mysql:/var/lib/mysql

Falls IPv6 im Netzwerk nicht vorhanden ist, sollte die Zeile auskommentiert werden. Ebenso ist das Image nur für den Raspberry Pi, wenn man ein anderes System benutzt braucht man nicht den arm32v7 Tag.

Zeit, die Konfiguration zu testen.

docker-compose up -d

Nun schauen wir in das Log.

lazydocker

Scheint alles soweit gut zu sein. Also können wir die GUI von NPM aufrufen, indem wir im Browser die IP-Adresse des Raspberry Pis, gefolgt von :81 eingeben.

Damit sollten wir beim Log-in landen.

Die Benutzerdaten sind folgende:

Email: admin@example.com Password: changeme

Bei der ersten Anmeldung wird nach einem neuen Password gefragt. Der Proxy Manager ist damit einsatzbereit.

Da momentan keine weiteren Geräte im Netzwerk sind, die von außen erreichbar sein sollten, müssen wir uns zunächst nicht weiter damit beschäftigen.

Updates lassen sich auch sehr einfach einspielen.

cd ~/docker/nginx-proxy-manager
docker-compose down
docker pull jc21/nginx-proxy-manager
docker-compose up -d

Es ist möglich bei Github über neue Versionen benachrichtigt zu werden. Das ist mir lieber als Watchtower zu nutzen, der die Updates automatisiert.

Ein neuer Release heißt nicht, dass man updaten muss oder das sich das Update bereits bei Docker.hub befindet

Firewall

Jetzt benötigen wir eine Firewall, am besten eine unkomplizierte, also die uncomplicated firewall.

sudo apt install ufw
sudo ufw allow 80/tcp #das ist der http-Port
sudo ufw allow 443/tcp #das ist der https-Port
sudo ufw allow 22/tcp #das ist der ssh-Port
sudo ufw logging medium
sudo ufw default deny incoming
sudo ufw enable

Jetzt müssen wir den Server neu starten, damit die Änderungen wirksam werden.

sudo reboot

Wir testen die Firewall, indem wir wieder versuchen {IP-Adresse vom Server}:81 aufzurufen und wundern uns darüber, dass es klappt. Das liegt daran, dass Docker die iptables verändert, sobald wir einen Port freigeben.

Die beste Lösung, die ich dafür gefunden habe, ist das Repository chaifeng/ufw-docker.

sudo nano /etc/ufw/after.rules

In diese Datei fügen wir diesen Code ans Ende ein.

# BEGIN UFW AND DOCKER
*filter
:ufw-user-forward - [0:0]
:ufw-docker-logging-deny - [0:0]
:DOCKER-USER - [0:0]
-A DOCKER-USER -j ufw-user-forward

-A DOCKER-USER -j RETURN -s 10.0.0.0/8
-A DOCKER-USER -j RETURN -s 172.16.0.0/12
-A DOCKER-USER -j RETURN -s 192.168.0.0/16

-A DOCKER-USER -p udp -m udp --sport 53 --dport 1024:65535 -j RETURN

-A DOCKER-USER -j ufw-docker-logging-deny -p tcp -m tcp --tcp-flags FIN,SYN,RST,ACK SYN -d 192.168.0.0/16
-A DOCKER-USER -j ufw-docker-logging-deny -p tcp -m tcp --tcp-flags FIN,SYN,RST,ACK SYN -d 10.0.0.0/8
-A DOCKER-USER -j ufw-docker-logging-deny -p tcp -m tcp --tcp-flags FIN,SYN,RST,ACK SYN -d 172.16.0.0/12
-A DOCKER-USER -j ufw-docker-logging-deny -p udp -m udp --dport 0:32767 -d 192.168.0.0/16
-A DOCKER-USER -j ufw-docker-logging-deny -p udp -m udp --dport 0:32767 -d 10.0.0.0/8
-A DOCKER-USER -j ufw-docker-logging-deny -p udp -m udp --dport 0:32767 -d 172.16.0.0/12

-A DOCKER-USER -j RETURN

-A ufw-docker-logging-deny -m limit --limit 3/min --limit-burst 10 -j LOG --log-prefix "[UFW DOCKER BLOCK] "
-A ufw-docker-logging-deny -j DROP

COMMIT
# END UFW AND DOCKER

Danach starten wir den Raspberry neu.

sudo reboot

Wir probieren noch mal das GUI aufzurufen und sehen schon wieder das GUI. Hat es nicht geklappt? Doch, hat es teilweise schon. Der Code-Block sieht vor, dass die Dienste weiterhin über 192.168.0.0/16 erreichbar sind. Bei einer Freigabe ans Internet wird der Zugriff geblockt.

Aber da 80 und 443 gegebenenfalls wirklich freigegeben werden sollen, müssen wir die Firewall ergänzen.

sudo ufw route allow 80/tcp
sudo ufw route allow 443/tcp
sudo ufw reload

Damit ist die Firewall eingerichtet.

Werbeblocker

Ich möchte in meinem Netzwerk Werbung und Malware möglichst auf DNS-Ebene blocken. Der Vorteil ist, dass so die Werbung auch auf dem Handy geblockt wird. Zwar gibt es Alternativen wie Pi-Hole und AdGuard, ich habe mich aber diesmal für Blocky entschieden.

cd ~/docker
mkdir blocky
cd blocky
mkdir whitelists
mkdir blacklists
mkdir logs

Nun haben wir drei Ordner im neu angelegten Verzeichnis. Zuerst erstelle ich ein neues Netzwerk und fülle ich die Docker-Compose-Datei.

docker network create blocky_net
nano docker-compose.yml

version: "3.9"

### Networks ###
networks:
    blocky_net:
        external:
            name: blocky_net
    default:
        driver: bridge

### Services ###
services:
    blocky:
        container_name: blocky
        image: spx01/blocky
        restart: unless-stopped
        networks:
            - blocky_net
        ports:
            - "53:53/tcp"
            - "53:53/udp"
            - "4000:4000/tcp"
        environment:
            - TZ=Europe/Berlin
        volumes:
            - ./config.yml:/app/config.yml
            - logs:/logs
            - ./blacklists:/app/blacklists/
            - ./whitelists:/app/whitelists/

Jetzt benötigen wir die Config-Datei. Statt die vollständige Datei zu bearbeiten, nehmen wir die Beispieldatei.

nano config.yml

upstream:
    externalResolvers:
        - 5.9.164.112 #digitalcourage
        - 80.241.218.68 #dismail
        - tcp-tls:fdns1.dismail.de:853
        - https://dns.digitale-gesellschaft.ch/dns-query
blocking:
    blackLists:
        suspicous:
            - https://raw.githubusercontent.com/PolishFiltersTeam/KADhosts/master/KADhosts.txt
            - https://raw.githubusercontent.com/FadeMind/hosts.extras/master/add.Spam/hosts
            - https://v.firebog.net/hosts/static/w3kbl.txt
        ads:
            - https://adaway.org/hosts.txt
            - https://v.firebog.net/hosts/AdguardDNS.txt
            - https://v.firebog.net/hosts/Admiral.txt
            - https://raw.githubusercontent.com/anudeepND/blacklist/master/adservers.txt
            - https://s3.amazonaws.com/lists.disconnect.me/simple_ad.txt
            - https://v.firebog.net/hosts/Easylist.txt
            - https://pgl.yoyo.org/adservers/serverlist.php?hostformat=hosts&showintro=0&mimetype=plaintext
            - https://raw.githubusercontent.com/FadeMind/hosts.extras/master/UncheckyAds/hosts
            - https://raw.githubusercontent.com/bigdargon/hostsVN/master/hosts
        tracking:
            - https://v.firebog.net/hosts/Easyprivacy.txt
            - https://v.firebog.net/hosts/Prigent-Ads.txt
            - https://raw.githubusercontent.com/FadeMind/hosts.extras/master/add.2o7Net/hosts
            - https://raw.githubusercontent.com/crazy-max/WindowsSpyBlocker/master/data/hosts/spy.txt
            - https://hostfiles.frogeye.fr/firstparty-trackers-hosts.txt
            - https://raw.githubusercontent.com/Kees1958/W3C_annual_most_used_survey_blocklist/master/TOP_EU_US_Ads_Trackers_HOST
        malicious:
            - https://raw.githubusercontent.com/DandelionSprout/adfilt/master/Alternate%20versions%20Anti-Malware%20List/AntiMalwareHosts.txt
            - https://osint.digitalside.it/Threat-Intel/lists/latestdomains.txt
            - https://s3.amazonaws.com/lists.disconnect.me/simple_malvertising.txt
            - https://v.firebog.net/hosts/Prigent-Crypto.txt
            - https://bitbucket.org/ethanr/dns-blacklists/raw/8575c9f96e5b4a1308f2f12394abd86d0927a4a0/bad_lists/Mandiant_APT1_Report_Appendix_D.txt
            - https://phishing.army/download/phishing_army_blocklist_extended.txt
            - https://gitlab.com/quidsup/notrack-blocklists/raw/master/notrack-malware.txt
            - https://v.firebog.net/hosts/Shalla-mal.txt
            - https://raw.githubusercontent.com/Spam404/lists/master/main-blacklist.txt
            - https://raw.githubusercontent.com/FadeMind/hosts.extras/master/add.Risk/hosts
            - https://urlhaus.abuse.ch/downloads/hostfile/
        coin:
            - https://zerodot1.gitlab.io/CoinBlockerLists/hosts_browser
    clientGroupsBlock:
        default:
            - suspicous
            - ads
            - tracking
            - malicious
            - coin
port: 53
httpPort: 4000

docker-compose up -d

Jetzt müsste unter dem Port 4000 etwas zu sehen sein.

Es muss nur noch der DNS-Server im Router umgestellt werden. Bei der Fritz!Box kann das unter IPv4-Einstellungen erledigt werden. Dort muss die IP-Adresse des Raspberry Pi als lokaler DNS-Server angegeben werden.

Des Weiteren tragen wir unter Zugangsdaten und DNS-Server statt den bisherigen DNS-Servern die IPv4-Adresse des Raspberry Pis ein.

Damit ist die Werbung inzwischen größtenteils geblockt.

Natürlich kann man noch viel mehr Einstellungen vornehmen, auf die ich jetzt nicht weiter eingehen möchte. Damit die Änderung wirksam wird, muss man das Netzwerk verlassen und sich dann neu verbinden.

Was ich zumindest noch machen würde, wäre mir drei Lesezeichen in meinem Webbrowser anzulegen.

http://ipadressevompi:4000/api/blocking/status Um den Status zu sehen.

http://ipadressevompi:4000/api/blocking/enable Um Blocky einzuschalten.

http://ipadressevompi:4000/api/blocking/disable Um Blocky auszuschalten.

Startseite

Um den Proxy-Manager zu testen und noch etwas auf dem Raspberry laufen zu lassen, möchte ich ein Dashboard haben, das als Startpage im Browser dienen könnte. Auch an dieser Stelle gäbe es dazu mehrere Möglichkeiten. Ich wähle Homer.

cd ~/docker
mkdir homer
cd homer
mkdir assets
id

Wir merken uns die Nummer unseres Nutzers (User ID) und der Gruppe Docker (Group ID).

nano .env

UID=1000 GID=123

Es müssen die eigenen Werte eingetragen werden. Anschließend brauchen wir eine Docker-Compose Datei.

nano docker-compose.yml

version: "3.9"

### Networks ###
networks:
    npm_net:
        external:
            name: npm_net
    default:
        driver: bridge

### Services ###
services:
    homer:
        container_name: homer
        image: b4bz/homer
        restart: unless-stopped
        networks:
            - npm_net
        ports:
            - 8080:8080
        environment:
            - UID=$UID
            - GID=$GID
        volumes:
            - ./config.yml:/www/config.yml
            - ./assets/:/www/assets

Vor der Bereitstellung fehlt noch die Konfigurationsdatei. Hier kann man sich ansehen, was beispielsweise zur Verfügung steht.

nano config.yaml

title: "Homepage"
subtitle: "Homer"
logo: "assets/logo.png"

links:
    - name: "Github"
      icon: "fab fa-github"
      url: "https://github.com/"
      target: "_blank"
    - name: "Deployn"
      icon: "fab fa-octopus-deploy"
      url: "https://deployn.de"
    - name: "Reddit"
      icon: "fab fa-reddit"
      url: "https://www.reddit.com/"

services:
    - name: "Example"
      icon: "fas fa-code-branch"
      items:
          - name: "Startpage"
          - subtitle: "Search engine"
          - url: "https://startpage.com"

Fertig.

docker-compose up -d

Die Seite befindet sich nun unter der IP-Adresse des Raspberry Pis mit der Portnummer 8080.

Öffentlicher Zugang

Als Letztes fehlt noch die Möglichkeit, auf diese Homepage von außerhalb des Netzwerkes zuzugreifen. Dazu muss eine Domain auf die öffentliche IP-Adresse des Heimnetzwerks zeigen, wie in der Anleitung zur Fritz!Box dargestellt wurde. In dem NPM GUI muss nur noch die gewünschte Subdomain eingegeben werden und auf den Port 8080 weitergeleitet werden.

Es ist auch möglich, eine DNS-Challenge für eine Domain zu nutzen.

Wenn man die Einstellung abgespeichert hat und versucht innerhalb seiner Netzwerkes die Seite aufzurufen, kommt eine Fehlermeldung, weil der DNS-Rebind-Schutz aus Sicherheitsgründen einen Zugriff aus dem eigenen Netzwerk über die externe IP erreichen möchte, unterbindet. In der Fehlermeldung steht normalerweise, wie man dieses Verhalten ändern kann.

Doch auch wenn man das eigene Netzwerk verlässt und versucht die Subdomain aufzurufen, erhält man einen Fehler, diesmal 504 Gateway Time-out. Warum? Weil die Firewall funktioniert.

sudo ufw allow 8080/tcp

Sobald man diesen Befehl abschickt, sollte die Seite erreichbar sein.

Die Einrichtung ist damit abgeschlossen 😀