traefik

Änderungsstand: 2020-08-23

Da der Letsencrypt-Docker mit integriertem NginX auch als Reverse-Proxy eingesetzt werden kann ist diese hier vorgestellte Methode eigentlich nur etwas für Traefik-Liebhaber. Seit ich herausfand, dass man im Reverse-Proxy mit Letsencrypt auch andere Server einbeziehen kann, habe ich das Traefik-Projekt, für mich persönlich, erst mal auf Eis gelegt. Aber keine Angst. Alles hier beschriebene wurde erfolgreich getestet.

Wer Traefik verwenden möchte und eine MariaDB in UNRAID mittels Docker betreibt und diese weiter benutzen möchte, sollte diesem Guide keine Beachtung schenken und den nächsten Guide verwenden. Und ja – mir ist schon etwas langweilig 🙂

Traefik 2 als Reverse-Proxy, Nextcloud und WordPress, beides mit nur einer Datenbank und Zugriff von Aussen mit SSL.

Hierfür erstelle ich eine minimale Debian-Server-VM. Alle Docker in dieser VM werden Traefik-gesteuert sein, inkl. SSL und Zugriff von Aussen haben. Warum wählte ich diesen Weg? Trotz der anscheinend vielen Befehle, die gleich folgen, habe ich dieses Szenario schon einmal auf dem Raspi erfolgreich getestet. Für mich scheint es vorerst der einfachere Weg zu sein. Ist mein Serversystem aufgestellt, werde ich mich mich über Traefik-Docker in Unraid schlau machen und evtl. realisieren. Da momentan alles noch Neuland ist, ich aber meinen Server schnellstmöglich am Laufen haben möchte, wählte ich diesen Weg. Obwohl die Befehle fast 1 zu 1 aus einem anderen Guide von mir übernommen wurden, testete ich auf meinen Unraid-Server alles auf Funktionalialität.

Zuerst erstelle ich eine Buster-Server-Netinstall VM. Je nach Anwendungsfall sollte man die Größe der zu verwendeten VM bedenken. Schleift man eine extra HDD als Datenlaufwerk durch, ist das wohl die beste Weise, um die VM relativ klein zu halten. Aber beachtet, dass meine ganzen Befehle auf das var/lib/-Verzeichnis der VM basieren. Das solltet Ihr dann unbedingt auf die extra eingebunde Platte legen. Nicht die Config-Files. Ich meine ganz speziell das Laufwerk mit den Daten von Nextcloud. Da kommen schnell paar GB zusammen. Oder noch mehr, je nach Anwendungsfall. Als Beispiel nenne ich meine Nextcloudanwendung, die in einem 4-Familienhaushalt und einem Zeitraum von anderthalb Jahren, schon 600 GB umfasst. Tip: Für Nextcloud als Anwendung weise ich meiner VM 4GB Ram und 2 Kerne zu. Ein Kern macht’s zur Not auch, aber 4GB Ram sollte das Minimum sein, jedenfalls, wenn man es produktiv im Privatgebrauch einsetzt! Hat man genügend Resourcen, sind auch 8GB keine schlechte Wahl.

Hier ist der Guide für das Installieren der VM. Anschließend logge ich mich in das Putty-Terminal ein und arbeite folgende Schritte dort ab:

apt update && apt upgrade -y

apt install sudo wget -y

sudo apt install docker docker-compose curl jq mc -y

Jetzt installiere ich den ersten Docker. Das wird Portainer sein. Wer Portainer nicht benötigt, macht einfach bei duckdns weiter. Ich erstelle meine Docker-*.yml Dateien im /home/dockervolumes-Verzeichnis:

sudo mkdir /home/dockervolumes

Nun folgende Befehle im Terminal eingeben ( Ordner wird erstellt und die *.yml wird dort geöffnet).

sudo mkdir /home/dockervolumes/portainer

cd /home/dockervolumes/portainer && sudo nano docker-compose.yml

Folgendes dort einfügen (vorher Eure Werte überprüfen):

version: '2'
  
services:
  portainer:
    image: portainer/portainer
    command: -H unix:///var/run/docker.sock
    restart: always
    ports:
      - 9000:9000
      - 8000:8000
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - /var/lib/PortainerData:/data

Speichern mit Strg-x, y, Enter

Quelle: https://portainer.readthedocs.io/en/latest/deployment.html

Anschließend die „yml“ starten mit

cd /home/dockervolumes/portainer && sudo docker-compose up -d

Mit VM-IP-Adresse:9000 kann man die Portainer-Web-Oberfläche im Browser starten. Auf die Funktionsweise des Portainers gehe ich hier nicht ein.

duckdns:

Meine verwendete Domain in diesem Guides ist knilix.duckdns.org.

sudo mkdir -p /home/dockervolumes/duckdns

nano /home/dockervolumes/duckdns/docker-compose.yml

---
version: "2"
services:
  duckdns:
    image: linuxserver/duckdns
    container_name: duckdns
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Europe/Berlin
      - SUBDOMAINS=knilix
      - TOKEN=DASTOKEN
      - LOG_FILE=true
    volumes:
      - /var/lib/DuckdnsConfig:/config
    restart: unless-stopped

STRG-x, y, Enter

Quelle: https://hub.docker.com/r/linuxserver/duckdns

Anschließend die „yml“ starten:

cd /home/dockervolumes/duckdns && sudo docker-compose up -d

Die Vorbereitungen wären abgeschlossen. Durch DuckDNS ist unser Rechner ab sofort, jedenfalls in der Theorie, von Aussen erreichbar. In der Praxis fehlen aber noch einige Sachen. Also keine Angst. Passieren kann nichts.

Es wird Zeit, den Router, in meinen Fall eine FritzBox! 7590 zu konfigurieren und die Portweiterleitung zur VM zu tätigen. Hier ist der Ablauf beschrieben. Achtung! Die VM mit Ihrer IP-Adresse wählen! Nicht den Unraid-Server!!!

Jetzt zu Traefik 2.

Hier nur die kompletten Befehle und Infos, die nötig sind.

sudo mkdir -p /home/dockervolumes/traefik

sudo touch /home/dockervolumes/traefik/acme.json

sudo chmod 600 /home/dockervolumes/traefik/acme.json

sudo touch /var/log/traefik.log

sudo chmod 600 /var/log/traefik.log

sudo docker network create traefik-net

sudo docker network create intern

Middlewares (Passwortschutz der Weboberfläche):

Auf der Seite https://hostingcanada.org/htpasswd-generator/ geben wir einen Usernamen und ein Passwort ein. Ich verwende für diesen Guide 1 User und 1 dazugehöriges Passwort. Verwendet bitte richtige Passwörter!!! karldall ist kein passwort – er ist ein Komiker 🙂 Dies dient nur zur Demonstration!!!

User) admin Passwort: karldall

Diesen User und das Passwort gebe ich jetzt auf der zuvor verlinkten Seite ein und generiere meine Passwort, welches ich später für die traefik-docker.yml benötige. Ich verwende die Methode *Apache spezific….. Folgendes bekomme ich heraus:

admin:$apr1$zejclqhm$OdhdcM9CR37zSovA7o6mq1

Jetzt ist wichtig, vor JEDEM $ noch ein $ zu setzen!!!

admin:$$apr1$zejclqhm$$OdhdcM9CR37zSovA7o6mq1

Diese Ausgabe merken bzw. kopieren.

Jetzt eine neue Datei anlegen. Nennen wir diese dynamic_conf.yml.

dynamic_conf.yml

sudo nano /home/dockervolumes/traefik/dynamic_conf.yml

tls:
  options:
    default:
      minVersion: VersionTLS12
      cipherSuites:
        - TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
        - TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384
        - TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305
        - TLS_AES_128_GCM_SHA256
        - TLS_AES_256_GCM_SHA384
        - TLS_CHACHA20_POLY1305_SHA256
      curvePreferences:
        - CurveP521
        - CurveP384
      sniStrict: true
http:
  middlewares:
    secHeaders:
      headers:
        browserXssFilter: true
        contentTypeNosniff: true
        frameDeny: true
        sslRedirect: true
        #HSTS Configuration
        customFrameOptionsValue: "SAMEORIGIN"
        stsIncludeSubdomains: true
        stsPreload: true
        stsSeconds: 31536000
    https-redirect:
      redirectScheme:
        scheme: https

STRG-x, y, Enter

Vielen Dank an dieser Stelle an https://goneuland.de/traefik-v2-https-verschluesselung-sicherheit-verbessern/. Ohne diesen Tip wäre es hier nicht so einfach weiter gegangen. Ganz speziell die Header-Sache hat mich am WordPress fast zum Verzweifeln gebracht. Ich habe diese Datei um ein kleines Extra erweitert (die letzten 3 Zeilen).

Traefik.yml

Nicht vergessen, Eure Email einzutragen!

sudo nano /home/dockervolumes/traefik/traefik.yml

## STATIC CONFIGURATION
log:
  level: INFO
  filePath: "/traefik.log"
 
api:
  insecure: true
  dashboard: true
 
entryPoints:
  http:
    address: ":80"
  https:
    address: ":443"
 
providers:
  docker:
    endpoint: "unix:///var/run/docker.sock"
    network: traefik-net
    exposedByDefault: false
  file:
    filename: "/dynamic_conf.yml"
 
certificatesResolvers:
  lets-encr:
    acme:
      storage: acme.json
      email: EMAIL-ADRESSE
 
      httpChallenge:
        entryPoint: http

STRG-x, y, Enter

Passen wir die traefik-docker-compose.yml noch an. Traefik wird nun von Innen und von Aussen erreichbar sein. Natürlich hier unbedingt von Aussen Passwortgeschützt und mit einer sicheren Verbindung. Wartet bitte ca. 1 Minute nach dem Start von Traefik, dass Letsencrypt genügent Zeit hat, die Zertifikate anzulegen. Das gilt auch für die anderen Docker.

Traefik-Compose

Hier tritt die Wirksamkeit des Passwortschutzes in Kraft (In Zeile 33, hinter users= die Ausgabe des vorhin erstellten Passwortes eingeben (das “ am Ende nicht vergessen!))!

sudo nano /home/dockervolumes/traefik/docker-compose.yml

version: '3'
 
services:
  traefik:
    image: "traefik:v2.2"
    container_name: "traefik"
    hostname: "traefik"
    restart: unless-stopped
 
    security_opt:
      - no-new-privileges:true
 
    networks:
      - traefik-net
 
    ports:
      - 80:80
      - 443:443
      - 8080:8080
 
    volumes:
      - "/etc/localtime:/etc/localtime:ro"
      - "/var/run/docker.sock:/var/run/docker.sock:ro"
      - "/var/log/traefik.log:/traefik.log"
      - "./traefik.yml:/traefik.yml:ro"
      - "./acme.json:/acme.json"
      - "./dynamic_conf.yml:/dynamic_conf.yml:ro"
 
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.traefik.entrypoints=http"
      - "traefik.http.routers.traefik.rule=Host(`traefik.knilix.duckdns.org`)"
      - "traefik.http.middlewares.traefik-auth.basicauth.users=admin:$$apr1$$2W74R0Cf$$HD9TjPUXTtDIfbdFU3FtN."
      - "traefik.http.routers.traefik.middlewares=https-redirect@file"
      - "traefik.http.routers.traefik-secure.entrypoints=https"
      - "traefik.http.routers.traefik-secure.rule=Host(`traefik.knilix.duckdns.org`)"
      - "traefik.http.routers.traefik-secure.middlewares=traefik-auth"
      - "traefik.http.routers.traefik-secure.tls=true"
      - "traefik.http.routers.traefik-secure.tls.certresolver=lets-encr"
      - "traefik.http.routers.traefik-secure.service=api@internal"
 
networks:
  traefik-net:
    external: true

STRG-x, y, Enter

Falls sich jemand fragt, was es mit der letzten Zeile external: true auf sich hat, bekommt jetzt die Antwort. Damit wird dem Docker nur angegeben, dass es sich um ein selbst-angelegtes Netwerk handelt und bei beenden und/oder Löschen des Dockers, das Netzwerk, in diesem Fall traefik-net, nicht mit gelöscht werden soll. Oder so ähnlich…

cd /home/dockervolumes/traefik && sudo docker-compose up -d

Mit Aufruf von traefik.knilix.duckdns.org sehen wir, nach Passworteingabe, die Benutzeroberfläche von Traefik, natürlich mit SSL. Von Innen ist Traefik weiterhin mit VM-Server-IP:8080 erreichbar.

Mein Traefik Dashboard (fast fertig)

MariaDB

Erstellen wir unsere Datenbank, die auf dem VM-System zuständig sein wird:

sudo mkdir /home/dockervolumes/mariadb

cd /home/dockervolumes/mariadb && sudo nano docker-compose.yml

---
version: "2"
services:
  mymariadb:
    image: linuxserver/mariadb
    container_name: mariadb
    restart: unless-stopped
 
    environment:
      - PUID=1000
      - PGID=1000
      - MYSQL_ROOT_PASSWORD=123458789
      - TZ=Europe/Berlin
 
    volumes:
      - /var/lib/MariaDB:/config
 
    ports:
      - 3306:3306
 
    networks:
      - intern
 
networks:
  intern:
    external: true

STRG-x, y, Enter

MariaDB wird nur im Netzerk intern verfügbar sein. Und das auch richtig so! Keiner will, dass eine Datenbank irgendwo Frei-Zugänglich herumliegt!

Nach dem Start, zur ersten Initialisierung, benötigt MariaDB eine Weile. 1 Minute warten, bevor man darauf zugreift.

cd /home/dockervolumes/mariadb && sudo docker-compose up -d

Schön, dass wir jetzt die Datenbank installiert haben. Mit unserer Angabe von „volumes“ haben wir den Vorteil, dass die Datenbankbankdaten ausserhalb des Dockers abgelegt werden. Somit bleiben die Daten erhalten, auch wenn der Docker mal gelöscht werden sollte. Mit Hilfe von phpMyAdmin lege ich mir meine Datenbanken selbst an.

PhpMyAdmin

Da wir in unserer eigenen VM die Sachen installieren, verzichte ich auch bei PhpMyAdmin auf den Zugriff von Aussen.

sudo mkdir -p /home/dockervolumes/phpmyadmin

sudo nano /home/dockervolumes/phpmyadmin/docker-compose.yml

---
version: "2"
services:
 phpmyadmin:
    image: jackgruber/phpmyadmin
    container_name: phpmyadmin
    restart: unless-stopped
 
    environment:
# IP der VM verwenden!
      - PMA_HOST=192.168.252.118
      - PMA_PORT=3306
    ports:
      - 8081:80
      - 9001:9000
 
    networks:
      - intern
 
networks:
  intern:
    external: true

STRG-x, y, Enter

Starten wir den Docker:

cd /home/dockervolumes/phpmyadmin && sudo docker-compose up -d

Jetzt lege ich meine Datenbank per Hand an. Aufruf von PhpMyAdmin im Browser mit VM-IP:8081

Login mit root und das Passwort, welches im mariadb-Dockerfile angegeben wurde. !

Auch hier machte der Browsercache, bei meinen unendlichen Versuchen, immer wieder den Spaß zunichte. Aber irgendwann gewöhnt man sich dran…

Phpmyadmin startet und knallt uns prompt einen kleinen Warnhinweis um die Ohren. Doch das ist normal.

Einfach auf „Finden Sie heraus, warum“ klicken

Und jetzt auf „anlegen“ klicken – Fertig. Es erscheinen ganz viele „OK’s“.

Dann auf Datenbanken (oberes Menufeld) klicken, einen Datenbanknamen im Eingabefeld eintragen (nextcloud) und utf8_general_ci und auf „Anlegen“ klicken.

Jetzt im linken Menu auf „Neu“ und im oberen Menu auf „Benutzerkonten“ klicken. Nun auf „Neu – Benutzerkonto hinzufügen“

Benutzername und Passwort angeben. Hostname gebe ich mit % an. Authentifizierung ist „Native MYSQL.Authentifizierung“.

Jetzt ganz runter scrollen und auf „OK“ klicken. Alles was mit „Globale Rechte“ zu tun hat, bleibt bitte AUS! Auch Datenbank für Benutzerrechte lassen wir unberührt.

Jetzt legen wir noch für unseren soeben erstellten Benutzer die Datenbankrechte an. Links im Menu auf „Neu“ und oben im Menu auf „Benutzerkonten“. Jetzt an den soeben erstellten Benutzernamen „Rechte ändern“ klicken, oben, in der zweiten Reihe, den Reiter „Datenbank“ wählen, im Auswahlmenu „nextcloud“ selektieren und OK. Jetzt bei „Datenbankspezifife Rechte“ – „Alle auswählen“ und OK.

Soeben wurde eine Datenbank für nextcloud erstellt, mit einem Benutzer, der NUR Rechte für die Datenbank nextcloud besitzt. Was wir heute nicht alles lernen 🙂

Da wir jetzt wissen, wie es funktioniert, legen wir auch gleich eine Datenbank und einen Benutzernamen für WordPress an 🙂

Wenn fertig, kann das phpmadmin-Fenster geschlossen werden.

Nextcloud

Hier wäre der Eintrag external_links wichtig: Hier kommt die Datenbankzuweisung des Services der MariaDB rein. In meinen Fall mymariadb. Die Passwortabfrage kann man sich bei einer Cloud sparen. Aber ich habe diese absichtlich reingesetzt, damit man mit den einzelnen Befehlen erste „Gehversuche“ machen kann. Die Zeilen 17 bis 19 und 24 bis 26 können theoretisch raus. Oder man setzt ein # vor der Zeile 18 und Zeile 25.

sudo mkdir /home/dockervolumes/nextcloud

cd /home/dockervolumes/nextcloud && sudo nano docker-compose.yml

version: "3.3"
 
services:
   nextcloud:
    image: nextcloud
    container_name: nextcloud
    hostname: "nextcloud"
    restart: unless-stopped
    ports:
      - 8082:80
    volumes:
      - /var/lib/Nextcloud/html:/var/www/html
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.nextcloud.entrypoints=http"
      - "traefik.http.routers.nextcloud.rule=Host(`nc.knilix.duckdns.org`)"
## Passwortabfrage
      - "traefik.http.middlewares.nextcloud-auth.basicauth.users=admin:$$apr1$$2W74R0Cf$$HD9TjPUXTtDIfbdFU3FtN."
##
      - "traefik.http.routers.nextcloud.middlewares=https-redirect@file"
      - "traefik.http.routers.nextcloud-secure.entrypoints=https"
      - "traefik.http.routers.nextcloud-secure.middlewares=calcarddav,secHeaders@file"
      - "traefik.http.routers.nextcloud-secure.rule=Host(`nc.knilix.duckdns.org`)"
## gehört zu Passwortabfrage
      - "traefik.http.routers.nextcloud-secure.middlewares=nextcloud-auth"
##
      - "traefik.http.routers.nextcloud-secure.tls=true"
      - "traefik.http.routers.nextcloud-secure.tls.certresolver=lets-encr"
# Traefik-Redirects für CalDAV / CardDAV:
      - "traefik.http.middlewares.calcarddav.redirectregex.permanent=true"
      - "traefik.http.middlewares.calcarddav.redirectregex.regex=https://(.*)/.well-known/(card|cal)dav"
      - "traefik.http.middlewares.calcarddav.redirectregex.replacement=https://$$1/remote.php/dav/"
 
    external_links:
       - mymariadb
 
    networks:
      - intern
      - traefik-net
 
networks:
  intern:
    external: true
  traefik-net:
    external: true

STRG-x, y, Enter

cd /home/dockervolumes/nextcloud && sudo docker-compose up -d

Auf zur Einrichtung Nextcloud

Im Browser gebe ich jetzt nc.knilix.duckdns.org ein und erhalte das Konfigurationsmenu von Nextcloud – natürlich mit zertifiziertem https, wenn man kurz wartet! Bevor mann die Einrichtung beginnt, unbedingt schauen, dass man auch https verwendet!

Administrator-Konto anlegen: lasst Euch was einfallen

Datenverzeichnis: /var/www/html/data

Speicher & Datenbank: MySQL/MARIADB

Datenbankbenutzer: Euren Benutzer, der soeben in phpmyadmin erstellt wurde

Datenbankpasswort: Das dazugehörige Passwort

Datenbankname: nextcloud

Datenbank-Host: VM-Server-IP:3306

Jetzt auf „Installation abschließen“ klicken. Da dauert dauert jetzt etwas. Nach ca. 1-2 Minuten springt das Anmeldefenster um und es werden noch empfohlene Apps installiert, weil ich den Haken bei „Empfohlene Apps installieren“ gesetzt habe. Irgendwas ist doch immer^^.

Die gesamte Ersteinrichtung dauerte dann doch gefühlte 4 Minuten.

Fertig!

Ein Tip!

Das Login mit dem Benutzernamen, welchen wir für Nextcloud in der *.yml angelegt haben, gilt NUR für den Datenbankzugriff (z.B über phpmyadmin). Der Login im Nextcloud ist das Administrator-Login, welches vor der Ersteinrichtung im Browser angelegt wurde.

Sicherheits- & Einrichtungswarnungen in Nextcloud:

Einige Sachen werden hier behoben.

Ein weiterer Tip (Login-Problem Handy-App)!

Nach dem Browser-Login im Nextcloud, erstelle ich einen weiteren Benutzer, der keine admin-Rechte hat. Dann logge ich mit diesem Benutzer ein, gehe auf Einstellungen (rechts oben) und dann links auf Sicherheit. Dort im Hauptfenster, ziemlich weit unten auf App-Name, dort gebe ich einen Namen ein, klicke auf „Neues App-Passwort erstellen“ und dann auf „QR-Code für mobile Apps anzeigen“. Diesen QR-Code verwende ich dann für das erste Login in der Nextcloud-App am Handy. Somit wäre binnen Sekunden die Einrichtung der Handy-App erledigt.

WordPress

Wichtig! DB_Host ist der Name des Services, welcher in der maraidb-compose hinterlegt ist. Ebenso external_links.

sudo mkdir -p /home/dockervolumes/wordpress

sudo nano /home/dockervolumes/wordpress/docker-compose.yml

version: '3.1'
 
services:
 
   wordpress:
    image: wordpress
    restart: unless-stopped
 
    ports:
      - 8083:80
 
    environment:
# Daten müssen in der Datenbank schon angelegt sein!
      WORDPRESS_DB_HOST: mymariadb
      WORDPRESS_DB_USER: wie_in_Datenbank
      WORDPRESS_DB_PASSWORD: 'wie_in_Datenbank'
      WORDPRESS_DB_NAME: wordpress
 
    volumes:
      - /var/lib/Wordpress:/var/www/html
 
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.wordpress.entrypoints=http"
      - "traefik.http.routers.wordpress.rule=Host(`wordpress.knilix.duckdns.org`)"
      - "traefik.http.routers.wordpress.middlewares=https-redirect@file"
      - "traefik.http.routers.wordpress-secure.entrypoints=https"
      - "traefik.http.routers.wordpress-secure.rule=Host(`wordpress.knilix.duckdns.org`)"
      - "traefik.http.routers.wordpress-secure.middlewares=secHeaders@file"
      - "traefik.http.routers.wordpress-secure.tls=true"
#
      - "traefik.http.routers.wordpress-secure.tls.certresolver=lets-encr"
 
 
    external_links:
       - mymariadb
 
    networks:
      - traefik-net
      - intern
 
networks:
  traefik-net:
    external: true
  intern:
    external: true

STRG-x, y, Enter

cd /home/dockervolumes/wordpress && sudo docker-compose up -d

Aufruf mit wordpress.knilix.duckdns.org. Es erfolgt eine automatische Umleitung zu https und die Ersteinrichtung kann beginnen.

Fertig. Im wahrsten Sinne des Wortes^^.

Jetzt noch ein Check auf SSL Labs (https://www.ssllabs.com/ssltest/)

Bingo-Soweit scheint wohl alles zu passen

Update der Docker.

.

Wie aktualisiert man jetzt die Docker? Ich verwende dafür ein kleines Script, welches ich momentan noch per Hand starte. Aber bedenkt, dass ALLE Docker, von denen sich in Dockervolumes die Scripte befinden, geupdated und gestartet werden, auch wenn diese nicht relevant sind. Soll heissen, dass die Compose-Files von Dockern, die keine Verwendung mehr haben oder momentan nicht benötigt werden, nicht im Verzeichnis /home/dockervolumes sein sollten.

cd /usr/local/bin && sudo nano mydockerupdatecomposescript

#!/bin/bash
# Automatisches Update ALLER Docker in /home/dockervolumes/*
# Ablageverzeichnis: /usr/local/bin/mydockerupdatecomposescript
# Angabe Hauptverzeichnis
  
# Datenbank stoppen
##cd /home/dockervolumes/mariadb
##sudo docker-compose stop
# Datenbank gestoppt (wird automatisch wieder gestartet)
  
cd /home/dockervolumes
   
readarray -d '' composeConfigs < <(find . -type f -name docker-compose.y* -print0)
   
for cfg in "${composeConfigs[@]}"; do
  docker-compose -f "$cfg" pull
  docker-compose -f "$cfg" up -d
done
   
# Alte Images automatisch löschen
docker image prune -f

Strg-x, y, Enter

Zum Aufruf des Scriptes folgenden Befehl eingeben:

sudo bash mydockerupdatecomposescript

Entfernt man bei den beiden Befehlen mit ## davor die ##, wird die Datenbank vor der Überprüfung der Docker gestoppt. Anschließend wird diese automatisch wieder gestartet. Dies dient zur Sicherheit, um einen Crash oder Datenverlust vorzubeugen, falls bei der Aktualisierung im selben Moment darauf geschrieben werden sollte.

Möchte man dieses Script täglich durchlaufen lassen, dann hilft folgendes:

sudo crontab -e 

Falls noch nicht geschehen, den Editor wählen. Ich verwende die 1 (nano). Folgendes am Ende der Datei einfügen (das Hashtag am Ende nicht vergessen):

0 5 * * * sudo bash mydockerupdatecomposescript
#

STGR-x, y, Enter

Jetzt wird täglich 05:00 Uhr geschaut, ob ein Update des Dockers verfügbar ist und gegebenenfalls geupdated.

Möchte man nur einmal pro Woche updaten, z.B Montag 05:00 Uhr, dann:

0 5 * * 1 sudo bash mydockerupdatecomposescript
#

STGR-x, y, Enter

Oder nur einmal im Monat, z.B. am 01. jeden Monats um 05:00 Uhr:

0 5 * 1 * sudo bash mydockerupdatecomposescript
#

STGR-x, y, Enter

Ganz gut beschrieben wird das auf https://wiki.ubuntuusers.de/Cron/

.

Quelle(n):

https://projekt-rootserver.de

https://greenitsolutions.at/traefik-docker-lets-encrypt-tutorial/

https://goneuland.de/traefik-v2-reverse-proxy-fuer-docker-unter-debian-10-einrichten/

https://github.com/DoTheEvo/Traefik-v2-examples

https://docs.traefik.io

https://thibmaek.com/post/updating-all-docker-compose-container

https://www.smarthomebeginner.com/traefik-reverse-proxy-tutorial-for-docker

https://chriswiegman.com/2020/01/running-nextcloud-with-docker-and-traefik-2

https://www.teqqy.de/reverse-proxy-mit-traefik-unter-docker