Wie man Portainer für die Docker-Verwaltung mit dem Nginx Proxy Manager installiert und nutzt

Portainer ist eine Open-Source-Container-Verwaltungslösung für Docker, Kubernetes und Nomad, die das Starten, Erstellen und Ausführen von Containern auf einfache Art und Weise vereinfacht. Sie bietet ein webbasiertes Dashboard zur Verwaltung von Containern, Images, Netzwerken und Volumes.

In diesem Lernprogramm lernst du, wie du die Portainer-Container-Verwaltungslösung auf einem Linux-Server installierst und konfigurierst und wie du damit Docker-Container für verschiedene Anwendungen erstellen und verwalten kannst. Außerdem lernst du, wie du diese Container mit dem Nginx Proxy Manager hinter Nginx platzieren kannst.

Voraussetzungen

• Ein Linux-Server mit Ubuntu / Debian / Cent OS / Rocky Linux 8 / Alma Linux.
• Ein Nicht-Root-Benutzer mit sudo-Rechten.
• Ein Fully Qualified Domain Name (FQDN), der auf den Server für Portainer (portrainer.example.com) und Nginx Proxy Manager (npm.example.com) verweist.

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, 9443 und 443. Portainer verwendet Port 9443, um seine Web-UI über HTTPS zu öffnen. DerNginx Proxy Manager verwendet Port 81 für seine UI.

$ sudo firewall-cmd --permanent --add-service=http
$ sudo firewall-cmd --permanent --add-service=https
$ sudo firewall-cmd --permanent --add-port=9443/tcp
$ 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, 9443 und 443.

$ sudo ufw allow 80
$ sudo ufw allow 443
$ sudo ufw allow 9443
$ sudo ufw allow 81

Ö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 – Portainer installieren

Erstelle ein Verzeichnis für Portainer.

$ mkdir ~/portainer

Wechsle in das Verzeichnis.

$ cd ~/portainer

Erstelle und öffne die Docker Compose Datei zum Bearbeiten.

$ nano docker-compose.yaml

Füge den folgenden Code in die Datei ein.

version: "3.3"
services:
    portainer:
      image: portainer/portainer-ce:latest
      container_name: portainer
      restart: always
      privileged: true
      volumes:
        - ./data:/data:Z
        - /var/run/docker.sock:/var/run/docker.sock:Z
      ports:
        - 9443:9443

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Lass uns die Docker Compose Datei durchgehen.

• Wir ziehen die neueste Version der Portainer Community Edition von Docker Hub. Die Portainer Community Edition kann kostenlos genutzt werden, während für die Business Edition eine kostenpflichtige Lizenz erforderlich ist. Du kannst die Business Edition nutzen, wirst aber nach dem Lizenzschlüssel gefragt, um sie zu verwenden.
• Wir haben unseren Container portainer genannt, um ihn zu identifizieren und zu verlinken.
• Die Neustart-Richtlinie ist auf always eingestellt, damit der Container während des Bootvorgangs aktiv bleibt.
• Die Einstellung privileged: true dient dazu, dass Portainer auf den Docker-Socket zugreifen kann und in einem privilegierten Kontext läuft, da wir SELinux verwenden. Wenn du kein SELinux verwendest, kannst du diese Einstellung entfernen. Mit dieser Einstellung kann der Portainer-Container auf alles auf dem Host-System zugreifen, auch auf die Hardware. Aktiviere diese Einstellung also nur, wenn du weißt, was du tust.
• Der Abschnitt volumes ordnet die Ordner auf dem Host den Ordnern im Container über Bind-Mounts zu. Wir haben das Verzeichnis ~/portainer/data für den Container freigegeben, um alle relevanten Daten zu speichern, und die Docker Socket API für die Containerverwaltung. Das Label :Z teilt Docker mit, dass wir SELinux auf unserem Host verwenden. Wenn du SELinux nicht aktiviert hast, solltest du das Label entfernen.

Starte Portainer.

$ docker-compose up -d

Überprüfe den Status des Containers.

$ docker ps
CONTAINER ID   IMAGE                           COMMAND        CREATED         STATUS         PORTS                                                           NAMES
916411e8d12e   portainer/portainer-ce:latest   "/portainer"   5 seconds ago   Up 4 seconds   8000/tcp, 9000/tcp, 0.0.0.0:9443->9443/tcp, :::9443->9443/tcp   portainer

Schritt 5 – Portainer aufrufen und konfigurieren

Öffne die URL https://<yourserverIP>:9443 in deinem Browser und du erhältst den folgenden Bildschirm.

Du wirst aufgefordert, einen neuen Administrator-Benutzer anzulegen. Gib deine Benutzerdaten ein. Deaktiviere das Kontrollkästchen Sammlung anonymer Statistiken zulassen, wenn dir der Datenschutz wichtig ist. Klicke auf die Schaltfläche Benutzer erstellen, um die Installation zu starten und ein neues Administratorkonto zu erstellen.

Als Nächstes wirst du zum folgenden Dashboard-Bildschirm weitergeleitet.

Nach ein paar Sekunden wird er automatisch aktualisiert und zeigt dir den folgenden Bildschirm an.

Er zeigt dir die lokale Umgebung an, in der Portainer läuft. Klicke auf die lokale Umgebung, um loszulegen.

Die meisten Abschnitte sind selbsterklärend. Der Abschnitt Stacks hilft dir bei der Erstellung von Containern mithilfe von Docker-Compose-Dateien. Du kannst Container direkt über die Kategorie Container in der Seitenleiste bereitstellen. Im Bereich Hosts kannst du die aktuelle Docker-Umgebung konfigurieren. Im Bereich App-Vorlagen findest du vorinstallierte Docker Compose-Dateien für die Installation der gängigsten Anwendungen. Du kannst auch eigene Vorlagen erstellen.

Im Bereich Einstellungen kannst du verschiedene Einstellungen vornehmen, z. B. benutzerdefinierte Docker-Registries hinzufügen, mehrere Hosts für Docker Swarm hinzufügen, den Benutzerzugang konfigurieren, Daten sichern und Portainer anpassen.

Schritt 5 – Portainer mit dem Nginx Proxy Manager (NPM) hinter einen Reverse Proxy setzen

Bevor wir weitermachen, müssen wir Portainer mit dem Nginx Proxy Manager hinter einen Reverse Proxy setzen. Der Nginx Proxy Manager ist eine Docker-Anwendung, die eine Web-Management-Oberfläche für die Einrichtung von Nginx als Reverse-Proxy-Host bietet. Er kann auch als Redirect- oder Streaming-Host verwendet werden.

NPM installieren

Der erste Schritt besteht darin, ein Netzwerk für den Nginx Proxy Manager (NPM) zu erstellen. Öffne den Bereich Netzwerke und klicke auf die Schaltfläche Netzwerk hinzufügen, um ein neues Netzwerk zu erstellen.

Gib dem Netzwerk einen Namen und lass alle Einstellungen unverändert. Klicke auf die Schaltfläche Netzwerk erstellen, um den Vorgang abzuschließen.

Gehe zu den Stacks und erstelle mit der Schaltfläche Stack hinzufügen einen neuen Stack.

Benenne den Stack als nginx-proxy-manager und füge den folgenden Code ein.

version: "3.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: ${DB_MYSQL_PASSWORD}
      DB_MYSQL_NAME: "npm"
      # Uncomment the line below if IPv6 is not enabled on your host
      # DISABLE_IPV6: 'true'
    volumes:
      - ./npm-data:/data:Z
      - ./letsencrypt:/etc/letsencrypt:Z
    depends_on:
      - npm-db
    networks:
      - npm-network
      - npm-internal

  npm-db:
    image: 'mariadb:latest'
    container_name: npm-db
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: ${MYSQL_ROOT_PASSWORD}
      MYSQL_DATABASE: 'npm'
      MYSQL_USER: 'npm'
      MYSQL_PASSWORD: ${DB_MYSQL_PASSWORD}
    volumes:
      - ./npm-data/mysql:/var/lib/mysql:Z
    networks:
      - npm-internal

networks:
  npm-internal:
  npm-network:
    external: true

Wir haben zwei Umgebungsvariablen gesetzt, um Datenbank- und Root-MySQL-Passwörter festzulegen. Portainer kann verwendet werden, um Geheimnisse mithilfe von Umgebungsvariablen zu setzen. Scrolle auf der Seite nach unten und klicke auf die Schaltfläche Umgebungsvariable hinzufügen, um starke Passwörter hinzuzufügen.

Klicke auf die Schaltfläche Deploy the stack, um den NPM-Container zu erstellen und zu starten.

Zugriff auf NPM

Öffne die URL https://<yourserverIP>:81 in deinem Browser und du erhältst den folgenden Bildschirm. Gib die folgenden Standard-Anmeldedaten ein, um dich anzumelden.

E-Mail Adresse: admin@example.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 zu erstellen. Klicke erneut auf die Schaltfläche Speichern, um loszulegen.

Gehe zu Hosts >> Proxy Hosts und klicke auf die Schaltfläche Proxy Host hinzufügen.

Gib den Domainnamen portainer.example.com ein. Wähle das Schema als https. Gib den Namen des Containers als Forward Hostname und 9443 als Forward Port ein. Aktiviere die Optionen Block Common Exploits und Websockets Support.

Wechsle zur Registerkarte SSL und wähle im Dropdown-Menü die OptionNeues SSL-Zertifikat anfordern. Aktiviere die OptionenForce SSL und HTTP/2 Support, um deine SSL-Verbindung zu sichern und zu optimieren. Gib die E-Mail-Adresse ein, an die du die Erneuerungsbenachrichtigungen senden möchtest, und stimme den Nutzungsbedingungen zu. Klicke auf die Schaltfläche Speichern, um die Einrichtung des Proxy-Hosts für Portainer abzuschließen.

Portainer mit dem NPM-Container verbinden

Wir haben den Proxy-Host eingerichtet, aber der Container ist noch nicht mit dem NPM-Netzwerk verbunden. Gehe zurück zum Portainer-Dashboard, besuche den Bereich Container und wähle den Portainer-Container aus.

Wähle npm-network aus dem Dropdown-Menü unter dem Abschnitt Verbundene Netzwerke und klicke auf die SchaltflächeNetzwerk beitreten, um den Portainer-Container zum Netzwerk des Proxy-Managers hinzuzufügen.

Es kann sein, dass du eine Fehlermeldung erhältst, aber wenn du die Seite aktualisierst, solltest du sehen, dass der Container zum NPM-Netzwerk hinzugefügt wurde.

Du solltest nun in der Lage sein, Portainer über die URL https://portainer.example.com in deinem Browser aufzurufen.

Du kannst ähnlich vorgehen, um NPM hinter einer öffentlich zugänglichen URL wie https://npm.example.com zu platzieren, wie in unserem Tutorial zum Nginx Proxy Manager beschrieben.

Nachdem du nun eine öffentliche URL für Portainer festgelegt hast, kannst du den exponierten Port 9443 entfernen. Gehe dazu zurück zum Terminal und wechsle in das Portainer-Verzeichnis.

$ cd ~/portainer

Öffne die Docker compose Datei zum Bearbeiten.

$ nano docker-compose.yaml

Entferne den Ports-Abschnitt, indem du ihn auskommentierst, wie unten gezeigt.

version: "3.3"
services:
    portainer:
      image: portainer/portainer-ce:latest
      container_name: portainer
      restart: always
      privileged: true
      volumes:
        - ./data:/data:Z
        - /var/run/docker.sock:/var/run/docker.sock:Z
      #ports:
      #  - 9443:9443
      networks:
        - npm-network

networks:
  npm-network:
    external: true

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Hier haben wir die Details des NPM-Netzwerks hinzugefügt, weil wir den Portainer-Container neu starten müssen.

Halte den Portainer-Container an.

$ docker-compose down --remove-orphans

Starte den Container erneut mit der aktualisierten Konfiguration.

$ docker-compose up -d

Schritt 6 – Einen Container mit einer App-Vorlage bereitstellen

Portainer bietet mehrere vordefinierte Vorlagen, um Anwendungen mit minimaler Konfiguration direkt zu starten.

Besuche den Bereich App-Vorlagen und wähle eine beliebige Vorlage aus. Gib ihr einen Namen und wähle das zu verwendende Netzwerk aus. Verwende den Abschnitt mit den erweiterten Optionen, um benutzerdefinierte Ports, Netzwerke und Volume Mounts einzurichten.

Klicke auf die Schaltfläche Container bereitstellen, um die Bereitstellung deiner Anwendung abzuschließen. Hier setzen wir den Redis-Container ein.

Schritt 7 – Verwalten von Containern

Lass uns einen bestehenden Container verwalten. Öffne die Containerseite und du wirst alle laufenden Container sehen.

Klicke auf den kürzlich erstellten hw-redis Container, um fortzufahren.

Oben siehst du eine Liste mit Aktionen, die du für einen laufenden Container durchführen kannst. Du kannst den Container anhalten und beenden. Mit der Option Neu erstellen kannst du den Container von Grund auf neu erstellen. Mit der Option Duplizieren/Bearbeiten kannst du einen weiteren identischen Container erstellen und die Einstellungen ändern, bevor du ihn startest.

Der Container-Status zeigt die Laufzeit, die IP-Adresse und andere Details über den Container an.

Die Option Logs zeigt die Ausgabe des Befehls docker logs an. Da die Ausgabe des Befehls nicht zwischengespeichert wird, wird der Befehl jedes Mal, wenn du die Seite aktualisierst, von vorne ausgeführt.

Die Option Inspect führt den Befehl docker inspect auf dem Container aus und zeigt seine Ausgabe an.

Die Option Stats zeigt dir die Nutzung des Containers in Echtzeit an.

Mit der Option Konsole kannst du die Container-Konsole starten. Du wirst nach dem Befehl und dem Systembenutzer gefragt, den du ausführen möchtest.

Drücke auf die Schaltfläche Verbinden, um die Konsole zu starten.

Die Option Attach führt den Befehl docker attach aus.

Auf der Seite mit den Containerdetails gibt es noch weitere Optionen. Du kannst ein Image erstellen, indem du einen bestehenden Container verwendest. Weitere Optionen sind das Ändern der Neustart-Richtlinie eines Containers und das Verbinden oder Trennen eines Netzwerks mit einem bestehenden Container.

Einen externen Container an Portainer anhängen

Wenn du einen Container außerhalb von Portainer erstellst, wird er in Portainer angezeigt, solange er auf demselben System erstellt wurde, auf dem Portainer läuft. Das ist möglich, weil Portainer über einen Websocket mit Docker verbunden ist.

Testen wir, indem wir den Hello World Docker Container starten.

$ docker run hello-world
Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
2db29710123e: Pull complete
Digest: sha256:10d7d58d5ebd2a652f4d93fdd86da8f265f5318c6a73cc5b6a9798ff6d2b2e67
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (amd64)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/

Überprüfe die Containerliste im Terminal. Wir verwenden das -a Flag, um die Liste aller Container, einschließlich der gestoppten, anzuzeigen. Du kannst den Namen des Containers als sad_williamson sehen.

$ docker ps -a
CONTAINER ID   IMAGE                             COMMAND                  CREATED         STATUS                     PORTS                                                                                  NAMES
5fa46b85d594   hello-world                       "/hello"                 3 minutes ago   Exited (0) 3 minutes ago                                                                                          sad_williamson
.....

Wenn du nun die Seite Portainer Containers aufrufst, wird der Hello World Container in der Liste mit demselben Namen als gestoppt angezeigt.

Fazit

Dies ist der Abschluss unseres Tutorials zur Installation und Nutzung von Portainer für die Docker-Verwaltung und den Nginx Proxy Manager. In einem der nächsten Tutorien werden wir uns mit der Erstellung von Docker-Images, der Erstellung von benutzerdefinierten Containern und der Verwendung von Portainer mit Docker Swarm beschäftigen. Ubnter anderem kann man auch Mastodon via Docker installieren. Wenn du Fragen hast, schreibe sie unten in die Kommentare.