Wie man den Nginx Proxy Manager mit Docker installiert und verwendet
Ein Reverse Proxy ist ein Webserver, der einem anderen Webserver oder einem Webservice vorgeschaltet werden kann. Er kann ausgehenden Datenverkehr verschlüsseln, als Load Balancer fungieren, den Datenverkehr umleiten und Schutz bieten. Der Nginx-Webserver kann als Proxy-Server vor herkömmlichen Servern eingesetzt werden, aber manchmal kann die Einrichtung mühsam sein und Probleme verursachen, wenn sie nicht richtig durchgeführt wird.
Der Nginx Proxy Manager ist eine Anwendung, die die Einrichtung von Nginx als Proxy-Server erleichtert, indem sie eine grafische Benutzeroberfläche (GUI) mit Funktionen wie integrierter SSL-Unterstützung mit Let’s Encrypt, Unterstützung für mehrere Hosts, HTTP-Authentifizierung, Zugriffslisten und Benutzerverwaltung bietet.
In diesem Lernprogramm lernst du, wie du den Nginx Proxy Manager mit Docker auf einem Linux-Server installierst. Wir werden alle gängigen Linux-Distributionen in einem einzigen Tutorial behandeln.
Voraussetzungen
- Ein Linux-Server mit Ubuntu/Debian/CentOS/Alma Linux/Rocky Linux und mindestens 1 GB RAM.
- Ein Nicht-Root-Benutzer mit sudo-Rechten.
- Ein vollständig qualifizierter Domainname (FQDN) wie
npm.example.com, der auf den Server zeigt.
Schritt 1 – Firewall konfigurieren
Cent OS/Rocky Linux/Alma Linux
Du solltest die Firewall Firewalld installiert haben. Überprüfe den Status der Firewall.
$ sudo firewall-cmd --state running
Öffne die Ports 80, 81 und 443.
$ sudo firewall-cmd --permanent --add-service=http $ sudo firewall-cmd --permanent --add-service=https $ sudo firewall-cmd --permanent --add-port=81/tcp
Lade die Firewall neu, um die Änderungen zu aktivieren.
$ sudo firewall-cmd --reload
Ubuntu/Debian
Ubuntu- und Debian-Systeme verwenden standardmäßig ufw (Uncomplicated Firewall).
Prüfe, ob die Firewall aktiv ist.
$ sudo ufw status
Wenn sie läuft, dann öffne die Ports 80, 81 und 443.
$ sudo ufw allow 80 $ sudo ufw allow 81 $ sudo ufw allow 443
Öffne den SSH-Port, wenn die Firewall nicht läuft.
$ sudo ufw allow "OpenSSH"
Aktiviere die Firewall, wenn sie nicht aktiv ist.
$ sudo ufw enable
Wenn sie läuft, lade sie neu, um die Änderungen zu übernehmen.
$ sudo ufw reload
Schritt 2 – Docker installieren
Cent OS/Rocky Linux/Alma Linux
Führe den folgenden Befehl aus, um Docker zu installieren.
$ sudo yum install -y yum-utils
$ sudo yum-config-manager \
--add-repo \
https://download.docker.com/linux/centos/docker-ce.repo
$ sudo yum install docker-ce docker-ce-cli containerd.io
Ubuntu
$ sudo apt install ca-certificates curl gnupg lsb-release $ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg $ echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu \ $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null $ sudo apt update $ sudo apt install docker-ce docker-ce-cli containerd.io
Debian
$ sudo apt install ca-certificates curl gnupg lsb-release $ curl -fsSL https://download.docker.com/linux/debian/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg $ echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/debian \ $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null $ sudo apt update $ sudo apt install docker-ce docker-ce-cli containerd.io
Aktiviere und starte den Docker-Dienst.
$ sudo systemctl start docker --now
Füge deinen Benutzernamen zur Docker-Gruppe hinzu.
$ sudo usermod -aG docker $USER
Melde dich aus dem System ab und melde dich wieder an, um die Änderung zu übernehmen.
Schritt 3 – Docker Compose installieren
Lade die Docker Compose Binärdatei herunter und installiere sie.
$ sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
Erteile der Binärdatei die Berechtigung zur Ausführung.
$ sudo chmod +x /usr/local/bin/docker-compose
Schritt 4 – Docker Compose-Datei erstellen
Erstelle ein Verzeichnis für den Nginx Proxy Manager.
$ mkdir ~/nginx-proxy
Wechsle in das Verzeichnis.
$ cd ~/nginx-proxy
Erstelle Verzeichnisse für Benutzerdaten und SSL-Zertifikate.
$ mkdir {data,letsencrypt}
Erstelle und öffne die Datei docker-compose.yml zum Bearbeiten.
$ nano docker-compose.yml
Füge den folgenden Code in die Datei ein.
version: "3"
services:
npm-app:
image: 'jc21/nginx-proxy-manager:latest'
container_name: npm-app
restart: unless-stopped
ports:
- '80:80' # Public HTTP Port
- '443:443' # Public HTTPS Port
- '81:81' # Admin Web Port
# Add any other Stream port you want to expose
# - '21:21' # FTP
environment:
DB_MYSQL_HOST: "npm-db"
DB_MYSQL_PORT: 3306
DB_MYSQL_USER: "npm"
DB_MYSQL_PASSWORD: "npm"
DB_MYSQL_NAME: "npm"
# Uncomment the line below if IPv6 is not enabled on your host
# DISABLE_IPV6: 'true'
volumes:
- ./data:/data
- ./letsencrypt:/etc/letsencrypt
depends_on:
- npm-db
networks:
- npm-nw
- npm-internal
npm-db:
image: 'mariadb:latest'
container_name: npm-db
restart: unless-stopped
environment:
MYSQL_ROOT_PASSWORD: 'npm'
MYSQL_DATABASE: 'npm'
MYSQL_USER: 'npm'
MYSQL_PASSWORD: 'npm'
volumes:
- ./data/mysql:/var/lib/mysql
networks:
- npm-internal
networks:
npm-internal:
npm-nw:
external: true
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Lass uns die Datei durchgehen. Im ersten Teil der Datei importieren wir das Image des Nginx-Proxy-Managers und setzen einige Umgebungsvariablen in Form von Datenbankanmeldedaten. Außerdem geben wir die Ports 80, 81 und 443 für den Zugriff auf den Server frei. Für den FTP-Zugang kannst du weitere Ports freigeben, z. B. 21. Du kannst die IPV6-Unterstützung deaktivieren, indem du die Zeile DISABLE_IPV6: 'true' auskommentierst. Wir haben mehrere Verzeichnisse von unserem Host auf den Docker gemappt, um Daten und SQL zu speichern.
Wir verwenden hier zwei Netzwerke. Das eine ist das interne Netzwerk npm-internal, um den Proxy Manager und die Datenbank zu verbinden. Dieses Netzwerk ist optional, da es automatisch erstellt wird. Aber hier tun wir es manuell, indem wir ihm einen Namen unserer Wahl geben.
Wir haben dem Proxy Manager Container ein externes Netzwerk namens npm-nw hinzugefügt. Dieses Netzwerk ist wichtig, denn damit kannst du den Proxy-Manager mit allen anderen Docker-Containern verbinden, die du installierst. Wenn du ein Netzwerk verwendest, kannst du jeden Container direkt verbinden, ohne seine Ports für den Server freigeben zu müssen.
Schritt 5 – Nginx Proxy Manager starten
Bevor wir den Docker-Container starten, müssen wir das externe Netzwerk npm-nw erstellen. Interne Netzwerke werden automatisch erstellt. Führe den folgenden Befehl aus, um das externe Netzwerk zu erstellen.
$ docker network create npm-nw
Starte den Docker-Container mit dem folgenden Befehl.
$ docker-compose up -d
Überprüfe den Status des Containers.
$ docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES c91ca0ddca97 jc21/nginx-proxy-manager:latest "/init" About a minute ago Up About a minute 0.0.0.0:80-81->80-81/tcp, :::80-81->80-81/tcp, 0.0.0.0:443->443/tcp, :::443->443/tcp npm-app 1738d71b95da mariadb:latest "docker-entrypoint.s…" About a minute ago Up About a minute 3306/tcp npm-db
Schritt 6 – Zugriff auf den Nginx Proxy Manager
Du kannst nun über die URL http://yourserverIP:81 auf deinen Nginx Proxy Manager zugreifen. Du solltest den folgenden Anmeldebildschirm erhalten.
Gib die folgenden Standard-Anmeldedaten ein, um dich anzumelden.
E-Mail Adresse: admin@exampl.com Passwort: changeme
Als Nächstes wirst du sofort aufgefordert, einen Namen und eine E-Mail-Adresse anzugeben.
Klicke auf die Schaltfläche Speichern und du wirst aufgefordert, ein neues Passwort festzulegen.
Klicke erneut auf die Schaltfläche “ Speichern“ und du kannst die Anwendung nun nutzen.
Wenn du die URL http://yourserverIP in deinem Browser öffnest, gelangst du auf eine Standardseite, die der Proxy Manager eingestellt hat.
Schritt 7 – Einrichten von Domainname und SSL für den Nginx Proxy Manager
Legen wir einen Domainnamen für den Zugriff auf den Nginx Proxy Manager fest. Dieser Schritt ist optional, aber nützlich, wenn du die Anwendung mit SSL verschlüsseln willst.
Klicke im Dashboard-Menü auf Hosts >> Proxy Hosts, um die Seite Proxy Hosts zu öffnen. Klicke dort auf die Schaltfläche Proxy-Host hinzufügen, um fortzufahren.
Füge den FQDN-Namen (npm.example.com) hinzu und klicke ihn an. Gib die IP-Adresse deines Servers und 81 als Forward Port ein.
Wechsle zur Registerkarte SSL.
Wähle die Option Neues SSL-Zertifikat anfordern aus dem Dropdown-Menü. Wähle die Optionen SSL- und HTTP/2-Unterstützung erzwingen. Wenn du HSTS aktivieren möchtest, kannst du das auch tun. Wenn du deine Domain über Cloudflare konfiguriert hast, darfst du die Option SSL er zwingen nicht aktivieren, da du sonst in einer Umleitungsschleife stecken bleibst.
Gib deine E-Mail-Adresse ein, stimme den Let’s Encrypt Terms of Service (TOS) zu und klicke zum Abschluss auf die Schaltfläche Speichern.
Deine Domain sollte jetzt funktionieren. Wenn du https://npm.example.com in deinem Browser öffnest, solltest du den Anmeldebildschirm des Nginx Proxy Managers erhalten.
Du kannst dies in ähnlicher Weise für die Standard-Landingpage tun und ihr einen Domainnamen wie https://example.com zuweisen. Ändere beim Einrichten des Proxy-Hosts einfach den Port von 81 auf 81.
Schritt 8 – Nginx Proxy Manager mit einer anderen Docker-Webanwendung verwenden
Jetzt, wo wir den Proxy Manager installiert haben, ist es an der Zeit, ihn zu nutzen. Als Erstes werden wir ihn nutzen, um eine andere Docker-Webanwendung zu hosten. Zu diesem Zweck werden wir den Ghost Blog installieren. Wenn du mehr darüber erfahren möchtest, schau dir unser Tutorial zur Installation von Ghost mit Docker auf einem Ubuntu-Server an.
Erstelle ein weiteres Verzeichnis für deinen Ghost-Blog.
$ mkdir ~/ghost
Wechsle in das Ghost-Verzeichnis.
$ cd ~/ghost
Erstelle zwei Verzeichnisse für den Inhalt und die Datenbank.
$ mkdir {content,mysql}
Auch wenn du das gleiche MySQL-Image verwendest, solltest du die Daten und ihre Container von denen des Proxy-Managers getrennt halten. So kannst du eventuelle Probleme eingrenzen und die Daten bei Bedarf umlagern.
Erstelle und öffne die Docker Compose-Datei zum Bearbeiten.
$ nano docker-compose.yml
Füge den folgenden Code ein. Ersetze example.com durch deinen tatsächlichen Domainnamen für deinen Ghost-Blog. Gib die SMTP-Daten ein, wenn du E-Mails empfangen möchtest. Du kannst sie entfernen, wenn du sie nicht brauchst.
version: '3.3'
services:
ghost-app:
image: ghost:latest
container_name: ghost-app
restart: always
depends_on:
- ghost-db
environment:
url: https://ghost.example.com
database__client: mysql
database__connection__host: ghost-db
database__connection__user: ghost
database__connection__password: ghostdbpass
database__connection__database: ghostdb
mail__transport: SMTP
mail__options__host: {Your Mail Service host}
mail__options__port: {Your Mail Service port}
mail__options__secureConnection: {true/false}
mail__options__service: {Your Mail Service}
mail__options__auth__user: {Your User Name}
mail__options__auth__pass: {Your Password}
volumes:
- /home/<username>/ghost/content:/var/lib/ghost/content
networks:
- npm-nw
- ghost-network
ghost-db:
image: mariadb:latest
container_name: ghost-db
restart: always
environment:
MYSQL_ROOT_PASSWORD: your_mysql_root_password
MYSQL_USER: ghost
MYSQL_PASSWORD: ghostdbpass
MYSQL_DATABASE: ghostdb
volumes:
- /home/<username>/ghost/mysql:/var/lib/mysql
networks:
- ghost-network
networks:
ghost-network:
npm-nw:
external: true
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Wie du sehen kannst, haben wir den Ghost-Container mit dem Nginx-Proxy-Manager über das externe Netzwerk npm-nw verbunden. Auf diese Weise geben wir die Ports von Ghost nicht an das System weiter. Wir haben auch ein internes Netzwerk ghost-network verwendet, um unsere Ghost-App und den dazugehörigen Datenbank-Container zu verbinden.
Starten Sie den Container.
$ docker-compose up -d
Ghost im Nginx Proxy Manager konfigurieren
Jetzt müssen wir den Reverse Proxy für unsere Ghost-Installation einrichten. Öffne den Nginx Proxy Manager in deinem Browser, gehe zu Dashboard >> Hosts >> Proxy Host und füge einen neuen Proxy Host hinzu.
Füge den Domainnamen hinzu, den du für deinen Ghost-Blog gewählt hast. Für den Wert Hostname/IP gibst du den Namen deines Containers ein. In diesem Fall wäre das ghost-app. Wir können hier nicht die IP-Adresse angeben, weil wir den Port von Ghost nicht für den Server freigegeben haben und der Nginx-Proxy Ghost nicht über die IP erreichen kann. Daher verwenden wir den Containernamen, auf den NPM über das Docker-Netzwerk npm-nw zugreifen kann, das wir erstellt haben. Verwende als Port 2368, den Standardport des Ghost Blogs. Überprüfe die anderen Optionen, wie auf dem Screenshot oben gezeigt.
Wechsle als Nächstes zum Reiter SSL und erstelle ein neues SSL-Zertifikat wie in Schritt 6 beschrieben. Da du Inhalte in deinen Ghost-Blog hochladen wirst, wäre es gut, eine maximale Upload-Größe für deine Uploads festzulegen.
Zum Glück kannst du mit NPM eigene Konfigurationen hinzufügen. Wechsle zur Registerkarte “ Erweitert“ und gib in das Feld client_max_body_size 50m; ein.
Klicke auf die Schaltfläche Speichern, um das Hinzufügen des Proxy-Hosts abzuschließen. Du solltest nun in der Lage sein, deinen Ghost-Blog über die folgende URL zu erreichen https://ghost.exampl.com
Schritt 9 – Nginx Proxy Manager als Redirect-Dienst verwenden
Sehen wir uns an, wie du NPM nutzen kannst, um eine Domain einfach auf eine andere umzuleiten. Gehe dazu auf Dashboard >> Hosts >> Redirection Hosts. Dort klickst du auf die Schaltfläche Umleitungshost hinzufügen, um loszulegen.
Gib den Domainnamen ein, den du weiterleiten möchtest. Und gib die Weiterleitungsdomain ein. Die Weiterleitungsdomain sollte bereits konfiguriert sein. Belasse das Schema auf auto. Je nach deinen Anforderungen kannst du http oder https wählen. Wähle den richtigen HTTP-Code und aktiviere die Optionen Pfad beibehalten und Common Exploits blockieren. Wenn du ein automatisches oder https-Schema verwendest, stelle sicher, dass du ein SSL-Zertifikat ausgewählt oder mit NPM erstellt hast. Klicke auf Speichern, um das Hinzufügen deines Umleitungshosts abzuschließen.
Deine Domain example.com sollte nun auf blog.example.com umgeleitet werden.
Andere Verwendungen des Nginx Proxy Managers
Es gibt zwei weitere Möglichkeiten, den Nginx Proxy Manager zu nutzen. Du kannst ihn als 404-Host verwenden, d.h. du kannst eine Domain als Landing Page verwenden, um den Suchmaschinen zu zeigen, dass die Seiten der Domain nicht existieren. Bei diesem Schritt musst du nur eine Domain eingeben und SSL für sie einrichten. Du kannst dies auch als Gelegenheit nutzen, die Logs für den Domainnamen zu verfolgen und den Referrer-Traffic zu sehen.
Die andere Funktion ist die Verwendung von NPM als Stream-Host. Mit dieser Funktion kannst du TCP/UDP-Ports an einen anderen Computer im Netzwerk weiterleiten. Das ist nützlich, wenn du Spieleserver hostest. Dazu musst du nur den eingehenden Port, die weiterleitende Domain oder IP-Adresse, den weiterleitenden Port und die Art des Ports angeben.
Nginx Proxy Manager zum Hosten einer statischen Website verwenden
Nginx Proxy Manager kann auch einfache statische oder dynamische Websites hosten. Dazu fügst du einen neuen Proxy-Host hinzu und wählst 127.0.0.1 als Weiterleitungsdomäne und 80 als Port.
Auf der Registerkarte Erweitert gibst du die Konfiguration ein, in der du das Stammverzeichnis angibst. Vergewissere dich, dass das Stammverzeichnis für die Website in der anfänglichen Docker Compose-Konfiguration eingebunden ist. Hier verwenden wir das Verzeichnis /data/static, um unsere statische Website zu hosten.
Klicke zum Abschluss auf Speichern und deine Website sollte zugänglich sein. Du kannst jede Art von Website mit dem Proxy Manager hosten.
Schritt 10 – Verschiedene Funktionen
Verwende die Zugriffskontrollfunktion des Nginx Proxy Managers
Du kannst die Zugriffslistenfunktion von NPM nutzen, um die HTTP-Authentifizierung zu aktivieren oder IP-Bereiche zu sperren. Öffne NPM und besuche die Seite Dashboard >> Zugriffslisten.
Klicke auf die Schaltfläche Zugriffsliste hinzufügen, um loszulegen.
Du kannst deine Zugriffslisten(ACL)-Konfiguration benennen. Wenn du die Registerkarte Erfülle alle anklickst, wird der Zugriff erlaubt, wenn der Client eine der angegebenen Bedingungen erfüllt. Wenn ein Client die HTTP-Authentifizierung besteht, aber den IP-basierten Zugriff nicht zulässt, wird er zugelassen. Ist die Option Satisfy Any jedoch nicht markiert, muss der Client alle Bedingungen erfüllen.
Die Funktion Auth an Host weitergeben leitet die Authentifizierungsfunktion an den Hostserver weiter.
Als Nächstes wechselst du zur Registerkarte Autorisierung. Hier kannst du einen Benutzernamen und ein Passwort für die HTTP-Authentifizierungsmethode erstellen. Um mehr als einen Benutzer hinzuzufügen, klicke auf die Schaltfläche Hinzufügen. Du kannst nur bis zu 5 Benutzer hinzufügen. Außerdem gibt es einen Fehler bei der Schaltfläche Hinzufügen, also benutze erst die Schaltfläche und gib dann die Details ein. Wenn du die Details ausfüllst und später auf die Schaltfläche klickst, um einen weiteren Benutzer hinzuzufügen, werden die vorherigen Benutzerdaten gelöscht.
Wechsle zur Registerkarte Zugriff. Hier kannst du einstellen, welchen IP-Adressen der Zugang gewährt oder verweigert werden soll.
Klicke zum Abschluss auf Speichern.
Um diese Zugriffsliste zu verwenden, musst du sie beim Hinzufügen deines Proxy-Hosts auswählen. Wie im Beispiel für Ghost Blog unten haben wir unsere Zugriffsliste ausgewählt.
Unterstützung für weitere Domainnamen aktivieren
Wenn die Anzahl der Hosts und Domains wächst, kann es sein, dass deinem Nginx der Hash-Speicherplatz ausgeht oder es zu Speicherproblemen kommt. Wir können eine benutzerdefinierte Konfiguration hinzufügen, die für alle Hosts gilt, um dieses Problem zu lösen.
Erstelle dazu das Verzeichnis custom innerhalb von ~/nginx-proxy/data/nginx.
$ sudo mkdir ~/nginx-proxy/data/nginx/custom
Erstelle und öffne die Datei http.conf innerhalb dieses Verzeichnisses.
$ sudo nano ~/nginx-proxy/data/nginx/custom/http.conf
Füge die folgenden Zeilen in die Datei ein.
proxy_headers_hash_max_size 1024; proxy_headers_hash_bucket_size 128;
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Nginx sollte diese Werte automatisch akzeptieren. Wenn das nicht der Fall ist, kannst du den NPM-Container mit dem folgenden Befehl neu starten.
$ docker restart npm-app
Standard Landing Page umleiten
In Schritt 6 siehst du die Standardseite, wenn du die URL http://<yourserverIP> eingibst. Wenn du das ändern möchtest, kannst du das tun. Besuche dazu die Seite Einstellungen. Klicke auf die drei Punkte auf der rechten Seite und dann auf die Schaltfläche Bearbeiten.
Du kannst die Landing Page so einstellen, dass sie als 404-Seite oder als Weiterleitungsseite fungiert, oder sie mit benutzerdefiniertem HTML versehen, indem du die Option Benutzerdefinierte Seite wählst. Wenn du Weiterleitung wählst, musst du die Ziel-URL angeben.
Das ist das benutzerdefinierte HTML, das wir für unseren Zweck verwenden.
<!doctype html>
<html>
<head>
<title>Nothing Here</title>
<meta charset="utf-8"/>
<meta name="robots" content="noindex"/>
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<style>
body {
text-align: center;
padding: 20px;
font: 20px Helvetica, sans-serif;
color: #333;
}
@media (min-width: 768px){
body{ padding-top: 150px;
}
}
h1 {
font-size: 50px;
}
article {
display: block;
text-align: left;
max-width: 650px;
margin: 0 auto;
}
</style>
</head>
<body>
<article>
<h1>Oops!</h1>
<div>
<p>Sorry for the inconvenience but you are not supposed to be here. You won't get anything here. This page was set for HowtoForge Nginx Proxy Manager Guide. Maybe, someday it will show something.</p>
</div>
</article>
</body>
</html>
Klicke zum Abschluss auf Speichern. Deine Landing Page sollte jetzt so aussehen wie die unten abgebildete.
Schritt 11 – Nginx Proxy Manager aktualisieren
Um NPM zu aktualisieren, musst du zuerst die Container stoppen.
$ cd ~/nginx-proxy $ docker-compose down --remove-orphans
Ziehe die neuesten Images.
$ docker-compose pull
Starte die Container erneut.
$ docker-compose up -d
Fazit
Damit ist unser Tutorium abgeschlossen. Du hast den Nginx Proxy Manager installiert und gelernt, wie du damit einen Proxy-Host für einen anderen Docker-Container hinzufügst, ihn als Umleitungsdienst verwendest und den Zugriff damit kontrollierst. Wenn du Fragen hast, schreibe sie unten in die Kommentare.