Der Autor wählte den Free and Open Source Fund, um eine Spende im Rahmen des Programms Write for DOnations zu erhalten.
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.
Bevor Sie diesen Leitfaden beginnen, benötigen Sie Folgendes:
sudo
-Berechtigungen.supervisord
-KonfigurationDa 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:
[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:
...
[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 :
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:
...
[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:
...
[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:
...
[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:
[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.
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:
<?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.
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:
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:
...
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:
...
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:
...
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:
...
COPY /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.
...
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:
...
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:
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 /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.
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.
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:
- mkdir ~/caddy
- cd ~/caddy
Erstellen Sie nun mit nano
oder Ihrem bevorzugten Editor eine neue Dockerfile
:
- nano ~/caddy/Dockerfile
Fügen Sie dann die folgenden Anweisungen hinzu:
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 /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:
- nano ~/caddy/Caddyfile
Fügen Sie nun den folgenden Code-Block zu Ihrer Caddyfile
hinzu:
{
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.
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.
Sie sollten nun in der Lage sein, mit der Anwendung zu interagieren und sie sollte sich automatisch an die Größe Ihres Browserfensters anpassen.
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.
Öffnen Sie nun http://your_server_ip:8080/files/
in einem Webbrowser. Sie sollten in der Lage sein, auf Ihre Dateien zuzugreifen.
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 HKLM\SYSTEM\CurrentControlSet\Services\WebClient\Parameters\BasicAuthLevel
auf DWORD:2
setzen.
In beiden Fällen ist Ihre native GUI-Anwendung nun für die Fernverwendung bereit.
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:
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.
Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.
This textbox defaults to using Markdown to format your answer.
You can type !ref in this text area to quickly search our full set of tutorials, documentation & marketplace offerings and insert the link!