Zum Inhalt springen

NginX Network Manager Docker Container auf dem Raspberry (Teil 3)

Veröffentlicht von martin am 29/04/2022

Für alle die sich wie ich immer wieder schwer tun mit dem NginX Revers Proxy, könnte der NginX Network Manager die Erlösung sein.

Ich persönlich mag grafische User Interfaces (GUI) und dies ist wirklich gut gelungen und eigentlich Layer8 sicher.

Doch starten wir mal mit dem Tutorial.

NginX Network Manager Docker Container

Es gibt ja schon eine ganze Menge fertige Images auf DockerHub oder auch im GitHub. Ich habe für mein Compose File original Image gewählt und dafür dann ein Compose File erstellt.

Das File ist recht einfach gehalten, es erstellt ein Frontend und ein Backend Netzwerk und bindet das NPM Image sowie ein Datenbank Image ein.

Das war es im großen und ganzen auch schon. Naja wenn es so einfach wäre dann hätte ich mich ja nicht dazu entschlossen ein Tutorial dazu zu machen oder.

Docker-Compose.yml im Überblick

Ein Docker Compose File ( docker-compose.yml) besteht im groben und ganzen aus 4 Teilen, wobei jedes davon wiederum aus mehreren Teilen besteht und 2 davon optional sind. Und wenn ihr jetzt denkt: “ Echt jetzt will der uns verarschen, wir wissen was ein Compose File ist. „, dann könnt ihr euch einfach auf den GitHub Link weiter unten im Beitrag klicken und euch das File ziehen. Dieser Beitrag ist aber für alle vom Einsteiger bis hin zum Enthusiasten, Profis brauchen meinen Beitrag nicht.

Genaueres zu Docker Compose Files werde ich noch mal in einem eigenen Beitrag bringen, daher hier nur ein grober Umriss.

NginX Network Manager Docker-Compose File mal im Detail

Wie ich oben schon beschrieben ist es nicht bei jedem File so einfach und manchmal ist es sinnvoller Volumes nicht einfach global anzulegen sondern im Service selbst zu definieren.

Doch machen wir uns an das NginX Network Manager Docker-Compose.yml und schauen uns Segment für Segment an.

Die Compose Reference Version

version: "3.9"

In der Version habe ich mich für die „3.9“ entschieden welche die aktuellste ist. Ich habe lange ausprobiert und mich schließlich dafür entschieden was für mich am besten funktioniert hat.

Volumes Definition

volumes:
  npm-data:
  npm-ssl:
  npm-db:

Meine Konfiguration benötigt diese 3 Volumes für NPM ist es ausreichend diese global festzulegen und dann nur noch im jeweiligen Service einzubinden. Den Namen die Ihr hier verwendet sind frei wählbar, es hat sich aber eingebürgert, die Namen aus einer Kombination von Main Application und Verwendungszweck zu benennen. So sind die Volumes auch in der CLI oder in einem WebFrontend wie Portainer einfacher zuzuordnen.

Netzwerk Definition

networks:
  frontend:
    # add this if the network is already existing!
    # external: true
  backend:
    # add this if the network is already existing!
    # external: true

Hier werden die Netzwerke festgelegt. Ich habe sie der einfach halt halber Frontend und Backend genannt. In der Übersicht von 'docker networks ls' werden sie dann um den Stack Namen ergänzt. In meinem Fall sieht das dann so aus.

NginX Network Manager docker network ls Ausgabe

NginX Proxy Manager Service Definition

Die Service Doku ist recht Umfangreich deswegen werde ich den App Teil vom DB Teil getrennt erklären.

services:
  npm-app:
    image: jc21/nginx-proxy-manager:latest
    container_name: nginx-proxy-app
    restart: unless-stopped
    deploy:
      resources:
        limits:
          memory: ${hard_limit}
        reservations:
          memory: ${soft_limit}
    depends_on:
      - npm-db
    ports:
      - "80:80"
      - "81:81"
      - "443:443"
    healthcheck:
      test: ["CMD", "/bin/check-health"]
      interval: 10s
      timeout: 3s
    environment:
      DB_MYSQL_HOST: ${DB_MYSQL_HOST}
      DB_MYSQL_PORT: ${DB_MYSQL_PORT}
      DB_MYSQL_USER: ${DB_MYSQL_USER}
      DB_MYSQL_PASSWORD: ${DB_MYSQL_PASSWORD}
      DB_MYSQL_NAME: ${DB_MYSQL_NAME}
    volumes:
      - npm-data:/data
      - npm-ssl:/etc/letsencrypt
    networks:
      - frontend
      - backend

Gehen wir die Punkte kurz durch:

  • image: _Name des verwendeten Images in diesem Fall aus dem Github Original NginX Proxy Manager Image von JC21
  • container_name: interner Name der von Docker verwendet wird
  • restart: Restart Policy1
  • deploy: Ressourcen Limits zum Beispiel Speicher, CPU etc… 2
  • depends_on: Abhängigkeiten die erfüllt sein müssen
  • ports: für den NginX Proxy Manager sind diese 3 Ports notwendig, wobei Port 81 für die Weboberfläche des NPM ist
  • healthcheck: Verwaltungsanwendungen wie Portainer oder Docker-Desktop können damit den Status des Containers darstellen aber auch in der docker cli ‚docker ps‘ wird der Status angezeigt
Docker PS aufruf
  • environment: Hier werden alle Variablen für den Betrieb aufgelistet, in unserem Fall sind das die Daten für die Datenbank des Nginx Proxy Managers. Ihr könnt die Umgebungsvariablen direkt eingeben oder so wie ich mit einer Variable befüllen lassen, bei mir kommt diese aus der .env Datei. Doch dazu mehr in einem anderen Artikel.
  • volumes und networks: werden hier noch mal für den einzelnen Service definiert wobei hier praktischer weise nur die vorher schon definierten Bezeichner verwendet werden.
    Der NginX Proxy Manager bringt auch ein LetsEncrypt Module mit und so kann über das Webfrontend praktisch für jede Domain schnell ein LetsEncrypt SSL Certificate erstellt werden.

NginX Proxy Manager Datenbank Service Definition

Kümmern wir uns nun um die Datenbank. Ich hatte zunächst auf die Datenbank Definition des Entwicklers des NPM gesetzt, leider musste ich feststellen das diese ab und zu Ihre Probleme mit dem Raspberry hat. Deswegen setze ich inzwischen auf die empfohlene Alternative.

Doch nun zur Definition selbst:

  npm-db:
    image: yobasystems/alpine-mariadb:latest
    container_name: nginx-proxy-db
    restart: unless-stopped
    deploy:
      resources:
        limits:
          memory: 200M
        reservations:
          memory: 100M
    environment:
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
      MYSQL_DATABASE: ${DB_MYSQL_NAME}
      MYSQL_USER: ${DB_MYSQL_USER}
      MYSQL_PASSWORD: ${DB_MYSQL_PASSWORD}
    ports:
      - ${DB_MYSQL_PORT}:3306
    healthcheck:
      test: ["CMD", "mysqladmin", "-u", "${DB_MYSQL_USER}", "ping", "-h", "localhost"]
      interval: 30s
      timeout: 10s
      retries: 5 
    volumes:
      - npm-db:/var/lib/mysql
    networks:
      - backend

Eine erneute Beschreibung der einzelnen Elemente werde ich mir hier sparen. Ich möchte doch darauf hinweisen, das anders wie bei der Service Definition der NginX Proxy Manager App bei der Datenbank auf das Netzwerk Frontend verzichtet werden kann. Da durch erreichen wir das die Datenbank in einem getrennten Netz betrieben wird.

Nach dem ihr das ganze nun in einem File gespeichert habt oder euch das Repository von Github gezogen habt, legt ihr bitte noch ein File .env im selben Verzeichnis an. Dort erstellt ihr die entsprechenden Variablen und verpasst ihnen die entsprechenden Werte.

Hier nun noch der Link zum Repo: https://github.com/meehr/nginx_proxy_manager

NginX Proxy Manager Environment File

Das .env File sieht dann zum Beispiel so aus:

DB_MYSQL_HOST=npm-db
DB_MYSQL_PORT=your-port
DB_MYSQL_USER=npm
DB_MYSQL_PASSWORD=your-secret-password
DB_MYSQL_NAME=npm
MYSQL_ROOT_PASSWORD=your-secret-root-password
hard_limit=500M
soft_limit=100M

Finale Prüfung und der Rollout

Überprüfung mit docker-compose config

Bevor ich ein Compose File ausrolle, habe ich mir angewöhnt das ganze vorher noch zu prüfen, um Fehler noch vor dem ersten Build zu finden. Dazu verwende ich den Befehl docker-compose -f docker-compose-nginx-proxy.yml config, das Ergebnis sieht dann in etwas so aus. (truncated File)

name: nginx_proxy
services:
  npm-app:
    container_name: nginx-proxy-app
    depends_on:
      npm-db:
        condition: service_started
.
.
.
  npm-db:
    container_name: nginx-proxy-db
    deploy:
.
.
.
networks:
  backend:
    name: nginx_proxy_backend
  frontend:
    name: nginx_proxy_frontend
volumes:
.
.

Rollout mit docker-compose

Schließlich könnt ihr nun die Container ausrollen dazu ruft ihr einfach in eurer Console den entsprechenden Befehl auf.

Bitte achtet darauf habt ihr dem File wie ich einen anderen Namen gegeben findet docker-compose up -d nichts und wird das mit einer Fehlermeldung quittieren.

Ihr müsst daher das File mit angeben:

docker-compose -f docker-compose-nginx-reverse-proxy.yml up -d

Beim ersten Rollout könnt ihr euch nun getrost einen Kaffee holen gehen, denn wenn ihr die Images nicht vorher gepullt habt, dauert das ein bissel. Selbst beim meiner FTTH Anbindung vergehen da schon mal 2 3 4 Minuten.

Sollte der Rollout sauber durchlaufen, seht ihr am Ende folgendes. 

dietpi@raspi:~/nginx_test$ docker-compose -f docker-compose.yaml up -d --force-recreate
[+] Running 7/7
 ⠿ Network nginx_test_backend_test    Created  0.8s
 ⠿ Network nginx_test_frontend_test   Created  0.3s
 ⠿ Volume "nginx-data-testdrive"      Created  0.3s
 ⠿ Volume "nginx-ssl-testdrive"       Created  0.7s
 ⠿ Volume "nginx-db-testdrive"        Created  0.3s
 ⠿ Container nginx-db-test            Started  3.3s
 ⠿ Container nginx-npm-frontend-test  Started 5.1s

Erreichbarkeit des NginX Proxy Manager und Konfiguration:

Nach dem Rollout erreicht ihr den NPM unter der IP Eures Raspberry und dem Port 81 in meinem Fall bedeutet dies:

192.168.2.50:81 in den Browser eingeben und dann einloggen.
Der Login Name für das erste mal ist [email protected] und das Passwort changeme.

Login Screen NginX Proxy Manager
Erster Login im NginX Proxy Manager

Nach dem Login werdet Ihr gebeten diese Daten direkt zu ändern.

Hinweis:
Bitte wählt ein sicheres Passwort auch wenn das Webfrontend im Normalfall nicht von außen zu erreichen ist sollte das Passwort sicher gewählt sein.

Die weitere Konfiguration gehen ich mit Euch dann in einem extra Artikel durch. Denn auch wenn es einem der NPM sehr einfach macht, das eine oder andere ist schon zu beachten gerade bei der NextCloud Config.

Fussnoten und Quellen

  1. Restart Policy ist dafür gedacht den Container in bestimmten Situationen neu zu starten eine ausführliche Anleitung findet ihr den den Docker Docs ↑
  2. deploy legt Spezifikationen für das ausrollen der Container fest, Ressource, Endpunkte etc alle Möglichkeiten findet ihr in der Docker-Compose V3 Reference ↑
  3. Eine gute Dokumentation zum NginX Proxy Manager findet ihr natürlich auf der Seite des Entwicklers: https://nginxproxymanager.com/guide/
Published inHowToRaspberryTechnikTutorial