One place for hosting & domains

      Fernzugriff auf GUI-Anwendungen mit Docker und Caddy unter Ubuntu 18.04


      Der Autor wählte den Free and Open Source Fund, um eine Spende im Rahmen des Programms Write for DOnations zu erhalten.

      Einführung

      Trotz der wachsenden Beliebtheit von Cloud-Diensten besteht nach wie vor die Notwendigkeit, native Anwendungen auszuführen.

      Durch die Verwendung von noVNC und TigerVNC können Sie native Anwendungen innerhalb eines Docker-Containers ausführen und über einen Webbrowser aus der Ferne auf sie zugreifen. Darüber hinaus können Sie Ihre Anwendung auf einem Server mit mehr Systemressourcen ausführen, als Ihnen vor Ort zur Verfügung stehen, was die Flexibilität bei der Ausführung großer Anwendungen steigern kann.

      In diesem Tutorial containerisieren Sie mit Docker Mozilla Thunderbird, einen E-Mail-Client. Anschließend sichern Sie sie Ihn und bieten Fernzugriff über den Caddy Webserver.

      Nach Abschluss können Sie von jedem Gerät aus mit einem Webbrowser auf Thunderbird zugreifen. Optional können Sie auch lokal auf die Dateien zugreifen, indem Sie WebDAV verwenden. Außerdem erhalten Sie ein völlig eigenständiges Docker-Image, das Sie überall ausführen können.

      Voraussetzungen

      Bevor Sie diesen Leitfaden beginnen, benötigen Sie Folgendes:

      Schritt 1 — Erstellen der supervisord-Konfiguration

      Da Ihr Server nun ausgeführt wird und Docker installiert ist, können Sie mit der Konfiguration des Containers Ihrer Anwendung beginnen. Da Ihr Container aus mehreren Komponenten besteht, müssen Sie einen Prozessmanager verwenden, um sie zu starten und zu überwachen. In diesem Fall verwenden Sie supervisord . supervisord ist ein in Python geschriebener Prozessmanager, der häufig zur Organisation komplexer Container verwendet wird.

      Erstellen und geben Sie zunächst ein Verzeichnis namens thunderbird für Ihren Container ein:

      • mkdir ~/thunderbird
      • cd ~/thunderbird

      Erstellen und öffnen Sie nun eine Datei namens supervisord.conf mit nano oder Ihrem bevorzugten Editor:

      Fügen Sie nun diesen ersten Code-Block in supervisord.conf ein, der die globalen Optionen für supervisord definiert:

      ~/thunderbird/supervisord.conf

      [supervisord]
      nodaemon=true
      pidfile=/tmp/supervisord.pid
      logfile=/dev/fd/1
      logfile_maxbytes=0
      

      In diesem Block konfigurieren Sie supervisord selbst. Sie müssen nodaemon auf true setzen, da es innerhalb eines Docker-Containers als Einstiegspunkt ausgeführt wird. Daher möchten Sie, dass es weiterhin im Vordergrund ausgeführt wird. Außerdem setzten Sie pidfile auf einen Pfad, auf den ein Nicht-root-Benutzer Zugriff hat (mehr dazu später), und logfile, auf stdout, damit Sie die Protokolle sehen können.

      Fügen Sie als Nächstes einen weiteren kleinen Code-Block zu supervisord.conf hinzu. Dieser Block startet TigerVNC, das ein kombinierter VNC/X11-Server ist:

      ~/thunderbird/supervisord.conf

      ...
      [program:x11]
      priority=0
      command=/usr/bin/Xtigervnc -desktop "Thunderbird" -localhost -rfbport 5900 -SecurityTypes None -AlwaysShared -AcceptKeyEvents -AcceptPointerEvents -AcceptSetDesktopSize -SendCutText -AcceptCutText :0
      autorestart=true
      stdout_logfile=/dev/fd/1
      stdout_logfile_maxbytes=0
      redirect_stderr=true
      

      In diesem Block richten Sie den X11-Server ein. X11 ist ein Display-Server-Protokoll, das die Ausführung von GUI-Anwendungen ermöglicht. Beachten Sie, dass es in Zukunft durch Wayland ersetzt werden wird, aber der Fernzugriff befindet sich noch in der Entwicklung.

      Für diesen Container verwenden Sie TigerVNC und seinen integrierten VNC-Server. Dies hat eine Reihe von Vorteilen gegenüber der Verwendung eines separaten X11- und VNC-Servers:

      • Schneller Reaktionszeit, da die GUI-Zeichnung direkt auf dem VNC-Server erfolgt und nicht in einem zwischengeschalteten Frambuffer (dem Speicher, der den Bildschirminhalt speichert).
      • Automatische Größenanpassung des Bildschirms, wodurch die Fernanwendung die Größe automatisch an den Client (in diesem Fall Ihr Webbrowser-Fenster) anpassen kann.

      Wenn Sie möchten, können Sie das Argument für die Option -desktop von Thunderbird auf etwas anderes Ihrer Wahl ändern. Der Server zeigt Ihre Wahl als Titel der Webseite an, die für den Zugriff auf Ihre Anwendung verwendet wird.

      Fügen wir nun einen dritten Code-Block zu supervisord.conf hinzu, um easy-novnc zu starten:

      ~/thunderbird/supervisord.conf

      ...
      [program:easy-novnc]
      priority=0
      command=/usr/local/bin/easy-novnc --addr :8080 --host localhost --port 5900 --no-url-password --novnc-params "resize=remote"
      autorestart=true
      stdout_logfile=/dev/fd/1
      stdout_logfile_maxbytes=0
      redirect_stderr=true
      

      In diesem Block richten Sie easy-novnc ein, einen eigenständigen Server, der einen Wrapper um noVNC bereitstellt. Dieser Server erfüllt zwei Rollen. Erstens stellt er eine einfache Verbindungsseite bereit, auf der Sie Optionen für die Verbindung konfigurieren und Standardoptionen festlegen können. Zweitens stellt er VNC über WebSocket als Proxy bereit, sodass der Zugriff über einen gewöhnlichen Webbrowser möglich ist.

      Normalerweise wird die Größenanpassung auf der Client-Seite vorgenommen (d. h. die Bildskalierung), aber Sie verwenden die Option resize=remote, um die Vorteile der Remote-Auflösungseinstellung von TigerVNC voll zu nutzen. Dies bietet auch eine geringere Latenz auf langsameren Geräten, wie z. B. Chromebooks niedrigerer Leistungsklassen:

      Anmerkung: Dieses Tutorial verwendet easy-novnc. Wenn Sie möchten, können Sie stattdessen websockify und einen separaten Webserver verwenden. Der Vorteil von easy-novnc besteht darin, dass der Speicherverbrauch und die Startzeit deutlich geringer sind und dass es in sich geschlossen ist. easy-novnc bietet außerdem eine sauberere Verbindungsseite als die Standardseite von noVNC und ermöglicht die Einstellung von Standardoptionen, die für diese Einrichtung hilfreich sind (wie resize=remote).

      Fügen Sie nun den folgenden Block zu Ihrer Konfiguration hinzu, um OpenBox, den Fenstermanager, zu starten:

      ~/thunderbird/supervisord.conf

      ...
      [program:openbox]
      priority=1
      command=/usr/bin/openbox
      environment=DISPLAY=:0
      autorestart=true
      stdout_logfile=/dev/fd/1
      stdout_logfile_maxbytes=0
      redirect_stderr=true
      

      In diesem Block richten Sie OpenBox ein, einen schlanken X11-Fenstermanager. Sie könnten diesen Schritt überspringen, aber ohne ihn hätten Sie keine Titellisten und könnten die Fenstergröße nicht ändern.

      Zum Schluss fügen wir den letzten Block zu supervisord.conf hinzu, wodurch die Hauptanwendung gestartet wird:

      ~/thunderbird/supervisord.conf

      ...
      [program:app]
      priority=1
      environment=DISPLAY=:0
      command=/usr/bin/thunderbird
      autorestart=true
      stdout_logfile=/dev/fd/1
      stdout_logfile_maxbytes=0
      redirect_stderr=true
      

      In diesem letzten Block setzen Sie priority auf 1, um sicherzustellen, dass Thunderbird nach TigerVNC gestartet wird. Ansonsten würde es auf eine Race-Bedingung treffen und womöglich nicht starten. Wir setzen auch autorestart=true, um die Anwendung automatisch wieder zu öffnen, wenn sie versehentlich geschlossen wird. Die Umgebungsvariable DISPLAY weist die Anwendung zur Anzeige auf dem zuvor erstellten VNC-Server an.

      So wird Ihre fertiggestellte supervisord.conf aussehen:

      ~/thunderbird/supervisord.conf

      [supervisord]
      nodaemon=true
      pidfile=/tmp/supervisord.pid
      logfile=/dev/fd/1
      logfile_maxbytes=0
      
      [program:x11]
      priority=0
      command=/usr/bin/Xtigervnc -desktop "Thunderbird" -localhost -rfbport 5900 -SecurityTypes None -AlwaysShared -AcceptKeyEvents -AcceptPointerEvents -AcceptSetDesktopSize -SendCutText -AcceptCutText :0
      autorestart=true
      stdout_logfile=/dev/fd/1
      stdout_logfile_maxbytes=0
      redirect_stderr=true
      
      [program:easy-novnc]
      priority=0
      command=/usr/local/bin/easy-novnc --addr :8080 --host localhost --port 5900 --no-url-password --novnc-params "resize=remote"
      autorestart=true
      stdout_logfile=/dev/fd/1
      stdout_logfile_maxbytes=0
      redirect_stderr=true
      
      [program:openbox]
      priority=1
      command=/usr/bin/openbox
      environment=DISPLAY=:0
      autorestart=true
      stdout_logfile=/dev/fd/1
      stdout_logfile_maxbytes=0
      redirect_stderr=true
      
      [program:app]
      priority=1
      environment=DISPLAY=:0
      command=/usr/bin/thunderbird
      autorestart=true
      stdout_logfile=/dev/fd/1
      stdout_logfile_maxbytes=0
      redirect_stderr=true
      

      Wenn Sie eine andere Anwendung containerisieren möchten, ersetzen Sie /usr/bin/thunderbird durch den Pfad zur ausführbaren Datei Ihrer Anwendung. Andernfalls sind Sie nun bereit, das Hauptmenü Ihrer GUI zu konfigurieren.

      Schritt 2 — Einrichten des OpenBox-Menüs

      Nachdem Ihr Prozessmanager konfiguriert ist, richten wir nun das OpenBox-Menü ein. Dieses Menü ermöglicht es uns, Anwendungen innerhalb des Containers zu starten. Bei Bedarf werden wir auch einen Terminal- und Prozessmonitor für das Debugging einschließen.

      Verwenden Sie innerhalb des Verzeichnisses Ihrer Anwendung nano oder Ihren bevorzugten Texteditor, um eine neue Datei namens menu.xml zu erstellen und zu öffnen:

      • nano ~/thunderbird/menu.xml

      Fügen Sie nun den folgenden Code zu menu.xml hinzu:

      ~/thunderbird/menu.xml

      <?xml version="1.0" encoding="utf-8"?>
      <openbox_menu xmlns="http://openbox.org/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://openbox.org/ file:///usr/share/openbox/menu.xsd">
          <menu id="root-menu" label="Openbox 3">
              <item label="Thunderbird">
                  <action name="Execute">
                      <execute>/usr/bin/thunderbird</execute>
                  </action>
              </item>
              <item label="Terminal">
                  <action name="Execute">
                      <execute>/usr/bin/x-terminal-emulator</execute>
                  </action>
              </item>
              <item label="Htop">
                  <action name="Execute">
                      <execute>/usr/bin/x-terminal-emulator -e htop</execute>
                  </action>
              </item>
          </menu>
      </openbox_menu>
      

      Diese XML-Datei enthält die Menüeinträge, die angezeigt werden, wenn Sie mit der rechten Maustaste auf den Desktop klicken. Jedes Element besteht aus einem Label und einer Aktion.

      Wenn Sie eine andere Anwendung containerisieren möchten, ersetzen Sie /usr/bin/thunderbird durch den Pfad zur ausführbaren Datei Ihrer Anwendung und ändern Sie das Label des Elements.

      Schritt 3 — Erstellen der Dockerfile

      Nachdem OpenBox konfiguriert ist, erstellen Sie nun die Dockerfile, die alles miteinander verbindet.

      Erstellen Sie eine Dockerfile im Verzeichnis Ihres Containers:

      • nano ~/thunderbird/Dockerfile

      Um zu beginnen, fügen wir etwas Code hinzu, um easy-novnc zu erstellen:

      ~/thunderbird/Dockerfile

      FROM golang:1.14-buster AS easy-novnc-build
      WORKDIR /src
      RUN go mod init build && 
          go get github.com/geek1011/easy-novnc@v1.1.0 && 
          go build -o /bin/easy-novnc github.com/geek1011/easy-novnc
      

      In der ersten Stufe erstellen Sie easy-novnc. Dies wird aus Gründen der Einfachheit und Platzersparnis in einem separaten Schritt durchgeführt – Sie benötigen nicht die gesamte Go-Toolchain in Ihrem endgültigen Image. Beachten Sie das @v1.1.0 im Befehl „build“. Dadurch wird sichergestellt, dass das Ergebnis deterministisch ist, was wichtig ist, weil Docker das Ergebnis jedes einzelnen Schritts zwischenspeichert. Wenn Sie keine explizite Version angegeben hätten, würde Docker zum Zeitpunkt der ersten Erstellung des Images auf die neueste Version von easy-novnc verweisen. Darüber hinaus möchten Sie sicherstellen, dass Sie eine bestimmte Version von easy-novnc herunterladen, für den Fall, dass an der CLI-Schnittstelle gravierende Änderungen vorgenommen werden.

      Erstellen wir nun die zweite Stufe, die zum endgültigen Image wird. Hier verwenden Sie Debian 10 (buster) als Basis-Image. Beachten Sie, dass dieses, da es in einem Container ausgeführt wird, unabhängig von der auf Ihrem Server laufenden Distribution funktioniert.

      Fügen Sie als Nächstes den folgenden Block zu Ihrer Dockerfile hinzu:

      ~/thunderbird/Dockerfile

      ...
      FROM debian:buster
      RUN apt-get update -y && 
          apt-get install -y --no-install-recommends openbox tigervnc-standalone-server supervisor gosu && 
          rm -rf /var/lib/apt/lists && 
          mkdir -p /usr/share/desktop-directories
      

      In dieser Anweisung installieren Sie Debian 10 als Ihr Basis-Image und installieren dann das absolute Minimum, das erforderlich ist, um GUI-Anwendungen in Ihrem Container auszuführen. Beachten Sie, dass Sie apt-get update als Teil der gleichen Anweisung ausführen, um Zwischenspeicherungsprobleme von Docker zu verhindern. Um Speicherplatz zu sparen, entfernen Sie auch die danach heruntergeladenen Paketlisten (die zwischengespeicherten Pakete selbst werden standardmäßig entfernt). Sie erstellen auch /usr/share/desktop-directories, da einige Anwendungen von dem vorhandenen Verzeichnis abhängen.

      Fügen wir einen weiteren kleinen Code-Block hinzu:

      ~/thunderbird/Dockerfile

      ...
      RUN apt-get update -y && 
          apt-get install -y --no-install-recommends lxterminal nano wget openssh-client rsync ca-certificates xdg-utils htop tar xzip gzip bzip2 zip unzip && 
          rm -rf /var/lib/apt/lists
      

      In dieser Anweisung installieren Sie einige nützliche Allzweck-Dienstprogramme und -Pakete. Von besonderem Interesse sind hier xdg-utils (das die Basisbefehle bereitstellt, die von Desktop-Anwendungen unter Linux verwendet werden) und ca-certificates (das die Stammzertifikate installiert, um uns den Zugriff auf HTTPS-Seiten zu ermöglichen).

      Nun können wir die Anweisungen für die Hauptanwendung hinzufügen:

      ~/thunderbird/Dockerfile

      ...
      RUN apt-get update -y && 
          apt-get install -y --no-install-recommends thunderbird && 
          rm -rf /var/lib/apt/lists
      

      Wie zuvor installieren wir hier die Anwendung. Wenn Sie eine andere Anwendung containerisieren möchten, können Sie diese Befehle durch die Befehle ersetzen, die zum Installieren Ihrer spezifischen Anwendung erforderlich sind. Einige Anwendungen erfordern etwas mehr Arbeit, um in Docker ausgeführt zu werden. Wenn Sie beispielsweise eine App installieren, die Chrome, Chromium oder QtWebEngine verwendet, müssen Sie das Befehlszeilenargument --no-sandbox verwenden, da es von Docker nicht unterstützt wird.

      Als Nächstes fügen wir die Anweisungen zum Hinzufügen der letzten wenigen Dateien zum Container hinzu:

      ~/thunderbird/Dockerfile

      ...
      COPY --from=easy-novnc-build /bin/easy-novnc /usr/local/bin/
      COPY menu.xml /etc/xdg/openbox/
      COPY supervisord.conf /etc/
      EXPOSE 8080
      

      Hier fügen Sie dem Image die zuvor erstellten Konfigurationsdateien hinzu, und kopieren die Binärdatei easy-novnc aus der ersten Stufe.

      Dieser nächste Code-Block erstellt das Datenverzeichnis und fügt einen dedizierten Benutzer für Ihre App hinzu. Dies ist wichtig, da einige Anwendungen sich weigern als root ausgeführt zu werden. Es ist auch eine bewährte Praxis, Anwendungen nicht als root auszuführen, auch nicht in einem Container.

      ~/thunderbird/Dockerfile

      ...
      RUN groupadd --gid 1000 app && 
          useradd --home-dir /data --shell /bin/bash --uid 1000 --gid 1000 app && 
          mkdir -p /data
      VOLUME /data
      

      Um eine konsistente UID/GID für die Dateien zu gewährleisten, setzen Sie beide ausdrücklich auf 1000. Außerdem installieren Sie ein Volumen in das Datenverzeichnis, um sicherzustellen, dass es zwischen den Neustarts erhalten bleibt.

      Zum Schluss fügen wir noch die Anweisungen zum Starten von allem hinzu:

      ~/thunderbird/Dockerfile

      ...
      CMD ["sh", "-c", "chown app:app /data /dev/stdout && exec gosu app supervisord"]
      

      Wenn sie den Standardbefehl auf supervisord setzen,wir der Manager die für die Ausführung Ihrer Anwendung erforderlichen Prozesse starten. In diesem Fall verwenden Sie CMD anstatt ENTRYPOINT. In den meisten Fällen würde es keinen Unterschied machen, aber die Verwendung von CMD ist für diesen Zweck aus einigen Gründen besser geeignet. Erstens nimmt supervisord keine Argumente entgegen, die für uns relevant wären, und wenn Sie dem Container Argumente hinzufügen, ersetzten diese CMD und werden an ENTRYPOINT angehängt. Zweitens ermöglicht uns die Verwendung von CMD, bei der Übergabe von Argumenten an den Container einen völlig anderen Befehl (der von /bin/sh -c ausgeführt wird), anzugeben, was das Debuggen erleichtert.

      Und schließlich müssen Sie vor dem Starten von supervisord chown als root ausführen, um Berechtigungsprobleme auf dem Datenvolumen zu verhindern und den untergeordneten Prozessen das Öffnen von stdout zu ermöglichen. Das bedeutet auch, dass sie gosu anstelle der Anweisung USER verwenden müssen, um den Benutzer zu wechseln.

      So wird Ihre fertiggestellte Dockerfile aussehen:

      ~/thunderbird/Dockerfile

      FROM golang:1.14-buster AS easy-novnc-build
      WORKDIR /src
      RUN go mod init build && 
          go get github.com/geek1011/easy-novnc@v1.1.0 && 
          go build -o /bin/easy-novnc github.com/geek1011/easy-novnc
      
      FROM debian:buster
      
      RUN apt-get update -y && 
          apt-get install -y --no-install-recommends openbox tigervnc-standalone-server supervisor gosu && 
          rm -rf /var/lib/apt/lists && 
          mkdir -p /usr/share/desktop-directories
      
      RUN apt-get update -y && 
          apt-get install -y --no-install-recommends lxterminal nano wget openssh-client rsync ca-certificates xdg-utils htop tar xzip gzip bzip2 zip unzip && 
          rm -rf /var/lib/apt/lists
      
      RUN apt-get update -y && 
          apt-get install -y --no-install-recommends thunderbird && 
          rm -rf /var/lib/apt/lists
      
      COPY --from=easy-novnc-build /bin/easy-novnc /usr/local/bin/
      COPY menu.xml /etc/xdg/openbox/
      COPY supervisord.conf /etc/
      EXPOSE 8080
      
      RUN groupadd --gid 1000 app && 
          useradd --home-dir /data --shell /bin/bash --uid 1000 --gid 1000 app && 
          mkdir -p /data
      VOLUME /data
      
      CMD ["sh", "-c", "chown app:app /data /dev/stdout && exec gosu app supervisord"]
      

      Speichern und schließen Sie Ihre Dockerfile. Nun sind wir bereit, unseren Container zu erstellen und auszuführen und dann auf Thunderbird — eine GUI-Anwendung — zugreifen.

      Schritt 4 — Erstellen und Ausführen des Containers

      Der nächste Schritt besteht darin, Ihren Container zu erstellen und so einzustellen, dass er beim Starten ausgeführt wird. Sie werden auch ein Volumen einrichten, um die Anwendungsdaten zwischen Neustarts und Aktualisierungen zu erhalten.

      Erstellen Sie zuerst Ihren Container. Stellen Sie sicher, dass diese Befehle im Verzeichnis ~/thunderbird ausgeführt werden:

      • docker build -t thunderbird .

      Erstellen Sie nun ein neues Netzwerk, das von den Containern der Anwendung gemeinsam genutzt wird:

      • docker network create thunderbird-net

      Erstellen Sie dann ein Volume zum Speichern der Anwendungsdaten:

      • docker volume create thunderbird-data

      Führen Sie es abschließen aus und stellen Sie es so ein, dass es automatisch neu startet:

      • docker run --detach --restart=always --volume=thunderbird-data:/data --net=thunderbird-net --name=thunderbird-app thunderbird

      Beachten Sie, dass Sie, wenn Sie möchten, die thunderbird-app nach der Option --name durch einen anderen Namen ersetzen können. Was auch immer Sie gewählt haben, Ihre Anwendung ist nun containerisiert und wird ausgeführt. Verwenden wir nun den Caddy Webserver, um sie zu sichern und eine Fernverbindung zu ihr aufzubauen.

      Schritt 5 — Einrichten von Caddy

      In diesem Schritt richten Sie den Caddy-Webserver so ein, dass er Authentifizierung und, optional, Fernzugriff auf Ihre Dateien über WebDAV bietet. Der Einfachheit halber und damit Sie ihn mit Ihrem vorhandenen Reverse-Proxy verwenden können, werden Sie ihn in einem anderen Container ausführen.

      Erstellen Sie ein neues Verzeichnis und gehen Sie dann in dieses:

      Erstellen Sie nun mit nano oder Ihrem bevorzugten Editor eine neue Dockerfile:

      Fügen Sie dann die folgenden Anweisungen hinzu:

      ~/caddy/Dockerfile

      FROM golang:1.14-buster AS caddy-build
      WORKDIR /src
      RUN echo 'module caddy' > go.mod && 
          echo 'require github.com/caddyserver/caddy/v2 v2.0.0' >> go.mod && 
          echo 'require github.com/mholt/caddy-webdav v0.0.0-20200523051447-bc5d19941ac3' >> go.mod
      RUN echo 'package main' > caddy.go && 
          echo 'import caddycmd "github.com/caddyserver/caddy/v2/cmd"' >> caddy.go && 
          echo 'import _ "github.com/caddyserver/caddy/v2/modules/standard"' >> caddy.go && 
          echo 'import _ "github.com/mholt/caddy-webdav"' >> caddy.go && 
          echo 'func main() { caddycmd.Main() }' >> caddy.go
      RUN go build -o /bin/caddy .
      
      FROM debian:buster
      
      RUN apt-get update -y && 
          apt-get install -y --no-install-recommends gosu && 
          rm -rf /var/lib/apt/lists
      
      COPY --from=caddy-build /bin/caddy /usr/local/bin/
      COPY Caddyfile /etc/
      EXPOSE 8080
      
      RUN groupadd --gid 1000 app && 
          useradd --home-dir /data --shell /bin/bash --uid 1000 --gid 1000 app && 
          mkdir -p /data
      VOLUME /data
      
      WORKDIR /data
      CMD ["sh", "-c", "chown app:app /data && exec gosu app /usr/local/bin/caddy run -adapter caddyfile -config /etc/Caddyfile"]
      

      Diese Dockerfile erstellt Caddy mit dem aktivierten WebDAV-Plugin und startet ihn dann auf Port 8080 mit der Caddyfile unter /etc/Caddyfile. Speichern und schließen Sie die Datei.

      Als Nächstes konfigurieren Sie den Caddy-Webserver. Erstellen Sie eine Datei namens Caddyfile im gerade erstellten Verzeichnis:

      Fügen Sie nun den folgenden Code-Block zu Ihrer Caddyfile hinzu:

      ~/caddy/Caddyfile

      {
          order webdav last
      }
      :8080 {
          log
          root * /data
          reverse_proxy thunderbird-app:8080
      
          handle /files/* {
              uri strip_prefix /files
              file_server browse
          }
          redir /files /files/
      
          handle /webdav/* {
              uri strip_prefix /webdav
              webdav
          }
          redir /webdav /webdav/
      
          basicauth /* {
              {env.APP_USERNAME} {env.APP_PASSWORD_HASH}
          }
      }
      

      Diese Caddyfile verweist das Stammverzeichnis an den in Schritt 4 erstellten Container thunderbird-app (Docker löst ihn in die richtige IP auf). Es wird auch einen schreibgeschützten webbasierten Dateibrowser auf /files bedienen und einen WebDAV-Server auf /webdav ausführen, den Sie lokal installieren können, um auf Ihre Dateien zugreifen zu können. Der Benutzername und das Passwort werden aus den Umgebungsvariablen APP_USERNAME und APP_PASSWORD_HASH gelesen.

      Erstellen Sie nun den Container:

      • docker build -t thunderbird-caddy .

      Caddy v.2 erfordert, dass Sie Ihr gewünschtes Passwort hashen. Führen Sie den folgenden Befehl aus und denken Sie daran, mypass durch ein starkes Passwort Ihrer Wahl zu ersetzen:

      • docker run --rm -it thunderbird-caddy caddy hash-password -plaintext 'mypass'

      Dieser Befehl gibt eine Zeichenfolge aus. Kopieren Sie diese in die Zwischenablage, um die Ausführung des nächsten Befehls vorzubereiten.

      Jetzt sind Sie bereit, den Container auszuführen. Achten Sie darauf, myuser durch einen Benutzernamen Ihrer Wahl zu ersetzen und ersetzen Sie mypass-hash durch die Ausgabe des im vorherigen Schritt ausgeführten Befehls. Sie können auch den Port (hier 8080) ändern, um über einen anderen Port auf Ihren Server zuzugreifen:

      • docker run --detach --restart=always --volume=thunderbird-data:/data --net=thunderbird-net --name=thunderbird-web --env=APP_USERNAME="myuser" --env=APP_PASSWORD_HASH="mypass-hash" --publish=8080:8080 thunderbird-caddy

      Wir sind nun bereit, auf unsere Anwendung zugreifen und sie zu testen.

      Schritt 6 — Testen und Verwalten der Anwendung

      Greifen wir nun auf die Anwendung zu und stellen sicher, dass sie funktioniert.

      Öffnen Sie zunächst http://your_server_ip:8080 in einem Webbrowser, melden Sie sich mit den zuvor gewählten Anmeldeinformationen an und klicken Sie auf Connect.

      Verbindungsseite von NoVNC

      Sie sollten nun in der Lage sein, mit der Anwendung zu interagieren und sie sollte sich automatisch an die Größe Ihres Browserfensters anpassen.

      Hauptmenü von Thunderbird

      Wenn Sie mit der rechten Maustaste auf den schwarzen Desktop klicken, sollten Sie ein Menü sehen, das Ihnen den Zugriff auf ein Terminal ermöglicht. Wenn Sie mit der mittleren Maustaste klicken, sollten Sie eine Liste von Fenstern sehen.

      NoVNC Klicken mit der rechten Maustaste

      Öffnen Sie nun http://your_server_ip:8080/files/ in einem Webbrowser. Sie sollten in der Lage sein, auf Ihre Dateien zugreifen.

      NoVNC Dateizugriff webdav

      Optional können Sie versuchen, http://your_server_ip:8080/webdav/ in einem WebDAV-Client zu installieren. Sie sollten in der Lage sein, direkt auf Ihre Dateien zuzugreifen und sie zu ändern. Wenn Sie die Option Map network drive (Netzlaufwerk zuordnen) im Windows Explorer verwenden, müssen Sie entweder einen Reverse-Proxy verwenden, um HTTPS hinzuzufügen oder HKLMSYSTEMCurrentControlSetServicesWebClientParametersBasicAuthLevel auf DWORD:2 setzen.

      In beiden Fällen ist Ihre native GUI-Anwendung nun für die Fernverwendung bereit.

      Zusammenfassung

      Sie haben nun erfolgreich einen Docker-Container für Thunderbird eingerichtet und dann mit Caddy den Zugriff darauf über einen Webbrowser konfiguriert. Sollten Sie Ihre App jemals aktualisieren müssen, halten Sie die Container an, führen Sie docker rm thunderbird-app thunderbird-web aus, erstellen Sie die Images neu und führen Sie dann die Befehle docker run aus den vorherigen Schritten oben erneut aus. Ihre Daten bleiben weiterhin erhalten, da sie in einem Volumen gespeichert sind.

      Wenn Sie mehr über grundlegende Docker-Befehle erfahren möchten, können Sie dieses Tutorial oder dieses Cheatsheet lesen. Für den längerfristigen Gebrauch sollten Sie auch in Betracht ziehen, HTTPS (hierfür ist eine Domäne erforderlich) für zusätzliche Sicherheit zu aktivieren.

      Wenn Sie mehr als eine Anwendung bereitstellen, möchten Sie möglicherweise Docker Compose oder Kubernetes verwenden, anstatt jeden Container manuell zu starten. Denken Sie daran, dass dieses Tutorial als Grundlage für die Ausführung jeder anderen Linux-Anwendung auf Ihrem Server dienen kann, einschließlich:

      • Wine, eine Kompatibilitätsschicht für die Ausführung von Windows-Anwendungen unter Linux.
      • GIMP, ein Open-Source-Bildbearbeitungsprogramm.
      • Cutter, eine Open-Source-Plattform für Reverse Engineering.

      Diese letzte Option zeigt das große Potenzial der Containerisierung und des Fernzugriffs auf GUI-Anwendungen. Mit dieser Einrichtung können Sie nun einen Server mit wesentlich mehr Rechenleistung, als Sie möglicherweise vor Ort haben, verwenden, um ressourcenintensive Tools wie Cutter auszuführen.



      Source link

      Fernzugriff auf GUI-Anwendungen mit Docker und Caddy unter Ubuntu 20.04


      Der Autor wählte den Free and Open Source Fund, um eine Spende im Rahmen des Programms Write for DOnations zu erhalten.

      Einführung

      Trotz der wachsenden Beliebtheit von Cloud-Diensten besteht nach wie vor die Notwendigkeit, native Anwendungen auszuführen.

      Durch die Verwendung von noVNC und TigerVNC können Sie native Anwendungen innerhalb eines Docker-Containers ausführen und über einen Webbrowser aus der Ferne auf sie zugreifen. Darüber hinaus können Sie Ihre Anwendung auf einem Server mit mehr Systemressourcen ausführen als Ihnen vor Ort zur Verfügung stehen, was die Flexibilität bei der Ausführung großer Anwendungen steigern kann.

      In diesem Tutorial containerisieren Sie mit Docker Mozilla Thunderbird, einen E-Mail-Client. Anschließend sichern Sie sie Ihn und bieten Fernzugriff über den Caddy Webserver.

      Nach Abschluss können Sie von jedem Gerät aus mit einem Webbrowser auf Thunderbird zugreifen. Optional können Sie auch lokal auf die Dateien zugreifen, indem Sie WebDAV verwenden. Außerdem erhalten Sie ein völlig eigenständiges Docker-Image, das Sie überall ausführen können.

      Voraussetzungen

      Bevor Sie diesen Leitfaden beginnen, benötigen Sie Folgendes:

      Schritt 1 — Erstellen der supervisord-Konfiguration

      Da Ihr Server nun ausgeführt wird und Docker installiert ist, können Sie mit der Konfiguration des Containers Ihrer Anwendung beginnen. Da Ihr Container aus mehreren Komponenten besteht, müssen Sie einen Prozessmanager verwenden, um sie zu starten und zu überwachen. In diesem Fall verwenden Sie supervisord. supervisord ist ein in Python geschriebener Prozessmanager, der häufig zur Organisation komplexer Container verwendet wird.

      Erstellen und geben Sie zunächst ein Verzeichnis namens thunderbird für Ihren Container ein:

      • mkdir ~/thunderbird
      • cd ~/thunderbird

      Erstellen und öffnen Sie nun eine Datei namens supervisord.conf mit nano oder Ihrem bevorzugten Editor:

      • nano ~/thunderbird/supervisord.conf

      Fügen Sie nun diesen ersten Code-Block in supervisord.conf ein, der die globalen Optionen für supervisord definiert:

      ~/thunderbird/supervisord.conf

      [supervisord]
      nodaemon=true
      pidfile=/tmp/supervisord.pid
      logfile=/dev/fd/1
      logfile_maxbytes=0
      

      In diesem Block konfigurieren Sie supervisord selbst. Sie müssen nodaemon auf true setzen, da es innerhalb eines Docker-Containers als Einstiegspunkt ausgeführt wird. Daher möchten Sie, dass es weiterhin im Vordergrund ausgeführt wird. Außerdem setzen Sie pidfile auf einen Pfad, auf den ein Nicht-root-Benutzer Zugriff hat (mehr dazu später), und logfile, auf stdout, damit Sie die Protokolle sehen können.

      Fügen Sie als Nächstes einen weiteren kleinen Code-Block zu supervisord.conf hinzu. Dieser Block startet TigerVNC, das ein kombinierter VNC/X11-Server ist:

      ~/thunderbird/supervisord.conf

      ...
      [program:x11]
      priority=0
      command=/usr/bin/Xtigervnc -desktop "Thunderbird" -localhost -rfbport 5900 -SecurityTypes None -AlwaysShared -AcceptKeyEvents -AcceptPointerEvents -AcceptSetDesktopSize -SendCutText -AcceptCutText :0
      autorestart=true
      stdout_logfile=/dev/fd/1
      stdout_logfile_maxbytes=0
      redirect_stderr=true
      

      In diesem Block richten Sie den X11-Server ein. X11 ist ein Display-Server-Protokoll, das die Ausführung von GUI-Anwendungen ermöglicht. Beachten Sie, dass es in Zukunft durch Wayland ersetzt werden wird, aber der Fernzugriff befindet sich noch in der Entwicklung.

      Für diesen Container verwenden Sie TigerVNC und seinen integrierten VNC-Server. Dies hat eine Reihe von Vorteilen gegenüber der Verwendung eines separaten X11- und VNC-Servers :

      • Schnellere Reaktionszeit, da die GUI-Zeichnung direkt auf dem VNC-Server erfolgt und nicht in einem zwischengeschalteten Framebuffer (dem Speicher, der den Bildschirminhalt speichert).
      • Automatische Größenanpassung des Bildschirms, wodurch die Fernanwendung die Größe automatisch an den Client (in diesem Fall Ihr Webbrowser-Fenster) anpassen kann.

      Wenn Sie möchten, können Sie das Argument für die Option -desktop von Thunderbird auf etwas anderes Ihrer Wahl ändern. Der Server zeigt Ihre Wahl als Titel der Webseite an, die für den Zugriff auf Ihre Anwendung verwendet wird.

      Fügen wir nun einen dritten Code-Block zu supervisord.conf hinzu, um easy-novnc zu starten:

      ~/thunderbird/supervisord.conf

      ...
      [program:easy-novnc]
      priority=0
      command=/usr/local/bin/easy-novnc --addr :8080 --host localhost --port 5900 --no-url-password --novnc-params "resize=remote"
      autorestart=true
      stdout_logfile=/dev/fd/1
      stdout_logfile_maxbytes=0
      redirect_stderr=true
      

      In diesem Block richten Sie easy-novnc ein, einen eigenständigen Server, der einen Wrapper um noVNC bereitstellt. Dieser Server erfüllt zwei Rollen. Erstens stellt er eine einfache Verbindungsseite bereit, auf der Sie Optionen für die Verbindung konfigurieren und Standardoptionen festlegen können. Zweitens stellt er VNC über WebSocket als Proxy bereit, sodass der Zugriff über einen gewöhnlichen Webbrowser möglich ist.

      Normalerweise wird die Größenanpassung auf der Client-Seite vorgenommen (d. h. die Bildskalierung), aber Sie verwenden die Option resize=remote, um die Vorteile der Remote-Auflösungseinstellung von TigerVNC voll zu nutzen. Dies bietet auch eine geringere Latenz auf langsameren Geräten, wie z. B. Chromebooks niedrigerer Leistungsklassen:

      Anmerkung: Dieses Tutorial verwendet easy-novnc. Wenn Sie möchten, können Sie stattdessen websockify und einen separaten Webserver verwenden. Der Vorteil von easy-novnc besteht darin, dass der Speicherverbrauch und die Startzeit deutlich geringer sind und dass es in sich geschlossen ist. easy-novnc bietet außerdem eine sauberere Verbindungsseite als die Standardseite von noVNC und ermöglicht die Einstellung von Standardoptionen, die für diese Einrichtung hilfreich sind (wie resize=remote).

      Fügen Sie nun den folgenden Block zu Ihrer Konfiguration hinzu, um OpenBox, den Fenstermanager, zu starten:

      ~/thunderbird/supervisord.conf

      ...
      [program:openbox]
      priority=1
      command=/usr/bin/openbox
      environment=DISPLAY=:0
      autorestart=true
      stdout_logfile=/dev/fd/1
      stdout_logfile_maxbytes=0
      redirect_stderr=true
      

      In diesem Block richten Sie OpenBox ein, einen schlanken X11-Fenstermanager. Sie könnten diesen Schritt überspringen, aber ohne ihn hätten Sie keine Titellisten und könnten die Fenstergröße nicht ändern.

      Zum Schluss fügen wir den letzten Block zu supervisord.conf hinzu, wodurch die Hauptanwendung gestartet wird:

      ~/thunderbird/supervisord.conf

      ...
      [program:app]
      priority=1
      environment=DISPLAY=:0
      command=/usr/bin/thunderbird
      autorestart=true
      stdout_logfile=/dev/fd/1
      stdout_logfile_maxbytes=0
      redirect_stderr=true
      

      In diesem letzten Block setzen Sie priority auf 1, um sicherzustellen, dass Thunderbird nach TigerVNC gestartet wird. Ansonsten würde es auf eine Race-Bedingung treffen und womöglich nicht starten. Wir setzen auch autorestart=true, um die Anwendung automatisch wieder zu öffnen, wenn sie versehentlich geschlossen wird. Die Umgebungsvariable DISPLAY weist die Anwendung zur Anzeige auf dem zuvor erstellten VNC-Server an.

      So wird Ihre fertiggestellte supervisord.conf aussehen:

      ~/thunderbird/supervisord.conf

      [supervisord]
      nodaemon=true
      pidfile=/tmp/supervisord.pid
      logfile=/dev/fd/1
      logfile_maxbytes=0
      
      [program:x11]
      priority=0
      command=/usr/bin/Xtigervnc -desktop "Thunderbird" -localhost -rfbport 5900 -SecurityTypes None -AlwaysShared -AcceptKeyEvents -AcceptPointerEvents -AcceptSetDesktopSize -SendCutText -AcceptCutText :0
      autorestart=true
      stdout_logfile=/dev/fd/1
      stdout_logfile_maxbytes=0
      redirect_stderr=true
      
      [program:easy-novnc]
      priority=0
      command=/usr/local/bin/easy-novnc --addr :8080 --host localhost --port 5900 --no-url-password --novnc-params "resize=remote"
      autorestart=true
      stdout_logfile=/dev/fd/1
      stdout_logfile_maxbytes=0
      redirect_stderr=true
      
      [program:openbox]
      priority=1
      command=/usr/bin/openbox
      environment=DISPLAY=:0
      autorestart=true
      stdout_logfile=/dev/fd/1
      stdout_logfile_maxbytes=0
      redirect_stderr=true
      
      [program:app]
      priority=1
      environment=DISPLAY=:0
      command=/usr/bin/thunderbird
      autorestart=true
      stdout_logfile=/dev/fd/1
      stdout_logfile_maxbytes=0
      redirect_stderr=true
      

      Wenn Sie eine andere Anwendung containerisieren möchten, ersetzen Sie /usr/bin/thunderbird durch den Pfad zur ausführbaren Datei Ihrer Anwendung. Andernfalls sind Sie nun bereit, das Hauptmenü Ihrer GUI zu konfigurieren.

      Schritt 2 — Einrichten des OpenBox-Menüs

      Nachdem Ihr Prozessmanager konfiguriert ist, richten wir nun das OpenBox-Menü ein. Dieses Menü ermöglicht es uns, Anwendungen innerhalb des Containers zu starten. Bei Bedarf werden wir auch einen Terminal- und Prozessmonitor für das Debugging einschließen.

      Verwenden Sie innerhalb des Verzeichnisses Ihrer Anwendung nano oder Ihren bevorzugten Texteditor, um eine neue Datei namens menu.xml zu erstellen und zu öffnen:

      • nano ~/thunderbird/menu.xml

      Fügen Sie nun den folgenden Code zu menu.xml hinzu:

      ~/thunderbird/menu.xml

      <?xml version="1.0" encoding="utf-8"?>
      <openbox_menu xmlns="http://openbox.org/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://openbox.org/ file:///usr/share/openbox/menu.xsd">
          <menu id="root-menu" label="Openbox 3">
              <item label="Thunderbird">
                  <action name="Execute">
                      <execute>/usr/bin/thunderbird</execute>
                  </action>
              </item>
              <item label="Terminal">
                  <action name="Execute">
                      <execute>/usr/bin/x-terminal-emulator</execute>
                  </action>
              </item>
              <item label="Htop">
                  <action name="Execute">
                      <execute>/usr/bin/x-terminal-emulator -e htop</execute>
                  </action>
              </item>
          </menu>
      </openbox_menu>
      

      Diese XML-Datei enthält die Menüeinträge, die angezeigt werden, wenn Sie mit der rechten Maustaste auf den Desktop klicken. Jedes Element besteht aus einem Label und einer Aktion.

      Wenn Sie eine andere Anwendung containerisieren möchten, ersetzen Sie /usr/bin/thunderbird durch den Pfad zur ausführbaren Datei Ihrer Anwendung und ändern Sie das Label des Elements.

      Schritt 3 — Erstellen der Dockerfile

      Nachdem OpenBox konfiguriert ist, erstellen Sie nun die Dockerfile, die alles miteinander verbindet.

      Erstellen Sie eine Dockerfile im Verzeichnis Ihres Containers:

      • nano ~/thunderbird/Dockerfile

      Um zu beginnen, fügen wir etwas Code hinzu, um easy-novnc zu erstellen:

      ~/thunderbird/Dockerfile

      FROM golang:1.14-buster AS easy-novnc-build
      WORKDIR /src
      RUN go mod init build && 
          go get github.com/geek1011/easy-novnc@v1.1.0 && 
          go build -o /bin/easy-novnc github.com/geek1011/easy-novnc
      

      In der ersten Stufe erstellen Sie easy-novnc. Dies wird aus Gründen der Einfachheit und Platzersparnis in einem separaten Schritt durchgeführt – Sie benötigen nicht die gesamte Go-Toolchain in Ihrem endgültigen Image. Beachten Sie das @v1.1.0 im Befehl „build“. Dadurch wird sichergestellt, dass das Ergebnis deterministisch ist, was wichtig ist, weil Docker das Ergebnis jedes einzelnen Schritts zwischenspeichert. Wenn Sie keine explizite Version angegeben hätten, würde Docker zum Zeitpunkt der ersten Erstellung des Images auf die neueste Version von easy-novnc verweisen. Darüber hinaus möchten Sie sicherstellen, dass Sie eine bestimmte Version von easy-novnc herunterladen, für den Fall, dass an der CLI-Schnittstelle gravierende Änderungen vorgenommen werden.

      Erstellen wir nun die zweite Stufe, die zum endgültigen Image wird. Hier verwenden Sie Debian 10 (buster) als Basis-Image. Beachten Sie, dass dieses, da es in einem Container ausgeführt wird, unabhängig von der auf Ihrem Server laufenden Distribution funktioniert.

      Fügen Sie als Nächstes den folgenden Block zu Ihrer Dockerfile hinzu:

      ~/thunderbird/Dockerfile

      ...
      FROM debian:buster
      RUN apt-get update -y && 
          apt-get install -y --no-install-recommends openbox tigervnc-standalone-server supervisor gosu && 
          rm -rf /var/lib/apt/lists && 
          mkdir -p /usr/share/desktop-directories
      

      In dieser Anweisung installieren Sie Debian 10 als Ihr Basis-Image und installieren dann das absolute Minimum, das erforderlich ist, um GUI-Anwendungen in Ihrem Container auszuführen. Beachten Sie, dass Sie apt-get update als Teil der gleichen Anweisung ausführen, um Zwischenspeicherungsprobleme von Docker zu verhindern. Um Speicherplatz zu sparen, entfernen Sie auch die danach heruntergeladenen Paketlisten (die zwischengespeicherten Pakete selbst werden standardmäßig entfernt). Sie erstellen auch /usr/share/desktop-directories, da einige Anwendungen von dem vorhandenen Verzeichnis abhängen.

      Fügen wir einen weiteren kleinen Code-Block hinzu:

      ~/thunderbird/Dockerfile

      ...
      RUN apt-get update -y && 
          apt-get install -y --no-install-recommends lxterminal nano wget openssh-client rsync ca-certificates xdg-utils htop tar xzip gzip bzip2 zip unzip && 
          rm -rf /var/lib/apt/lists
      

      In dieser Anweisung installieren Sie einige nützliche Allzweck-Dienstprogramme und -Pakete. Von besonderem Interesse sind hier xdg-utils (das die Basisbefehle bereitstellt, die von Desktop-Anwendungen unter Linux verwendet werden) und ca-certificates (das die Stammzertifikate installiert, um uns den Zugriff auf HTTPS-Seiten zu ermöglichen).

      Nun können wir die Anweisungen für die Hauptanwendung hinzufügen:

      ~/thunderbird/Dockerfile

      ...
      RUN apt-get update -y && 
          apt-get install -y --no-install-recommends thunderbird && 
          rm -rf /var/lib/apt/lists
      

      Wie zuvor installieren wir hier die Anwendung. Wenn Sie eine andere Anwendung containerisieren möchten, können Sie diese Befehle durch die Befehle ersetzen, die zum Installieren Ihrer spezifischen Anwendung erforderlich sind. Einige Anwendungen erfordern etwas mehr Arbeit, um in Docker ausgeführt zu werden. Wenn Sie beispielsweise eine App installieren, die Chrome, Chromium oder QtWebEngine verwendet, müssen Sie das Befehlszeilenargument --no-sandbox verwenden, da es von Docker nicht unterstützt wird.

      Als Nächstes fügen wir die Anweisungen zum Hinzufügen der letzten wenigen Dateien zum Container hinzu:

      ~/thunderbird/Dockerfile

      ...
      COPY --from=easy-novnc-build /bin/easy-novnc /usr/local/bin/
      COPY menu.xml /etc/xdg/openbox/
      COPY supervisord.conf /etc/
      EXPOSE 8080
      

      Hier fügen Sie dem Image die zuvor erstellten Konfigurationsdateien hinzu, und kopieren die Binärdatei easy-novnc aus der ersten Stufe.

      Dieser nächste Code-Block erstellt das Datenverzeichnis und fügt einen dedizierten Benutzer für Ihre App hinzu. Dies ist wichtig, da einige Anwendungen sich weigern als root ausgeführt zu werden. Es ist auch eine bewährte Praxis, Anwendungen nicht als root auszuführen, auch nicht in einem Container.

      ~/thunderbird/Dockerfile

      ...
      RUN groupadd --gid 1000 app && 
          useradd --home-dir /data --shell /bin/bash --uid 1000 --gid 1000 app && 
          mkdir -p /data
      VOLUME /data
      

      Um eine konsistente UID/GID für die Dateien zu gewährleisten, setzen Sie beide ausdrücklich auf 1000. Außerdem installieren Sie ein Volumen in das Datenverzeichnis, um sicherzustellen, dass es zwischen den Neustarts erhalten bleibt.

      Zum Schluss fügen wir noch die Anweisungen zum Starten von allem hinzu:

      ~/thunderbird/Dockerfile

      ...
      CMD ["sh", "-c", "chown app:app /data /dev/stdout && exec gosu app supervisord"]
      

      Wenn sie den Standardbefehl auf supervisord setzen,wir der Manager die für die Ausführung Ihrer Anwendung erforderlichen Prozesse starten. In diesem Fall verwenden Sie CMD anstatt ENTRYPOINT. In den meisten Fällen würde es keinen Unterschied machen, aber die Verwendung von CMD ist für diesen Zweck aus einigen Gründen besser geeignet. Erstens nimmt supervisord keine Argumente entgegen, die für uns relevant wären, und wenn Sie dem Container Argumente hinzufügen, ersetzten diese CMD und werden an ENTRYPOINT angehängt. Zweitens ermöglicht uns die Verwendung von CMD, bei der Übergabe von Argumenten an den Container einen völlig anderen Befehl (der von /bin/sh -c ausgeführt wird), anzugeben, was das Debuggen erleichtert.

      Und schließlich müssen Sie vor dem Starten von supervisord chown als root ausführen, um Berechtigungsprobleme auf dem Datenvolumen zu verhindern und den untergeordneten Prozessen das Öffnen von stdout zu ermöglichen. Das bedeutet auch, dass sie gosu anstelle der Anweisung USER verwenden müssen, um den Benutzer zu wechseln.

      So wird Ihre fertiggestellte Dockerfile aussehen:

      ~/thunderbird/Dockerfile

      FROM golang:1.14-buster AS easy-novnc-build
      WORKDIR /src
      RUN go mod init build && 
          go get github.com/geek1011/easy-novnc@v1.1.0 && 
          go build -o /bin/easy-novnc github.com/geek1011/easy-novnc
      
      FROM debian:buster
      
      RUN apt-get update -y && 
          apt-get install -y --no-install-recommends openbox tigervnc-standalone-server supervisor gosu && 
          rm -rf /var/lib/apt/lists && 
          mkdir -p /usr/share/desktop-directories
      
      RUN apt-get update -y && 
          apt-get install -y --no-install-recommends lxterminal nano wget openssh-client rsync ca-certificates xdg-utils htop tar xzip gzip bzip2 zip unzip && 
          rm -rf /var/lib/apt/lists
      
      RUN apt-get update -y && 
          apt-get install -y --no-install-recommends thunderbird && 
          rm -rf /var/lib/apt/lists
      
      COPY --from=easy-novnc-build /bin/easy-novnc /usr/local/bin/
      COPY menu.xml /etc/xdg/openbox/
      COPY supervisord.conf /etc/
      EXPOSE 8080
      
      RUN groupadd --gid 1000 app && 
          useradd --home-dir /data --shell /bin/bash --uid 1000 --gid 1000 app && 
          mkdir -p /data
      VOLUME /data
      
      CMD ["sh", "-c", "chown app:app /data /dev/stdout && exec gosu app supervisord"]
      

      Speichern und schließen Sie Ihre Dockerfile. Nun sind wir bereit, unseren Container zu erstellen und auszuführen und dann auf Thunderbird — eine GUI-Anwendung — zugreifen.

      Schritt 4 — Erstellen und Ausführen des Containers

      Der nächste Schritt besteht darin, Ihren Container zu erstellen und so einzustellen, dass er beim Starten ausgeführt wird. Sie werden auch ein Volumen einrichten, um die Anwendungsdaten zwischen Neustarts und Aktualisierungen zu erhalten.

      Erstellen Sie zuerst Ihren Container. Stellen Sie sicher, dass diese Befehle im Verzeichnis ~/thunderbird ausgeführt werden:

      • docker build -t thunderbird .

      Erstellen Sie nun ein neues Netzwerk, das von den Containern der Anwendung gemeinsam genutzt wird:

      • docker network create thunderbird-net

      Erstellen Sie dann ein Volume zum Speichern der Anwendungsdaten:

      • docker volume create thunderbird-data

      Führen Sie es abschließen aus und stellen Sie es so ein, dass es automatisch neu startet:

      • docker run --detach --restart=always --volume=thunderbird-data:/data --net=thunderbird-net --name=thunderbird-app thunderbird

      Beachten Sie, dass Sie, wenn Sie möchten, die thunderbird-app nach der Option --name durch einen anderen Namen ersetzen können. Was auch immer Sie gewählt haben, Ihre Anwendung ist nun containerisiert und wird ausgeführt. Verwenden wir nun den Caddy-Webserver, um sie zu sichern und eine Fernverbindung zu ihr aufzubauen.

      Schritt 5 — Einrichten von Caddy

      In diesem Schritt richten Sie den Caddy-Webserver so ein, dass er Authentifizierung und, optional, Fernzugriff auf Ihre Dateien über WebDAV bietet. Der Einfachheit halber und damit Sie ihn mit Ihrem vorhandenen Reverse-Proxy verwenden können, werden Sie ihn in einem anderen Container ausführen.

      Erstellen Sie ein neues Verzeichnis und gehen Sie dann in dieses:

      Erstellen Sie nun mit nano oder Ihrem bevorzugten Editor eine neue Dockerfile:

      Fügen Sie dann die folgenden Anweisungen hinzu:

      ~/caddy/Dockerfile

      FROM golang:1.14-buster AS caddy-build
      WORKDIR /src
      RUN echo 'module caddy' > go.mod && 
          echo 'require github.com/caddyserver/caddy/v2 v2.0.0' >> go.mod && 
          echo 'require github.com/mholt/caddy-webdav v0.0.0-20200523051447-bc5d19941ac3' >> go.mod
      RUN echo 'package main' > caddy.go && 
          echo 'import caddycmd "github.com/caddyserver/caddy/v2/cmd"' >> caddy.go && 
          echo 'import _ "github.com/caddyserver/caddy/v2/modules/standard"' >> caddy.go && 
          echo 'import _ "github.com/mholt/caddy-webdav"' >> caddy.go && 
          echo 'func main() { caddycmd.Main() }' >> caddy.go
      RUN go build -o /bin/caddy .
      
      FROM debian:buster
      
      RUN apt-get update -y && 
          apt-get install -y --no-install-recommends gosu && 
          rm -rf /var/lib/apt/lists
      
      COPY --from=caddy-build /bin/caddy /usr/local/bin/
      COPY Caddyfile /etc/
      EXPOSE 8080
      
      RUN groupadd --gid 1000 app && 
          useradd --home-dir /data --shell /bin/bash --uid 1000 --gid 1000 app && 
          mkdir -p /data
      VOLUME /data
      
      WORKDIR /data
      CMD ["sh", "-c", "chown app:app /data && exec gosu app /usr/local/bin/caddy run -adapter caddyfile -config /etc/Caddyfile"]
      

      Diese Dockerfile erstellt Caddy mit dem aktivierten WebDAV-Plugin und startet ihn dann auf Port 8080 mit der Caddyfile unter /etc/Caddyfile. Speichern und schließen Sie die Datei.

      Als Nächstes konfigurieren Sie den Caddy-Webserver. Erstellen Sie eine Datei namens Caddyfile im gerade erstellten Verzeichnis:

      Fügen Sie nun den folgenden Code-Block zu Ihrer Caddyfile hinzu:

      ~/caddy/Caddyfile

      {
          order webdav last
      }
      :8080 {
          log
          root * /data
          reverse_proxy thunderbird-app:8080
      
          handle /files/* {
              uri strip_prefix /files
              file_server browse
          }
          redir /files /files/
      
          handle /webdav/* {
              uri strip_prefix /webdav
              webdav
          }
          redir /webdav /webdav/
      
          basicauth /* {
              {env.APP_USERNAME} {env.APP_PASSWORD_HASH}
          }
      }
      

      Diese Caddyfile verweist das Stammverzeichnis an den in Schritt 4 erstellten Container thunderbird-app (Docker löst ihn in die richtige IP auf). Es wird auch einen schreibgeschützten webbasierten Dateibrowser auf /files bedienen und einen WebDAV-Server auf /webdav ausführen, den Sie lokal installieren können, um auf Ihre Dateien zugreifen zu können. Der Benutzername und das Passwort werden aus den Umgebungsvariablen APP_USERNAME und APP_PASSWORD_HASH gelesen.

      Erstellen Sie nun den Container:

      • docker build -t thunderbird-caddy .

      Caddy v.2 erfordert, dass Sie Ihr gewünschtes Passwort hashen. Führen Sie den folgenden Befehl aus denken Sie daran, mypass durch ein starkes Passwort Ihrer Wahl zu ersetzen:

      • docker run --rm -it thunderbird-caddy caddy hash-password -plaintext 'mypass'

      Dieser Befehl gibt eine Zeichenfolge aus. Kopieren Sie diese in die Zwischenablage, um die Ausführung des nächsten Befehls vorzubereiten.

      Jetzt sind Sie bereit, den Container auszuführen. Achten Sie darauf, myuser durch einen Benutzernamen Ihrer Wahl zu ersetzen und ersetzen Sie mypass-hash durch die Ausgabe des im vorherigen Schritt ausgeführten Befehls. Sie können auch den Port (hier 8080) ändern, um über einen anderen Port auf Ihren Server zuzugreifen:

      • docker run --detach --restart=always --volume=thunderbird-data:/data --net=thunderbird-net --name=thunderbird-web --env=APP_USERNAME="myuser" --env=APP_PASSWORD_HASH="mypass-hash" --publish=8080:8080 thunderbird-caddy

      Wir sind nun bereit, auf unsere Anwendung zuzugreifen und sie zu testen.

      Schritt 6 — Testen und Verwalten der Anwendung

      Greifen wir nun auf die Anwendung zu und stellen sicher, dass sie funktioniert.

      Öffnen Sie zunächst http://your_server_ip:8080 in einem Webbrowser, melden Sie sich mit den zuvor gewählten Anmeldeinformationen an und klicken Sie auf Connect.

      Verbindungsseite von NoVNC

      Sie sollten nun in der Lage sein, mit der Anwendung zu interagieren und sie sollte sich automatisch an die Größe Ihres Browserfensters anpassen.

      Hauptmenü von Thunderbird

      Wenn Sie mit der rechten Maustaste auf den schwarzen Desktop klicken, sollten Sie ein Menü sehen, das Ihnen den Zugriff auf ein Terminal ermöglicht. Wenn Sie mit der mittleren Maustaste klicken, sollten Sie eine Liste von Fenstern sehen.

      NoVNC Klicken mit der rechten Maustaste

      Öffnen Sie nun http://your_server_ip:8080/files/ in einem Webbrowser. Sie sollten in der Lage sein, auf Ihre Dateien zuzugreifen.

      NoVNC Dateizugriff webdav

      Optional können Sie versuchen, http://your_server_ip:8080/webdav/ in einem WebDAV-Client zu installieren. Sie sollten in der Lage sein, direkt auf Ihre Dateien zuzugreifen und sie zu ändern. Wenn Sie die Option Map network drive (Netzlaufwerk zuordnen) im Windows Explorer verwenden, müssen Sie entweder einen Reverse-Proxy verwenden, um HTTPS hinzuzufügen oder HKLMSYSTEMCurrentControlSetServicesWebClientParametersBasicAuthLevel auf DWORD:2 setzen.

      In beiden Fällen ist Ihre native GUI-Anwendung nun für die Fernverwendung bereit.

      Zusammenfassung

      Sie haben nun erfolgreich einen Docker-Container für Thunderbird eingerichtet und dann mit Caddy den Zugriff darauf über einen Webbrowser konfiguriert. Sollten Sie Ihre App jemals aktualisieren müssen, halten Sie die Container an, führen Sie docker rm thunderbird-app thunderbird-web aus, erstellen Sie die Images neu und führen Sie dann die Befehle docker run aus den vorherigen Schritten oben erneut aus. Ihre Daten bleiben weiterhin erhalten, da sie in einem Volumen gespeichert sind.

      Wenn Sie mehr über grundlegende Docker-Befehle erfahren möchten, können Sie dieses Tutorial oder dieses Cheatsheet lesen. Für den längerfristigen Gebrauch sollten Sie auch in Betracht ziehen, HTTPS (hierfür ist eine Domäne erforderlich) für zusätzliche Sicherheit zu aktivieren.

      Wenn Sie mehr als eine Anwendung bereitstellen, möchten Sie möglicherweise Docker Compose oder Kubernetes verwenden, anstatt jeden Container manuell zu starten. Denken Sie daran, dass dieses Tutorial als Grundlage für die Ausführung jeder anderen Linux-Anwendung auf Ihrem Server dienen kann, einschließlich:

      • Wine, eine Kompatibilitätsschicht für die Ausführung von Windows-Anwendungen unter Linux.
      • GIMP, ein Open-Source-Bildbearbeitungsprogramm.
      • Cutter, eine Open-Source-Plattform für Reverse Engineering.

      Diese letzte Option zeigt das große Potenzial der Containerisierung und des Fernzugriffs auf GUI-Anwendungen. Mit dieser Einrichtung können Sie nun einen Server mit wesentlich mehr Rechenleistung, als Sie möglicherweise vor Ort haben, verwenden, um ressourcenintensive Tools wie Cutter auszuführen.



      Source link

      Installieren von Python 3 und Einrichten einer Programmierumgebung auf einem Ubuntu 20.04-Server


      Einführung

      Die Python-Programmiersprache ist eine zunehmend beliebte Wahl für Anfänger und auch erfahrene Entwickler. Python ist flexibel und vielseitig und bietet Vorteile in den Bereichen Skripterstellung, Automatisierung, Datenanalysen, maschinelles Lernen und Backend-Entwicklung. Python wurde 1991 erstmals veröffentlicht; der Name ist von der britischen Komikergruppe Monty Python inspiriert. Das Entwicklerteam wollte mit Python eine Sprache schaffen, deren Verwendung Spaß macht.

      In diesem Tutorial richten Sie Ihren Ubuntu 20.04-Server mit einer Python 3-Programmierumgebung ein. Das Programmieren auf einem Server bietet viele Vorteile und fördert die Zusammenarbeit bei Entwicklungsprojekten. Die allgemeinen Grundsätze dieses Tutorials gelten für alle Distributionen von Debian Linux.

      Voraussetzungen

      Um dieses Tutorial absolvieren zu können, benötigen Sie einen non-root user mit sudo-Berechtigungen auf einem Ubuntu 20.04-Server. Um zu erfahren, wie Sie diese Einrichtung erreichen, befolgen Sie unseren Leitfaden zur Ersteinrichtung des Servers.

      Wenn Sie noch nicht mit einer Terminalumgebung vertraut sind, können Sie im Artikel „Eine Einführung in das Linux-Terminal“ mehr über das Terminal erfahren.

      Nach der Einrichtung Ihres Servers und Benutzers können Sie loslegen.

      Schritt 1 — Einrichten von Python 3

      Ubuntu 20.04 und andere Versionen von Debian Linux werden mit vorinstalliertem Python 3 ausgeliefert. Um sicherzustellen, dass unsere Versionen aktuell sind, aktualisieren wir das System mit dem Befehl apt, um das Advanced Packaging Tool von Ubuntu zu nutzen:

      • sudo apt update
      • sudo apt -y upgrade

      Das Flag -y bestätigt, dass wir mit der Installation aller Elemente einverstanden sind. Je nach Ihrer Linux-Version müssen Sie aber ggf. zusätzliche Eingabeaufforderungen bei Aktualisierungen und Upgrades Ihres Systems bestätigen.

      Nach Abschluss des Verfahrens können wir die im System installierte Version von Python 3 überprüfen, indem wir Folgendes eingeben:

      Sie erhalten eine Ausgabe im Terminalfenster, in der die Versionsnummer steht. Zwar kann Ihre Zahl anders sein, die Ausgabe wird aber etwa wie folgt aussehen:

      Output

      Python 3.8.2

      Um Softwarepakete für Python zu verwalten, installieren wir pip, ein Tool, das Programmierpakete installieren und verwalten wird, die wir möglicherweise in unseren Entwicklungsprojekten verwenden möchten. Sie können mehr über Module oder Pakete erfahren, die Sie mit pip installieren können, indem Sie „Importieren von Modulen in Python 3“ lesen.

      • sudo apt install -y python3-pip

      Python-Pakete lassen sich installieren, indem Sie Folgendes eingeben:

      • pip3 install package_name

      Hier kann sich package_name auf beliebige Python-Pakete oder Bibliotheken beziehen, wie Django für die Webentwicklung oder NumPy für wissenschaftliches Rechnen. Wenn Sie NumPy installieren möchten, können Sie dies mit dem Befehl pip3 install numpy tun.

      Es sind noch einige weitere Pakete und Entwicklungstools zu installieren, um sicherzustellen, dass wir eine robuste Einrichtung für unsere Programmierumgebung haben:

      • sudo apt install -y build-essential libssl-dev libffi-dev python3-dev

      Nach der Einrichtung von Python und der Installation von pip und anderen Tools können wir eine virtuelle Umgebung für unsere Entwicklungsprojekte einrichten.

      Schritt 2 — Einrichten einer virtuellen Umgebung

      Mit virtuellen Umgebungen können Sie einen isolierten Bereich auf Ihrem Server für Python-Projekte schaffen, sodass jedes Ihrer Projekte einen eigenen Satz von Abhängigkeiten aufweist, der andere Projekte nicht stört.

      Das Einrichten einer Programmierumgebung bietet eine größere Kontrolle über Python-Projekte und die Handhabung verschiedener Versionen von Paketen. Das ist beim Einsatz von Paketen anderer Anbieter besonders wichtig.

      Sie können so viele Python-Programmierumgebungen einrichten wie nötig. Jede Umgebung ist im Grunde genommen ein Verzeichnis oder Ordner auf Ihrem Server, das bzw. der Skripte zum Ausführen einer Umgebung enthält.

      Es gibt zwar verschiedene Möglichkeiten, um eine Programmierumgebung in Python einzurichten, aber wir verwenden hier das Modul venv, das Teil der Standardbibliothek von Python 3 ist. Wir installieren venv, indem wir Folgendes eingeben:

      • sudo apt install -y python3-venv

      Nach der Installation sind wir bereit, Umgebungen zu erstellen. Wählen Sie entweder ein Verzeichnis, in das Sie Ihre Python-Programmierumgebungen einfügen möchten, oder erstellen Sie mit mkdir wie folgt ein neues Verzeichnis:

      • mkdir environments
      • cd environments

      Sobald Sie sich im Verzeichnis befinden, in dem Sie die Umgebungen einrichten möchten, können Sie eine Umgebung erstellen, indem Sie den folgenden Befehl ausführen:

      Im Grunde genommen richtet pyvenv ein neues Verzeichnis ein, das einige Elemente enthält, die wir mit dem Befehl ls anzeigen können:

      Output

      bin include lib lib64 pyvenv.cfg share

      Zusammen sorgen diese Dateien dafür, dass Ihre Projekte vom breiteren Kontext Ihres Servers isoliert werden, sodass sich Systemdateien und Projektdateien nicht vermischen. Dies ist eine gute Praxis für die Versionsverwaltung und sorgt dafür, dass jedes Ihrer Projekte Zugriff auf die jeweils benötigten Pakete hat. Python Wheels, ein für Python entwickeltes Paketformat, das Ihre Software-Produktion beschleunigen kann, indem es die Anzahl der benötigten Kompilierungen reduziert, wird sich im Verzeichnis share von Ubuntu 20.04 befinden.

      Um diese Umgebung zu verwenden, müssen Sie sie aktivieren. Das können Sie tun, indem Sie den folgenden Befehl eingeben, der das Skript activate aufruft:

      • source my_env/bin/activate

      Ihrer Eingabeaufforderung wird nun der Name Ihrer Umgebung vorangestellt. In diesem Fall heißt sie my_env. Je nach der Version von Debian Linux, die Sie ausführen, sieht Ihr Präfix möglicherweise etwas anders aus, der Name Ihrer Umgebung in Klammern sollte jedoch das Erste sein, das Sie in der Zeile sehen:

      Dieses Präfix lässt uns wissen, dass die Umgebung my_env gegenwärtig aktiv ist. Das bedeutet, dass bei der Erstellung von Programmen nur die Einstellungen und Pakete dieser spezifischen Umgebung verwendet werden.

      Anmerkung: Innerhalb der virtuellen Umgebung können Sie auf Wunsch den Befehl python anstelle von python3 und pip anstelle von pip3 verwenden. Wenn Sie Python 3 auf Ihrem Rechner außerhalb einer Umgebung verwenden, müssen Sie ausschließlich die Befehle python3 und pip3 verwenden.

      Nach den folgenden Schritten ist Ihre virtuelle Umgebung bereit zur Verwendung.

      Schritt 3 — Erstellen eines „Hello, World”-Programms

      Nachdem wir unsere virtuelle Umgebung eingerichtet haben, erstellen wir nun das traditionelle „Hello, World!“-Programm. Dadurch können wir unsere Umgebung testen und erhalten die Möglichkeit, uns mit Python besser vertraut zu machen, wenn wir es nicht bereits sind.

      Dazu öffnen wir einen Befehlszeilen-Texteditor wie nano und erstellen eine neue Datei:

      Sobald die Textdatei im Terminalfenster geöffnet ist, geben wir unser Programm ein:

      print("Hello, World!")
      

      Beenden Sie nano, indem Sie die Tasten STRG und X drücken. Wenn Sie zum Speichern der Datei aufgefordert werden, drücken Sie y.

      Sobald Sie nano beendet haben und zu Ihrer Shell zurückgekehrt sind, führen Sie das Programm aus:

      Das gerade erstellte Programm hello.py sollte dazu führen, dass im Terminal die folgende Ausgabe angezeigt wird:

      Output

      Hello, World!

      Geben Sie den Befehl deactivate ein, um die Umgebung zu verlassen und in das Originalverzeichnis zurückkehren.

      Zusammenfassung

      Herzlichen Glückwunsch! Sie haben auf Ihrem Ubuntu Linux-Server eine Python-3-Programmierumgebung eingerichtet und können nun mit einem Codierprojekt beginnen!

      Wenn Sie einen lokalen Rechner anstelle eines Servers verwenden, konsultieren Sie das Tutorial, das für Ihr Betriebssystem relevant ist, in unserer Reihe Installieren und Einrichten einer lokalen Programmierumgebung für Python 3.

      Da Ihr Server nun bereit für die Softwareentwicklung ist, können Sie mehr über das Codieren in Python erfahren, indem Sie unser kostenloses E-Book Codieren in Python 3 lesen oder unsere Python-Tutorials konsultieren.



      Source link