One place for hosting & domains

      Cómo acceder remotamente a aplicaciones GUI usando Docker y Caddy en Ubuntu 18.04


      El autor seleccionó la Free and Open Source Fund para recibir una donación como parte del programa Write for DOnations.

      Introducción

      Aún con la creciente popularidad de los servicios en la nube, la necesidad de ejecutar aplicaciones nativas sigue existiendo.

      Con noVNC y TigerVNC, puede ejecutar aplicaciones nativas dentro de un contenedor Docker y acceder a ellas remotamente usando un navegador web. Adicionalmente, puede ejecutar su aplicación en un servidor con más recursos del sistema de los que pueda tener disponibles localmente, lo que puede proporcionar mayor flexibilidad cuando se ejecutan grandes aplicaciones.

      En este tutorial, pondrá en un contendor Mozilla Thunderbird, un cliente de correo electrónico, usando Docker. Tras ello, lo protegerá y proporcionará acceso remoto usando el servidor web Caddy.

      Cuando haya terminado, podrá acceder a Thunderbird desde cualquier dispositivo usando únicamente un navegador web. Opcionalmente, podrá acceder localmente a los archivos usando WebDAV. También tendrá una imagen Docker completamente autocontenida que puede ejecutar en cualquier lugar.

      Requisitos previos

      Antes de iniciar esta guía, necesitará lo siguiente:

      Paso 1: Crear la configuración supervisord

      Ahora que su servidor está ejecutándose y Docker está instalado, está listo para comenzar a configurar el contenedor de su aplicación. Ya que su contenedor consta de varios componentes, deberá usar un administrador de procesos para iniciarlos y monitorizarlos. Aquí usará supervisord. supervisord es un gestor de procesos escrito en Python que se utiliza a menudo para organizar contenedores complejos.

      Primero, cree y entre en un directorio llamado thunderbird para su contenedor.

      • mkdir ~/thunderbird
      • cd ~/thunderbird

      Ahora cree y abra un archivo llamado supervisord.conf usando nano o su editor preferido:

      Ahora añada este primer bloque de código en supervisord.conf, lo que definirá las opciones globales para supervisord:

      ~/thunderbird/supervisord.conf

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

      En este bloque, está configurando supervisord. Deberá establecer nodaemon a true porque se ejecutará dentro de un contenedor Docker como el punto de entrada. Por tanto, querrá que permanezca en ejecución en primer plano. También configura pidfile a una ruta accesible por un usuario non-root (más sobre esto más tarde), y logfile to stdout para que pueda ver los registros.

      A continuación, añada otro bloque de código pequeño a supervisord.conf. Este bloque inicia TigerVNC que es un servidor VNC/X11 combinado:

      ~/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
      

      En este bloque, está configurando el servidor X11. X11 es un protocolo de servidor de visualización, que es lo que permite que se ejecuten las aplicaciones GUI. Tenga en cuenta que en el futuro se sustituirá con Wayland, pero el acceso remoto aún está en desarrollo.

      Para este contenedor, está usando TigerVNC y está integrado en el servidor VNC. Esto tiene varias ventajas sobre el uso de un servidor X11 y VNC:

      • Tiempo de respuesta más rápido, ya que el dibujo de la GUI se realiza directamente en el servidor VNC en vez de hacerse en un framebuffer intermedio (la memoria que almacena los contenidos de la pantalla).
      • Cambio de tamaño automático de la pantalla, que permite a la aplicación remota cambiar de tamaño automáticamente para que se ajuste al cliente (en este caso, la ventana de su navegador web).

      Si lo desea, puede cambiar el argumento para la opción -desktop desde Thunderbird a otra cosa que elija. El servidor mostrará su opción como el título de la página web usada para acceder a su aplicación.

      Ahora, vamos a añadir un tercer bloque de código a supervisord.conf para iniciar easy-novnc:

      ~/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
      

      En este bloque, está configurando easy-novnc, un servidor independiente que ofrece un envoltorio alrededor de noVNC. Este servidor realiza dos funciones. Primero, proporciona una página sencilla de conexión que le permite configurar opciones para la conexión, y le permite establecer las predeterminadas. Segundo, realiza proxy a VNC sobre WebSocket, lo que permite el acceso a través de un navegador web ordinario.

      Normalmente, el cambio de tamaño se realiza en el lado del cliente (es decir, escala de imagen), pero está usando la opción resize=remote para aprovechar los ajustes de resolución remota de TigerVNC. Esto también proporciona una menor latencia en dispositivos más lentos, como Chromebooks de gama baja:

      Nota: Este tutorial utiliza easy-novnc. Si lo desea, puede usar websockfy y un servidor web independiente. La ventaja de easy-novnc es que el uso de memoria y el tiempo de inicio es significativamente menor que si fuese auto-contenido. easy-novnc también proporciona una página conexión más limpia que la de noVNC predeterminado, y permite establecer opciones predeterminadas que son útiles para esta configuración (como resize=remote).

      Ahora añada el siguiente bloque a su configuración para iniciar OpenBox, el gestor de ventanas:

      ~/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
      

      En este bloque, está configurando OpenBox, un gestor de ventanas X11 ligero. Podría omitir este paso, pero sin él no tendría las barras de título o podría cambiar el tamaño de las ventanas.

      Finalmente, vamos a añadir el último bloque a supervisord.conf, que iniciará la aplicación principal:

      ~/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
      

      En este bloque final, está configurando priority a 1 para garantizar que Thunderbird se inicia tras TigerVNC, o encontrará una condición de carrera o fallaría aleatoriamente al inicio. También configuramos autorestart=true para que vuelva a abrir automáticamente la aplicación si se cierra por error. La variable de entorno DISPLAY indica a la aplicación que se muestre en el servidor VNC que configuró anteriormente.

      Este es el aspecto que tendrá su supervisord.conf completado:

      ~/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
      

      Si desea poner una aplicación diferente en contenedor, sustituya /usr/bin/thunderbird con la ruta al ejecutable de su aplicación. De lo contrario, estará listo para configurar el menú principal de su GUI.

      Paso 2: Configurar el menú de OpenBox

      Ahora que su gestor de procesos está configurado, vamos a configurar el menú de OpenBox. Este menú nos permite abrir aplicaciones dentro del contenedor. También incluiremos un monitor de terminal y procesos para depurar si es necesario.

      Dentro del directorio de la aplicación, utilice nano o su editor de texto favorito para crear y abrir un nuevo archivo llamado menu.xml:

      • nano ~/thunderbird/menu.xml

      Ahora añada el siguiente código a menu.xml:

      ~/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>
      

      Este archivo XML contiene los elementos del menú que aparecerán cuando haga clic con el botón derecho sobre el escritorio. Cada elemento consta de una etiqueta y una acción.

      Si desea añadir al contenedor una aplicación diferente, sustituya /usr/bin/thunderbird con la ruta al ejecutable de su aplicación y cambie la etiqueta del elemento.

      Paso 3: Crear el Dockerfile

      Ahora que OpenBox está configurado, creará el Dockerfile, que une todo.

      Crear un Dockerfile en el directorio de su contenedor:

      • nano ~/thunderbird/Dockerfile

      Para comenzar, vamos a añadir algún código para crear easy-novnc:

      ~/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
      

      En la primera etapa, está creando easy-novnc. Esto se hace en una etapa independiente para mayor simplificada y para ahorrar espacio; no necesita toda la cadena de herramientas de go en su imagen final. Observe @v1.1.0 en el comando de compilación. Esto garantiza que el resultado sea determinista, lo cual es importante porque Docker captura el resultado de cada paso. Si no hubiese especificado una versión explícita, Docker haría referencia a la versión más reciente de easy-novnc en el momento en que se compiló la imagen por primera vez. Además, desea garantizar que descarga una versión específica de easy-novnc, en el caso de que se realicen cambios de ruptura en la interfaz CLI.“”“”

      Ahora vamos a crear la segunda etapa que será la imagen final. Aquí usará Debian 10 (buster) como imagen base. Observe que dado que se está ejecutando en un contenedor, funcionará independientemente de la distribución que esté ejecutando en su servidor.

      A continuación, añada el siguiente bloque a su Dockerfile:

      ~/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
      

      En esta instrucción, está instalando Debian 10 como su imagen base y luego instalando el mínimo necesario para ejecutar aplicaciones GUI en su contenedor. Observe que ejecuta apt-get update como parte de la misma instrucción para evitar problemas de captura desde Docker. Para ahorrar espacio, también está eliminando las listas de paquetes descargadas posteriormente (los paquetes en caché en sí mismos se eliminan por defecto). Está creando /usr/share/desktop-directories porque algunas aplicaciones dependen de que exista el directorio.

      Vamos a añadir otro bloque de código pequeño:

      ~/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
      

      En esta instrucción, está instalando algunas utilidades y paquetes útiles de uso general. Son interesantes xdg-utils (que proporciona los comandos base usados por las aplicaciones de escritorio en Linux) y ca-certificates (que instala los certificados raíz para permitirnos acceder a los sitios HTTPS).

      Ahora, podemos añadir las instrucciones para la aplicación principal:

      ~/thunderbird/Dockerfile

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

      Como antes, aquí estamos instalando la aplicación. Si añade una aplicación diferente al contenedor, puede sustituir estos comandos con los necesarios para instalar su aplicación específica. Algunas aplicaciones requerirán un poco más de trabajo para ejecutarse dentro de Docker. Por ejemplo, si está instalando una aplicación que utiliza Chrome, Chromium o QtWebEngine, deberá usar el argumento de línea de comando --no-sandbox porque no será compatible en Docker.

      A continuación, vamos a comenzar añadiendo las instrucciones para añadir las últimas líneas al contenedor:

      ~/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
      

      Aquí está añadiendo los archivos de configuración que creó anteriormente a la imagen y copiando el binario easy-novnc de la primera etapa.

      Este siguiente bloque de código crea el directorio de datos y añade un usuario dedicado para su aplicación. Esto es importante porque algunas aplicaciones no se ejecutan como root. También es una buena práctica no ejecutar aplicaciones como root, incluso en un contenedor.

      ~/thunderbird/Dockerfile

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

      Para garantizar un UID/GID consistente para los archivos, está estableciendo explícitamente ambos a 1000. También está montando un volumen sobre el directorio de datos para garantizar que persiste entre los reinicios.

      Finalmente, vamos a añadir las instrucciones para iniciar todo:

      ~/thunderbird/Dockerfile

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

      Al establecer el comando predeterminado a supervisord, el administrador iniciará los procesos requeridos para ejecutar su aplicación. En este caso, está usando CMD en vez de ENTRYPOINT. En la mayoría de los casos, no supondría una diferencia, pero usar CMD es mejor para este fin por algunos motivos. Primero, supervisord no toma ningún argumento que sería relevante para nosotros, y si proporciona argumentos al contenedor, sustituye CMD y se anexan a ENTRYPOINT. Segundo, usar CMD nos permite proporcionar un comando completamente diferente (que se será ejecutado por /bin/sh -c) cuando se pasan argumentos al contenedor, lo que hace que la depuración sea más fácil.

      Y finalmente, deberá ejecutar chown como raíz antes de iniciar supervisord para evitar problemas de permisos sobre el volumen de datos y para permitir que se abran los procesos secundarios stdout. Esto también significa que deberá usar gosu en vez de la instrucción USER para cambiar al usuario.

      Este es el aspecto que tendrá su archivo Dockerfile completado:

      ~/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"]
      

      Guarde y cierre su Dockerfile. Ahora estamos listos para crear y ejecutar nuestro contenedor, y luego acceder a Thunderbird – una aplicación GUI.

      Paso 4: Crear y ejecutar el contenedor

      El siguiente paso es crear su contenedor y configurarlo para que se ejecute al inicio. También configurará un volumen para conservar los datos de la aplicación entre reinicios y actualizaciones.

      Primero, cree su contenedor. Asegúrese de ejecutar estos comandos en el directorio ~/thunderbird:

      • docker build -t thunderbird .

      Ahora cree una nueva red que será compartida entre los contenedores de la aplicación:

      • docker network create thunderbird-net

      A continuación, cree un volumen para almacenar los datos de la aplicación:

      • docker volume create thunderbird-data

      Finalmente, ejecútelo para que se reinicie automáticamente:

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

      Tenga en cuenta que si lo desea, puede sustituir thunderbird-app tras la opción --nombre con un nombre diferente. Sea cual sea su elección, su aplicación ahora está en contenedor y ejecutándose. Ahora vamos a usar el servidor web Caddy para protegerla y conectar remotamente a ella.

      Paso 5: Configurar Caddy

      En este paso, configurará el servidor web Caddy para proporcionar autenticación y, opcionalmente, acceso remoto a los archivos sobre WebDAV. Para mayor simplicidad, y para permitirle usarlo con su proxy inverso existente, lo ejecutará en otro contenedor.

      Cree un nuevo directorio y muévalo dentro:

      Ahora cree un nuevo Dockerfile usando nano o su editor preferido:

      Luego, añada las siguientes directivas:

      ~/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"]
      

      Este Dockerfile crea Caddy con el complemento WebDAV habilitado, y luego lo abre en el puerto 8080 con Caddyfile en /etc/Caddyfile. Guarde y cierre el archivo.

      A continuación, configurará el servidor web Caddy. Cree un archivo llamado Caddyfile en el directorio que acaba de crear:

      Ahora añada el siguiente bloque de código a su Caddyfile:

      ~/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}
          }
      }
      

      Este Caddyfile realiza proxy el directorio raíz al contenedor thunderbird-app que creó en el Paso 4 (Docker lo resuelve a la IP correcta). También servirá como un navegador de archivo basado en web solo lectura en /files y para ejecutar el servidor WebDAV en /webdav que puede montar localmente para acceder a sus archivos. El nombre de usuario y la contraseña se leen desde las variables de entorno APP_USERNAME y APP_PASSWORD_HASH.

      Ahora cree el contenedor:

      • docker build -t thunderbird-caddy .

      Caddy v.2 requiere que haga hash a su contraseña deseada. Ejecute el siguiente comando y recuerde sustituir mypass con una contraseña fuerte que elija:

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

      Este comando dará como resultado una cadena de caracteres. Copie esto a su portapapeles para prepararse para ejecutar el siguiente comando.

      Ahora está listo para ejecutar el contenedor. Asegúrese de sustituir myuser con un nombre de usuario que elija, y sustituya mypass-hash con el resultado del comando que ejecutó en el paso anterior. Puede cambiar también el puerto (8080 aquí) para acceder a su servidor en un puerto diferente:

      • 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

      Ahora está listo para acceder y probar nuestra aplicación.

      Paso 6: Probar y administrar la aplicación

      Vamos a acceder a su aplicación y a asegurarnos de que está funcionando.

      Primero, abra http://your_server_ip:8080 en un navegador web, inicie sesión con las credenciales que seleccionó anteriormente y haga clic en Connect.

      Página de conexión de NoVNC

      Ahora debería poder interactuar con la aplicación, y debería cambiar de tamaño automáticamente para que se adapte a la ventana de su navegador.

      Menú principal de Thunderbird

      Si hace clic con el botón derecho en el escritorio en negro, debería ver un menú que le permite acceder a un terminal. Si hace clic en el centro, debería ver una lista de ventanas.

      Clic derecho en NoVNC

      Ahora abra http://your_server_ip:8080/files/ en un navegador web. Debería poder acceder a sus archivos.

      Archivo de acceso webdav a NoVNC

      Opcionalmente, puede intentar montar http://your_server_ip:8080/webdav/ en un cliente WebDAV. Debería poder acceder y modificar sus archivos directamente. Si utiliza la opción Asignar unidad de red en Windows Explorer, necesitará usar un proxy inverso para añadir HTTPS o establecer HKLMSYSTEMCurrentControlSetServicesWebClientParametersBasicAuthLevel​​​ a DWORD:2.

      En cualquier caso, su aplicación GUI nativa está ahora lista para su uso remoto.

      Conclusión

      Ahora ha configurado correctamente un contenedor Docker para Thunderbird y a continuación, usando Caddy, ha configurado el acceso a él a través de un navegador web. Si alguna vez necesita actualizar su aplicación, detenga los contenedores, ejecute docker rm thunderbird-app thunderbird-web, vuelva a crear las imágenes, y vuelva a ejecutar los comandos docker run de los pasos anteriores. Sus datos se conservarán, ya que se almacenan en un volumen.

      Si desea obtener más información sobre los comandos Docker básicos, puede leer este tutorial o esta hoja de trucos. Para un uso a más largo plazo, quizá desee considerar habilitar HTTPS (esto requiere un dominio) para mayor seguridad.

      Además, si está implementando más de una aplicación, es posible que desee usar Docker Compose o Kubernetes en vez de iniciar cada contenedor manualmente. Y recuerde, este tutorial puede servir como base para ejecutar cualquier otra aplicación Linux en su servidor, incluyendo:

      • Wine, una capa de compatibilidad para ejecutar aplicaciones Windows en Linux.
      • GIMP, un editor de imágenes de código abierto.
      • Cutter, una plataforma de ingeniería inversa de código abierto:

      Esta última opción demuestra el gran potencial de usar contendores y acceder remotamente a aplicaciones GUI. Con esta configuración, puede usar un servidor con una potencia de computación considerablemente mayor que si utilizase localmente herramientas que consumen muchos recursos como Cutter.



      Source link

      Comment accéder à distance aux applications GUI en utilisant Docker et Caddy sur Ubuntu 18.04


      L’auteur a choisi le Free and Open Source Fund pour recevoir un don dans le cadre du programme Write for Donations.

      Introduction

      Même avec la popularité croissante des services cloud, le besoin d’exécuter des applications natives existe toujours.

      En utilisant noVNC et TigerVNC,vous pouvez exécuter des applications natives dans un conteneur Docker et y accéder à distance à l’aide d’un navigateur web. En outre, vous pouvez exécuter votre application sur un serveur disposant de plus de ressources système que celles dont vous disposez localement, ce qui peut offrir une plus grande flexibilité lors de l’exécution de grandes applications.

      Dans ce tutoriel, vous allez conteneuriser Mozilla Thunderbird, un client de messagerie électronique, en utilisant Docker. Ensuite, vous le sécuriserez et lui donnerez un accès à distance en utilisant le serveur web de Caddy.

      Lorsque vous aurez terminé, vous pourrez accéder à Thunderbird depuis n’importe quel appareil en utilisant simplement un navigateur web. En option, vous pourrez également accéder localement aux fichiers de ce site en utilisant WebDAV. Vous aurez également une image de Docker entièrement autonome que vous pourrez exécuter n’importe où.

      Conditions préalables

      Avant de commencer ce guide, vous aurez besoin de ce qui suit :

      Étape 1 &mdash ; Créer la Configuration de supervisord

      Maintenant que votre serveur fonctionne et que Docker est installé, vous êtes prêt à commencer à configurer le conteneur de votre application. Comme votre conteneur est constitué de plusieurs composants, vous devez utiliser un gestionnaire de processus pour les lancer et les surveiller. Ici, vous utiliserez supervisord. supervisord est un gestionnaire de processus écrit en Python qui est souvent utilisé pour orchestrer des conteneurs complexes. 

      Tout d’abord, créez et entrez un répertoire appelé thunderbird pour votre conteneur : 

      • mkdir ~/thunderbird
      • cd ~/thunderbird

      Maintenant, créez et ouvrez un fichier appelé supervisord.conf utilisant nano ou votre éditeur préféré :

      Ajoutez maintenant ce premier bloc de code dans supervisord.conf, qui définira les options globales de supervisord :

      ~/thunderbird/supervisord.conf

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

      Dans ce bloc, vous configurez supervisord lui-même. Vous devez mettre nodaemon sur true parce qu’il sera placé à l’intérieur d’un conteneur Docker comme point d’entrée. Par conséquent, vous voulez qu’il reste au premier plan. Vous mettez également en place pidfile vers un chemin accessible par un non-root user (nous y reviendrons plus tard), et logfile vers stdout pour que vous puissiez voir les journaux. 

      Ensuite, ajoutez un autre petit bloc de code à supervisord.conf. Ce bloc démarre TigerVNC, qui est un serveur combiné VNC/X11 :

      ~/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
      

      Dans ce bloc, vous configurez le serveur X11. X11 est un protocole de serveur d’affichage, qui permet aux applications graphiques de s’exécuter. Notez qu’à l’avenir il sera remplacé par Wayland, mais l’accès à distance est encore en développement.

      Pour ce conteneur, vous utilisez TigerVNC et son serveur VNC intégré. Cela présente un certain nombre d’avantages par rapport à l’utilisation d’un serveur X11 et VNC séparé :

      • Temps de réponse plus rapide, car le dessin de l’interface graphique est fait directement sur le serveur VNC plutôt que d’être fait sur un framebuffer intermédiaire (la mémoire qui stocke le contenu de l’écran).
      • Le redimensionnement automatique de l’écran, qui permet à l’application distante de se redimensionner automatiquement en fonction du client (dans ce cas, la fenêtre de votre navigateur web).

      Si vous le souhaitez, vous pouvez changer l’argument pour l’option -desktop de Thunderbird à quelque chose d’autre de votre choix. Le serveur affichera votre choix comme titre de la page web utilisée pour l’accès à votre application.

      Maintenant, ajoutons un troisième bloc de code à supervisord.conf pour démarrer easy-novnc : 

      ~/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
      

      Dans ce bloc, vous mettez en place easy-novncun serveur autonome qui fournit une wrapper autour de noVNC Ce serveur joue deux rôles. Tout d’abord, il fournit une page de connexion simple qui vous permet de configurer des options pour la connexion, et vous permet de définir des options par défaut. Deuxièmement, il permet à VNC de se substituer à WebSocket, qui permet d’y accéder au moyen d’un navigateur web ordinaire. 

      Habituellement, le redimensionnement se fait du côté client (c’est-à-dire la mise à l’échelle de l’image), mais vous utilisez l’option resize=remote pour profiter pleinement des ajustements de la résolution à distance de TigerVNC. Cela permet également de réduire la latence sur les appareils plus lents, tels que les Chromebooks bas de gamme :

      Note : Ce tutoriel utilise easy-novnc. Si vous le souhaitez, vous pouvez utiliser websockify et un serveur web séparé à la place. L’avantage d’easy-novnc est que l’utilisation de la mémoire et le temps de démarrage sont nettement plus faibles et que c’est autonome. easy-novnc fournit également une page de connexion plus propre que celle par défaut de noVNC et permet de définir des options par défaut qui sont utiles pour cette configuration (telles que resize=remote).

      Ajoutez maintenant le bloc suivant à votre configuration pour lancer OpenBox, le gestionnaire de fenêtres :

      ~/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
      

      Dans ce bloc, vous mettez en place OpenBox, un gestionnaire léger de fenêtres X11. Vous pouvez sauter cette étape, mais sans elle, vous n’auriez pas de barres de titre ou ne pourriez pas redimensionner les fenêtres.

      Enfin, ajoutons le dernier bloc à supervisord.conf, qui lancera l’application principale : 

      ~/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
      

      Dans ce dernier bloc, vous fixez la priorité à 1 pour s’assurer que Thunderbird se lance après TigerVNC, sinon il rencontrerait une condition de course et ne démarrerait pas au hasard. Nous avons également réglé autorestart=true pour rouvrir automatiquement l’application si elle se ferme par erreur. La variable d’environnement DISPLAY indique à l’application de s’afficher sur le serveur VNC que vous avez configuré précédemment.

      Voici ce à quoi votre supervisord.conf complété ressemblera : 

      ~/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
      

      Si vous voulez conteneuriser une autre demande, remplacez /usr/bin/thunderbird avec le chemin d’accès à l’exécutable de votre application. Sinon, vous êtes maintenant prêt à configurer le menu principal de votre interface graphique.

      Maintenant que votre gestionnaire de processus est configuré, mettons en place le menu de l’OpenBox. Ce menu nous permet de lancer des applications à l’intérieur du conteneur. Nous inclurons également un terminal et un moniteur de processus pour le débogage, si nécessaire.

      Dans le répertoire de votre candidature, utilisez nano ou votre éditeur de texte préféré pour créer et ouvrir un nouveau fichier appelé menu.xml: 

      • nano ~/thunderbird/menu.xml

      Ajoutez maintenant le code suivant à menu.xml:

      ~/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>
      

      Ce fichier XML contient les éléments de menu qui apparaîtront lorsque vous ferez un clic droit sur le bureau. Chaque élément est constitué d’une étiquette et d’une action.

      Si vous voulez conteneuriser une autre demande, remplacez /usr/bin/thunderbird avec le chemin d’accès à l’exécutable de votre application et modifiez le label de l’article. 

      Étape 3 &mdash ; Créer le Dockerfile

      Maintenant que l’OpenBox est configurée, vous allez créer le Dockerfile, qui relie tout.

      Créez un Dockerfile dans le répertoire de votre conteneur :

      • nano ~/thunderbird/Dockerfile

      Pour commencer, ajoutons un peu de code pour élaborer easy-novnc: 

      ~/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
      

      Dans un premier temps, vous construisez easy-novnc. Cela se fait dans une étape séparée pour des raisons de simplicité et de gain d’espace &mdash ; vous n’avez pas besoin de toute la chaîne d’outils Go dans votre image finale. Notez le @v1.1.0 dans la commande de construction. Cela garantit que le résultat est déterministe, ce qui est important car Docker met en cache le résultat de chaque étape. Si vous n’aviez pas spécifié de version explicite, Docker ferait référence à la dernière version d’easy-novnc au moment où l’image a été construite pour la première fois. En outre, vous voulez vous assurer que vous téléchargez une version spécifique de easy-novnc, au cas où des modifications de rupture seraient apportées à l’interface CLI. 

      Créons maintenant la deuxième étape, qui deviendra l’image finale. Ici, vous utiliserez Debian 10 (buster) comme image de base. Notez que, comme il s’exécute dans un conteneur, il fonctionnera quelle que soit la distribution que vous utilisez sur votre serveur.

      Ensuite, ajoutez le bloc suivant à votre Dockerfile: 

      ~/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
      

      Dans cette instruction, vous installez Debian 10 comme image de base, puis vous installez le strict minimum requis pour exécuter des applications graphiques dans votre conteneur. Notez que vous exécutez apt-get update dans le cadre de la même instruction, pour éviter les problèmes de mise en cache de Docker. Pour gagner de la place, vous supprimez également les listes de paquets téléchargées par la suite (les paquets mis en cache sont eux-mêmes supprimé par défaut). Vous créez également /usr/share/desktop-directories car certaines applications dépendent du répertoire existant.

      Ajoutons un autre petit bloc de code :

      ~/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
      

      Dans cette instruction, vous installez des utilitaires et des paquets utiles à usage général. Les points suivants présentent un intérêt particulier xdg-utils (qui fournit les commandes de base utilisées par les applications de bureau sous Linux) et ca-certificates (qui installe les certificats racine pour nous permettre d’accéder aux sites HTTPS). 

      Maintenant, nous pouvons ajouter les instructions pour la demande principale :

      ~/thunderbird/Dockerfile

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

      Comme auparavant, nous installons ici l’application. Si vous conteneurisez une autre application, vous pouvez remplacer ces commandes par celles nécessaires à l’installation de votre application spécifique. Certaines applications nécessiteront un peu plus de travail pour fonctionner dans Docker. Par exemple, si vous installez une application qui utilise Chrome, Chromium, ou QtWebEngine, vous devrez utiliser l’argument de la ligne de commande --no-sandbox parce qu’il ne sera pas soutenu au sein de Docker. 

      Ensuite, commençons à ajouter les instructions pour ajouter les derniers fichiers dans le conteneur :

      ~/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
      

      Ici, vous ajoutez à l’image les fichiers de configuration que vous avez créés précédemment et vous copiez le binaire easy-novnc de la première étape.

      Le bloc de code suivant crée le répertoire de données et ajoute un utilisateur dédié à votre application. Ceci est important, car certaines applications refusent de s’exécuter en tant que root. Il est également bon de ne pas exécuter les applications en tant que root, même dans un conteneur.

      ~/thunderbird/Dockerfile

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

      Pour assurer la cohérence des UID/GID pour les fichiers, vous fixez explicitement les deux à 1000. Vous montez également un volume sur le répertoire de données pour vous assurer qu’il persiste entre les redémarrages.

      Enfin, ajoutons les instructions pour tout lancer :

      ~/thunderbird/Dockerfile

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

      En réglant la commande par défaut sur supervisord, le gestionnaire lancera les processus nécessaires à l’exécution de votre application. Dans ce cas, vous utilisez CMD plutôt qu’ENTRYPOINT. Dans la plupart des cas, cela ne ferait pas de différence, mais l’utilisation de CMD est plus adaptée à cette fin, pour plusieurs raisons. Premièrement, supervisord ne prend pas d’arguments qui seraient pertinents pour nous, et si vous fournissez des arguments au conteneur, ils remplacent CMD et sont annexés à ENTRYPOINT.  Deuxièmement, l’utilisation de CMD nous permet de fournir une commande entièrement différente (qui sera exécutée par /bin/sh -c) lors du passage des arguments au conteneur, ce qui rend le débogage plus facile.

      Et enfin, vous devez exécuterchown comme root avant de démarrer supervisord pour éviter les problèmes d’autorisation sur le volume de données et pour permettre aux processus enfant d’ouvrir stdout. Cela signifie également que vous devez utiliser gosu au lieu de l’instruction USER pour changer d’utilisateur. 

      Voici ce à quoi votre Dockerfile complété ressemblera :

      ~/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"]
      

      Sauvegardez et fermez votre Dockerfile. Nous sommes maintenant prêts à construire et à faire fonctionner notre conteneur, puis à accéder à Thunderbird &mdash, une application GUI.

      Étape 4 &mdash ; Création et utilisation du conteneur

      L’étape suivante consiste à construire votre conteneur et à le mettre en marche au démarrage. Vous mettrez également en place un volume pour préserver les données de l’application entre les redémarrages et les mises à jour.

      Construisez d’abord votre conteneur. Veillez à exécuter ces commandes dans le répertoire ~/thunderbird :

      • docker build -t thunderbird .

      Créez maintenant un nouveau réseau qui sera partagé entre les conteneurs de l’application :

      • docker network create thunderbird-net

      Créez ensuite un volume pour stocker les données de l’application :

      • docker volume create thunderbird-data

      Enfin, lancez-le et réglez-le pour qu’il redémarre automatiquement :

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

      Notez que si vous le souhaitez, vous pouvez remplacer le thunderbird-app après l’option --name par un nom différent. Quel que soit votre choix, votre application est maintenant conteneurisée et en cours d’exécution. Utilisons maintenant le serveur web Caddy pour le sécuriser et nous y connecter à distance.

      Étape 5 &mdash ; Mise en place de Caddy

      Au cours de cette étape, vous configurerez le serveur web Caddy pour fournir une authentification et, éventuellement, un accès à distance aux fichiers via WebDAV. Par souci de simplicité, et pour vous permettre de l’utiliser avec votre proxy inverse existant, vous le ferez fonctionner dans un autre conteneur.

      Créez un nouveau répertoire et déplacez-vous à l’intérieur de celui-ci :

      Créez maintenant un nouveau Dockerfile en utilisant nano ou votre éditeur préféré :

      Ajoutez ensuite les directives suivantes :

      ~/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"]
      

      Ce Dockerfile construit Caddy avec le plugin WebDAV activé, puis le lance sur le port 8080 avec le Caddyfile dans /etc/Caddyfile. Enregistrez et fermez le fichier.

      Ensuite, vous allez configurer le serveur web de Caddy. Créez un fichier nommé Caddyfile dans le répertoire que vous venez de créer :

      Ajoutez maintenant le bloc de code suivant à votre Caddyfile :

      ~/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}
          }
      }
      

      Ce Caddyfile est un proxy du répertoire root vers le conteneur thunderbird-app que vous avez créé à l’étape 4 (le Docker le résout en l’IP correcte). Il servira également de navigateur de fichiers en lecture seule sur /files et fera fonctionner un serveur WebDAV sur /webdav que vous pourrez monter localement pour accéder à vos fichiers. Le nom d’utilisateur et le mot de passe sont lus à partir des variables d’environnement APP_USERNAME et APP_PASSWORD_HASH. 

      Maintenant, construisez le conteneur :

      • docker build -t thunderbird-caddy .

      Caddy v.2 vous demande de hacher le mot de passe que vous souhaitez. Exécutez la commande suivante et n’oubliez pas de remplacer mypass avec un mot de passe fort de votre choix : 

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

      Cette commande produira une chaîne de caractères. Copiez ceci dans votre presse-papiers en préparation de l’exécution de la prochaine commande.

      Vous êtes maintenant prêt à faire fonctionner le conteneur. Veillez à remplacer myuser avec un nom d’utilisateur de votre choix, et remplacez mypass-hash par la sortie de la commande que vous avez exécutée à l’étape précédente. Vous pouvez également changer le port (8080 ici) pour accéder à votre serveur sur un port différent : 

      • 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

      Nous sommes maintenant prêts à accéder et à tester notre application.

      Étape 6 &mdash ; Tester et gérer l’application

      Accédez à votre application et assurez-vous qu’elle fonctionne.

      Ouvrez d’abord http://votre_serveur_ip:8080 dans un navigateur web, connectez-vous avec les identifiants que vous avez choisis auparavant, et cliquez sur Connect. 

      Page de connexion NoVNC 

      Vous devriez maintenant être en mesure d’interagir avec l’application, et celle-ci devrait automatiquement se redimensionner pour s’adapter à la fenêtre de votre navigateur.

      Menu principal de Thunderbird

      Si vous faites un clic droit sur le bureau noir, vous devriez voir un menu qui vous permet d’accéder à un terminal. Si vous cliquez avec le bouton du milieu de la souris, vous devriez voir une liste de fenêtres.

      Clic droit sur NoVNC

      Ouvrez maintenant http://votre_serveur_ip:8080/files/ dans un navigateur web. Vous devriez pouvoir accéder à vos fichiers.

      Accès au fichier NoVNC webdav

      En option, vous pouvez essayer de monter http://your_server_ip:8080/webdav/ dans un client WebDAV. Vous devez pouvoir accéder à vos fichiers et les modifier directement. Si vous utilisez l’option de carte lecteur réseau dans l’explorateur Windows, vous devrez soit utiliser un mandataire inverse pour ajouter le HTTPS, ou définir HKLMSYSTEMCurrentControlSetServicesClientWebParametersBasicAuthLevel à DWORD:2. 

      Dans les deux cas, votre application GUI native est maintenant prête à être utilisée à distance.

      Conclusion

      Vous avez maintenant configuré avec succès un conteneur Docker pour Thunderbird et ensuite, à l’aide de Caddy, vous avez configuré l’accès à ce conteneur via un navigateur web. Si jamais vous devez mettre à jour votre application, arrêtez les conteneurs, exécutez docker rm thunderbird-app thunderbird-web, reconstruisez les images, puis relancez les commandes d’exécution du docker à partir des étapes précédentes ci-dessus. Vos données seront toujours préservées puisqu’elles sont stockées dans un volume.

      Si vous voulez en savoir plus sur les commandes de base du Docker, vous pouvez lire ceci tutoriel ou cette fiche d’aide. Pour une utilisation à plus long terme, vous pouvez également envisager d’activer le HTTPS (qui nécessite un domaine) pour une sécurité supplémentaire.

      En outre, si vous déployez plus d’une application, vous pouvez utiliser Docker Compose ou Kubernetes au lieu de démarrer chaque conteneur manuellement. Et n’oubliez pas que ce tutoriel peut servir de base pour exécuter toute autre application Linux sur votre serveur, y compris :

      • Wine, une couche de compatibilité pour l’exécution d’applications Windows sous Linux.
      • GIMP, un éditeur d’images open-source.
      • Cutter, une plateforme de rétro-ingénierie open-source.

      Cette dernière option démontre le grand potentiel de la conteneurisation et de l’accès à distance aux applications GUI. Grâce à cette configuration, vous pouvez désormais utiliser un serveur doté d’une puissance de calcul considérablement plus importante que celle dont vous disposez localement pour faire fonctionner des outils gourmands en ressources comme Cutter.



      Source link

      Como acessar remotamente aplicações GUI usando Docker e Caddy no Ubuntu 18.04


      O autor selecionou o Free and Open Source Fund para receber uma doação como parte do programa Write for DOnations.

      Introdução

      Mesmo com a crescente popularidade dos serviços em nuvem, a necessidade de executar aplicações nativas ainda existe.

      Utilizando o noVNC e o TigerVNC, você pode executar aplicações nativas dentro de um contêiner Docker e acessá-las remotamente usando um navegador Web. Além disso, você pode executar sua aplicação em um servidor com mais recursos de sistema do que você pode ter disponível localmente, o que pode fornecer maior flexibilidade ao se executar grandes aplicações.

      Neste tutorial, você irá conteinerizar o Mozilla Thunderbird, um cliente de e-mail usando o Docker. Depois, você irá protegê-lo e fornecer acesso remoto usando o servidor Web Caddy.

      Quando você terminar, você será capaz de acessar o Thunderbird a partir de qualquer dispositivo usando apenas um navegador Web. Opcionalmente, você também poderá acessar localmente os arquivos dele usando o WebDAV. Você também terá uma imagem Docker totalmente independente que você pode executar em qualquer lugar.

      Pré-requisitos

      Antes de iniciar este guia, você precisará do seguinte:

      • Um servidor Ubuntu 18.04 com pelo menos 2GB RAM e 4GB de espaço em disco.
      • Um usuário non root com privilégios sudo.
      • O Docker configurado em seu servidor. Você pode seguir o tutorial How To Install and Use Docker on Ubuntu 18.04.

      Passo 1 – Criando a configuração do supervisord

      Agora que seu servidor está em execução e o Docker está instalado, você está pronto para começar a configuração do contêiner da sua aplicação. Como seu contêiner consiste em vários componentes, você precisa usar um gerenciador de processos para iniciá-los e monitorá-los. Aqui, você estará usando o supervisord. O supervisord é um gerenciador de processos escrito em Python que é frequentemente usado para orquestrar contêineres complexos.

      Primeiro, crie e entre em um diretório chamado thunderbird para seu contêiner:

      • mkdir ~/thunderbird
      • cd ~/thunderbird

      Agora crie e abra um arquivo chamado supervisord.conf usando o nano ou o seu editor preferido:

      Agora adicione este primeiro bloco de código em supervisord.conf, que definirá as opções globais para o supervisord:

      ~/thunderbird/supervisord.conf

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

      Neste bloco, você está configurando o supervisord propriamente. Você precisa definir o nodaemon para true porque ele estará executando dentro de um contêiner Docker como o entrypoint. Portanto, você vai querer que ele permaneça em execução em primeiro plano. Você também está definindo o pidfile para um caminho acessível por um usuário não-root (mais sobre isso posteriormente), e o logfile para stdout para que você possa ver os logs.

      Em seguida, adicione outro pequeno bloco de código ao supervisord.conf. Este bloco inicia o TigerVNC, que é um servidor VNC/X11 combinado:

      ~/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
      

      Neste bloco, você está configurando o servidor X11. O X11 é um protocolo de servidor de exibição, que é o que permite que as aplicações GUI sejam executadas. Observe que no futuro ele será substituído pelo Wayland, mas o acesso remoto ainda está em desenvolvimento.

      Para este contêiner você está usando o TigerVNC e seu servidor VNC embutido. Isso tem uma série de vantagens em relação ao uso de um servidor X11 e VNC separados:

      • Tempo de resposta mais rápido, uma vez que o desenho da GUI é feito diretamente no servidor VNC em vez de ser feito em um framebuffer intermediário (a memória que armazena o conteúdo da tela).
      • Redimensionamento automático da tela, que permite que a aplicação remota seja redimensionada automaticamente para caber no cliente (nesse caso, na janela do navegador Web).

      Se você desejar, você pode alterar o argumento para a opção -desktop a partir do Thunderbird para outra coisa de sua escolha. O servidor exibirá sua escolha como o título da página Web usada para acessar sua aplicação.

      Agora, vamos adicionar um terceiro bloco de código ao supervisord.conf para iniciar o easy-novnc:

      ~/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
      

      Neste bloco, você está configurando o easy-novnc, um servidor standalone que fornece um encapsulamento em torno do noVNC. Este servidor executa dois papéis. Primeiro, ele fornece uma página de conexão simples que lhe permite configurar opções para a conexão e definir as opções padrão. Segundo, ele faz proxy do VNC no WebSocket, que o permite ser acessado através de um navegador Web comum.

      Normalmente, o redimensionamento é feito no lado do cliente (ou seja, a escala de imagem), mas você está usando a opção resize=remote para tirar a vantagem total dos ajustes de resolução remota do TigerVNC. Isso também fornece menor latência em dispositivos mais lentos, como os Chromebooks de entrada:

      Nota: Este tutorial usa o easy-novnc. Se você desejar, você pode usar o websockify e um servidor Web separado. A vantagem do easy-novnc é que o uso da memória e o tempo de inicialização são significativamente mais baixos e ele é auto-contido. O easy-novnc também fornece uma página de conexão mais limpa do que o noVNC padrão e permite definir opções padrão que são úteis para esta configuração (como o resize=remote).

      Agora adicione o seguinte bloco à sua configuração para iniciar o OpenBox, o gerenciador de janelas:

      ~/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
      

      Neste bloco, você está configurando o OpenBox, um gerenciador de janelas X11 leve. Você poderia ignorar este passo, mas sem ele, você não teria barras de título ou seria capaz de redimensionar janelas.

      Finalmente, vamos adicionar o último bloco ao supervisord.conf, que irá iniciar a aplicação principal:

      ~/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
      

      Neste bloco final, você está definindo priority para 1 para garantir que o Thunderbird inicie depois do TigerVNC, ou ele encontraria uma condição de corrida e falharia aleatoriamente ao iniciar. Também definimos autorestart=true para reabrir a aplicação automaticamente se ela fechar erroneamente. A variável de ambiente DISPLAY diz à aplicação para exibir no servidor VNC que você configurou anteriormente.

      Veja como seu supervisord.conf finalizado vai ficar:

      ~/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
      

      Se você quiser conteinerizar uma aplicação diferente, substitua /usr/bin/thunderbird pelo caminho para o executável da sua aplicação. Caso contrário, você está pronto para configurar o menu principal da sua GUI.

      Passo 2 – Configurando o menu do OpenBox

      Agora que seu gerenciador de processos está configurado, vamos configurar o menu do OpenBox. Este menu nos permite lançar aplicações dentro do contêiner. Também incluiremos um terminal e monitor de processos para depuração, se necessário.

      Dentro do diretório da sua aplicação, use o nano ou o seu editor de texto favorito para criar e abrir um novo arquivo chamado menu.xml:

      • nano ~/thunderbird/menu.xml

      Agora adicione o seguinte código ao menu.xml:

      ~/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>
      

      Este arquivo XML contém os itens de menu que aparecerão quando você clicar com o botão direito no desktop. Cada item consiste em uma etiqueta e em uma ação.

      Se você quiser conteinerizar uma aplicação diferente, substitua /usr/bin/thunderbird pelo caminho para o executável da sua aplicação e altere o label do item.

      Passo 3 – Criando o Dockerfile

      Agora que o OpenBox está configurado, você criará o Dockerfile, que une tudo que vimos.

      Crie um Dockerfile no diretório do seu contêiner:

      • nano ~/thunderbird/Dockerfile

      Para começar, vamos adicionar código para criar o easy-novnc:

      ~/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
      

      No primeiro estágio, você está compilando o easy-novnc. Isso é feito em um estágio separado por simplicidade e para salvar espaço – você não precisa da cadeia de ferramentas Go inteira em sua imagem final. Observe o @v1.1.0 no comando de compilação. Isso garante que o resultado seja determinístico, o que é importante porque o Docker faz cache do resultado de cada passo. Se você não tivesse especificado uma versão explícita, o Docker faria referência à versão mais recente do easy-novnc no momento em que a imagem foi construída pela primeira vez. Além disso, você deseja garantir que você baixe uma versão específica do easy-novnc, no caso de alterações recentes na interface CLI.

      Agora vamos criar o segundo estágio, que se tornará a imagem final. Aqui você estará usando o Debian 10 (buster) como a imagem base. Observe que como isso está em execução em um contêiner, ele funcionará independentemente da distribuição que você está executando em seu servidor.

      Em seguida, adicione o seguinte bloco ao seu Dockerfile:

      ~/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
      

      Nesta instrução, você está instalando o Debian 10 como sua imagem base e instalando o mínimo necessário para executar aplicações GUI em um contêiner. Observe que você executa apt-get update como parte da mesma instrução para evitar problemas de cache do Docker. Para economizar espaço, você também está removendo as listas de pacotes baixadas depois (os pacotes em cache são removidos por padrão). Você também está criando /usr/share/desktop-directories porque algumas aplicações dependem do diretório existente.

      Vamos adicionar outro pequeno bloco de código:

      ~/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
      

      Nesta instrução, você está instalando alguns utilitários e pacotes de utilidade geral. De interesse particular aqui estão o xdg-utils (que fornece os comandos base usados pelas aplicações desktop no Linux) e os ca-certificates (que instalam os certificados raiz para nos permitir acessar sites HTTPS).

      Agora, podemos adicionar as instruções para a aplicação principal:

      ~/thunderbird/Dockerfile

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

      Como antes, aqui estamos instalando a aplicação. Se você estiver conteinerizando uma aplicação diferente, você pode substituir esses comandos por aqueles necessários para instalar seu app específico. Algumas aplicações irão exigir um pouco mais de trabalho para executar dentro do Docker. Por exemplo, se você estiver instalando um app que usa o Chrome, Chromium ou o QtWebEngine, você precisará usar o argumento da linha de comando --no-sandbox porque ele não será suportado dentro do Docker.

      Em seguida, vamos começar a adicionar as instruções para adicionar os últimos arquivos ao contêiner:

      ~/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
      

      Aqui você está adicionando os arquivos de configuração que você criou anteriormente à imagem e copiando o binário easy-novnc do primeiro estágio.

      Este próximo bloco de código cria o diretório de dados e adiciona um usuário dedicado para o seu app. Isto é importante porque algumas aplicações se recusam a serem executados como root. Também é uma boa prática não executar aplicações como root, mesmo em um contêiner.

      ~/thunderbird/Dockerfile

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

      Para garantir um UID/GID consistente para os arquivos, você está configurando ambos explicitamente para 1000. Você também está montando um volume no diretório de dados para garantir que ele persista entre reinicializações.

      Finalmente, vamos adicionar as instruções de lançamento.

      ~/thunderbird/Dockerfile

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

      Ao definir o comando padrão para supervisord, o gerenciador irá lançar os processos necessários para executar sua aplicação. Neste caso, você está usando CMD em vez de ENTRYPOINT. Na maioria dos casos, isso não faria diferença, mas usar o CMD é mais adequado para este propósito por algumas razões. Primeiro, o supervisord não aceita quaisquer argumentos relevantes para nós, e se você fornecer argumentos ao contêiner eles substituem o CMD e são anexados ao ENTRYPOINT. Segundo, usar o CMD nos permite fornecer um comando inteiramente diferente (que será executado por /bin/sh -c) ao passar argumentos para o contêiner, o que torna a depuração mais fácil.

      E, finalmente, você precisa executar o chown como root antes de iniciar o supervisord para evitar problemas de permissão no volume de dados e para permitir que os processos filhos abram o stdout. Isso também significa que você precisa usar gosu em vez da instrução USER para trocar o usuário.

      Aqui está como o seu Dockerfile finalizado vai parecer:

      ~/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"]
      

      Salve e feche seu Dockerfile. Agora estamos prontos para compilar e executar nosso contêiner e, em seguida, acessar o Thunderbird – uma aplicação GUI.

      Passo 4 – Compilando e executando o contêiner

      O próximo passo é compilar seu contêiner e configurá-lo para executar na inicialização. Você também irá configurar um volume para preservar os dados da aplicação entre reinicializações e atualizações.

      Primeiro compile seu contêiner. Certifique-se de executar esses comandos no diretório ~/thunderbird:

      • docker build -t thunderbird .

      Agora crie uma nova rede que será compartilhada entre os contêineres da aplicação:

      • docker network create thunderbird-net

      Em seguida, crie um volume para armazenar os dados da aplicação:

      • docker volume create thunderbird-data

      Finalmente, execute-a e defina-a para reinicializar automaticamente:

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

      Observe que se você quiser, você pode substituir o thunderbird-app após a opção --name por um nome diferente. Seja o que for que você escolheu, sua aplicação está agora conteinerizada e em execução. Agora vamos usar o servidor Web Caddy para protegê-la e conectar-se remotamente a ela.

      Passo 5 – Configurando o Caddy

      Neste passo, você irá configurar o servidor Web Caddy para fornecer autenticação e, opcionalmente, acesso remoto a arquivos através do WebDAV. Por simplicidade, e para lhe permitir utilizá-lo com seu proxy reverso existente, você irá executá-lo em um outro contêiner

      Crie um novo diretório e então mova-se para ele:

      Agora crie um novo Dockerfile usando o nano ou o seu editor preferido:

      Então, adicione as seguintes diretivas:

      ~/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"]
      

      Este Dockerfile compila o Caddy com o plug-in WebDAV habilitado e, em seguida, o lança na porta 8080 com o Caddyfile em /etc/Caddyfile. Salve e feche o arquivo.

      Em seguida, você irá configurar o servidor Web Caddy. Crie um arquivo chamado Caddyfile no diretório que você acabou de criar:

      Agora adicione o seguinte bloco de código ao seu Caddyfile:

      ~/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}
          }
      }
      

      Este Caddyfile faz proxy do diretório raiz para o contêiner thunderbird-app que você criou no Passo 4 (o Docker o resolve para o IP correto). Ele também irá fornecer um navegador de arquivos baseado em web somente leitura em /files e executar um servidor WebDAV em /webdav, que você pode montar localmente para acessar seus arquivos. O nome de usuário e a senha são lidos a partir das variáveis de ambiente APP_USERNAME e APP_PASSWORD_HASH.

      Agora compile o contêiner:

      • docker build -t thunderbird-caddy .

      O Caddy v.2 requer que você faça um hash da sua senha desejada. Execute o seguinte comando e lembre-se de substituir mypass por uma senha forte da sua escolha:

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

      Este comando irá exibir uma string de caracteres. Copie isso para sua área de transferência em preparação para executar o próximo comando.

      Agora tudo está pronto para executar o contêiner. Certifique-se de substituir myuser por um nome de usuário da sua escolha e substitua mypass-hash pela saída do comando que você executou no passo anterior. Você também pode alterar a porta (8080 aqui) para acessar seu servidor em uma porta diferente:

      • 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

      Agora estamos prontos para acessar e testar nossa aplicação.

      Passo 6 – Testando e gerenciando a aplicação

      Vamos acessar sua aplicação e garantir que ela está funcionando.

      Primeiro, abra http://your_server_ip:8080 em um navegador Web, faça login com as credenciais que você escolheu anteriormente, e clique em Connect.

      NoVNC connect page

      Agora você deve ser capaz de interagir com a aplicação, e ela deve redimensionar automaticamente para se encaixar na janela do seu navegador.

      Thunderbird main menu

      Se você clicar com o botão direito no desktop preto, você deve ver um menu que lhe permite acessar um terminal. Se você clicar com o botão do meio, verá uma lista de janelas.

      NoVNC right click

      Agora abra http://your_server_ip:8080/files/ em um navegador. Você deve ser capaz de acessar seus arquivos.

      NoVNC file access webdav

      Opcionalmente, você pode tentar montar http://your_server_ip:8080/webdav/ em um cliente WebDAV. Você deve ser capaz de acessar e modificar seus arquivos diretamente. Se você usar a opção Mapear unidade de rede no Windows Explorer, você precisará usar um proxy reverso para adicionar HTTPS ou definir HKLMSYSTEMCurrentControlSetServicesWebClientParametersBasicAuthLevel para DWORD:2.

      Em ambos os casos, sua aplicação GUI nativa está pronta para uso remoto.

      Conclusão

      Agora você configurou com êxito um contêiner Docker para o Thunderbird e, em seguida, usando o Caddy, você configurou o acesso a ele através de um navegador Web. Se você precisar atualizar sua aplicação, pare os contêineres, execute docker rm thunderbird-app thunderbird-web, recompile as imagens e, em seguida, execute novamente os comandos docker run das etapas anteriores acima. Seus dados ainda serão preservados uma vez que eles são armazenados em um volume.

      Se você quiser aprender mais sobre comandos básicos do Docker, você pode ler este tutorial ou esse guia de consulta rápida. Para uso a longo prazo, convém habilitar o HTTPS (isso requer um domínio) para segurança adicional.

      Além disso, se você estiver implantando mais de uma aplicação, você pode querer usar o Docker Compose ou o Kubernetes em vez de iniciar cada contêiner manualmente. E lembre-se, este tutorial pode servir como base para executar qualquer outra aplicação Linux em seu servidor, incluindo:

      • Wine , uma camada de compatibilidade para executar aplicações Windows no Linux.
      • GIMP, um editor de imagem de código aberto.
      • Cutter, uma plataforma de engenharia reversa de código aberto.

      Esta última opção demonstra o grande potencial de conteinerizar e acessar remotamente aplicações GUI. Com esta configuração, agora você usa um servidor com mais poder de computação do que localmente. Com isso, você executa ferramentas com consumo intensivo de recursos como o Cutter.



      Source link