Cómo acceder de forma remota a aplicaciones GUI mediante Docker y Caddy en Debian 9

El autor seleccionó el Fondo de Código Libre y Abierto para recibir una donación como parte del programa Write for DOnations.

Introducción

Incluso con la creciente popularidad de los servicios en la nube, todavía existe la necesidad de ejecutar aplicaciones nativas.

Al usar noVNC y TigerVNC, puede ejecutar aplicaciones nativas dentro de un contenedor Docker y acceder a ellas de forma remota mediante un navegador web. Además, puede ejecutar su aplicación en un servidor con más recursos del sistema de los que podría tener disponibles localmente, lo que puede proporcionar una mayor flexibilidad al ejecutar aplicaciones de gran tamaño.

En este tutorial, utilizarás Docker para contenerizar Mozilla Thunderbird, un cliente de correo electrónico. Luego, lo protegerás y proporcionarás acceso remoto mediante el servidor web Caddy.

Cuando hayas terminado, podrás acceder a Thunderbird desde cualquier dispositivo usando solo un navegador web. Opcionalmente, también podrás acceder localmente a los archivos desde allí usando WebDAV. También tendrás una imagen de Docker completamente autónoma que podrás ejecutar en cualquier lugar.

Prerrequisitos

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

• Un servidor Debian 9 con al menos 2 GB de RAM y 4 GB de espacio en disco.
• Un usuario no root con sudoprivilegios.
• Docker está instalado en tu servidor. Puedes seguir el procedimiento Cómo instalar y usar Docker en Debian 9.

Paso 1: creación de la supervisordconfiguración

Ahora que su servidor está en funcionamiento y Docker está instalado, está listo para comenzar a configurar el contenedor de su aplicación. Dado que su contenedor consta de varios componentes, debe utilizar un administrador de procesos para iniciarlos y monitorearlos. Aquí, utilizará supervisord. supervisordes un administrador de procesos escrito en Python que se utiliza a menudo para organizar contenedores complejos.

Primero, crea e ingresa un directorio llamado thunderbirdpara tu contenedor:

mkdir ~/thunderbird
cd ~/thunderbird

Ahora crea y abre un archivo llamado supervisord.confusando nanoo tu editor preferido:

nano ~/thunderbird/supervisord.conf

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

~/thunderbird/supervisord.conf

[supervisord]nodaemon=truepidfile=/tmp/supervisord.pidlogfile=/dev/fd/1logfile_maxbytes=0

En este bloque, se configura supervisorda sí mismo. Debe configurarlo nodaemonporque truese ejecutará dentro de un contenedor Docker como punto de entrada. Por lo tanto, desea que permanezca ejecutándose en primer plano. También está configurando pidfileuna ruta a la que pueda acceder un usuario que no sea root (más sobre esto más adelante) y logfilela salida estándar para poder ver los registros.

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

~/thunderbird/supervisord.conf

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

En este bloque, se configura el servidor X11. X11 es un protocolo de servidor de pantalla, que es lo que permite ejecutar aplicaciones GUI. Tenga en cuenta que en el futuro será reemplazado por Wayland, pero el acceso remoto aún está en desarrollo.

Para este contenedor, se utiliza TigerVNC y su servidor VNC integrado. Esto tiene varias ventajas con respecto al uso de un servidor X11 y VNC independientes:

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

Si lo desea, puede cambiar el argumento de la -desktopopción por Thunderbirdotro que elija. El servidor mostrará su elección como el título de la página web que se utiliza para acceder a su aplicación.

Ahora, agreguemos un tercer bloque de código para supervisord.confcomenzar easy-novnc:

~/thunderbird/supervisord.conf

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

En este bloque, se configura easy-novncun servidor independiente que proporciona un contenedor para noVNC. Este servidor cumple dos funciones. En primer lugar, proporciona una página de conexión simple que permite configurar opciones para la conexión y permite establecer las predeterminadas. En segundo lugar, hace de proxy de VNC sobre WebSocket, lo que permite acceder a él a través de un navegador web común.

Por lo general, el cambio de tamaño se realiza en el lado del cliente (es decir, el escalado de la imagen), pero estás usando la resize=remoteopción para aprovechar al máximo los ajustes de resolución remotos de TigerVNC. Esto también proporciona una latencia más baja en dispositivos más lentos, como Chromebooks de gama baja:

Nota: Este tutorial utiliza easy-novnc. Si lo desea, puede utilizar websockifyy un servidor web independiente en su lugar. La ventaja de easy-novnces que el uso de memoria y el tiempo de inicio son significativamente menores y que es autónomo. easy-novncTambién proporciona una página de conexión más clara que la predeterminada de noVNC y permite configurar opciones predeterminadas que son útiles para esta configuración (como resize=remote).

Ahora agregue el siguiente bloque a su configuración para iniciar OpenBox, el administrador de ventanas:

~/thunderbird/supervisord.conf

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

En este bloque, estás configurando OpenBox, un administrador de ventanas X11 liviano. Puedes omitir este paso, pero sin él, no tendrías barras de título ni podrías cambiar el tamaño de las ventanas.

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

~/thunderbird/supervisord.conf

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

En este bloque final, se configura prioritypara 1garantizar que Thunderbird se inicie después de TigerVNC, de lo contrario, se encontraría con una condición de carrera y fallaría aleatoriamente al iniciarse. También configuramos autorestart=truepara que se vuelva a abrir automáticamente la aplicación si se cierra por error. La DISPLAYvariable de entorno le indica a la aplicación que se muestre en el servidor VNC que configuró anteriormente.

Así es como supervisord.conflucirá una vez completado:

~/thunderbird/supervisord.conf

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

Si desea incluir en un contenedor una aplicación diferente, reemplácela /usr/bin/thunderbirdcon la ruta al ejecutable de su aplicación. De lo contrario, ya está listo para configurar el menú principal de su GUI.

Paso 2: Configuración del menú OpenBox

Ahora que el administrador de procesos está configurado, configuremos el menú de OpenBox. Este menú nos permite iniciar aplicaciones dentro del contenedor. También incluiremos una terminal y un monitor de procesos para depuración si es necesario.

Dentro del directorio de tu aplicación, utiliza nanotu editor de texto favorito para crear y abrir un nuevo archivo llamado menu.xml:

nano ~/thunderbird/menu.xml

Ahora agregue el siguiente código a menu.xml:

~/thunderbird/menu.xml

?xml version="1.0" encoding="utf-8"?openbox_menu  xmlns_xsi="http://www.w3.org/2001/XMLSchema-instance" xsi_schemaLocation="http://openbox.org/ file:///usr/share/openbox/menu.xsd"    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 al hacer clic con el botón derecho en el escritorio. Cada elemento consta de una etiqueta y una acción.

Si desea contener una aplicación diferente, reemplácela /usr/bin/thunderbirdcon la ruta al ejecutable de su aplicación y cambie el labeldel elemento.

Paso 3: creación del Dockerfile

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

Crea un Dockerfile en el directorio de tu contenedor:

nano ~/thunderbird/Dockerfile

Para comenzar, agreguemos algo de código para compilar easy-novnc:

~/thunderbird/archivo Docker

FROM golang:1.14-buster AS easy-novnc-buildWORKDIR /srcRUN 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ás construyendo easy-novnc. Esto se hace en una etapa separada para simplificar y ahorrar espacio; no necesitas toda la cadena de herramientas de Go en tu imagen final. Ten en cuenta el @v1.1.0en el comando de construcción. Esto garantiza que el resultado sea determinista, lo cual es importante porque Docker almacena en caché el resultado de cada paso. Si no hubieras especificado una versión explícita, Docker haría referencia a la última versión de easy-novncen el momento en que se construyó la imagen por primera vez. Además, debes asegurarte de descargar una versión específica de easy-novnc, en caso de que se realicen cambios importantes en la interfaz CLI.

Ahora vamos a crear la segunda etapa, que se convertirá en la imagen final. Aquí utilizará Debian 10 (Buster) como imagen base. Tenga en cuenta que, dado que se ejecuta en un contenedor, funcionará independientemente de la distribución que esté ejecutando en su servidor.

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

~/thunderbird/archivo Docker

...FROM debian:busterRUN 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, instalará Debian 10 como su imagen base y luego instalará el mínimo necesario para ejecutar aplicaciones GUI en su contenedor. Tenga en cuenta que ejecuta apt-get updatecomo parte de la misma instrucción para evitar problemas de almacenamiento en caché de Docker. Para ahorrar espacio, también está eliminando las listas de paquetes descargadas posteriormente (los paquetes almacenados en caché se eliminan de manera predeterminada). También está creando /usr/share/desktop-directoriesporque algunas aplicaciones dependen de la existencia del directorio.

Agreguemos otro pequeño bloque de código:

~/thunderbird/archivo Docker

...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 estas instrucciones, instalará algunas utilidades y paquetes de uso general útiles. De particular interés son xdg-utils(que proporciona los comandos básicos que utilizan las aplicaciones de escritorio en Linux) y ca-certificates(que instala los certificados raíz para permitirnos acceder a sitios HTTPS).

Ahora, podemos agregar las instrucciones para la aplicación principal:

~/thunderbird/archivo Docker

...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 estás creando un contenedor con otra aplicación, puedes reemplazar estos comandos con los necesarios para instalar tu aplicación específica. Algunas aplicaciones requerirán un poco más de trabajo para ejecutarse dentro de Docker. Por ejemplo, si estás instalando una aplicación que usa Chrome, Chromium o QtWebEngine, necesitarás usar el argumento de la línea de comandos --no-sandboxporque no será compatible dentro de Docker.

A continuación, comencemos a agregar las instrucciones para agregar los últimos archivos al contenedor:

~/thunderbird/archivo Docker

...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ás agregando los archivos de configuración que creaste anteriormente a la imagen y copiando el easy-novncbinario de la primera etapa.

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

~/thunderbird/archivo Docker

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

Para garantizar la coherencia UID/GIDde los archivos, se configuran explícitamente ambos valores en 1000. También se monta un volumen en el directorio de datos para garantizar que persista entre reinicios.

Por último, agreguemos las instrucciones para lanzar todo:

~/thunderbird/archivo Docker

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

Al configurar el comando predeterminado en supervisord, el administrador iniciará los procesos necesarios para ejecutar su aplicación. En este caso, está usando CMDen lugar de ENTRYPOINT. En la mayoría de los casos, no haría ninguna diferencia, pero using CMDes más adecuado para este propósito por algunas razones. Primero, supervisordno toma ningún argumento que sea relevante para nosotros y, si proporciona argumentos al contenedor, estos reemplazan CMDy se agregan a ENTRYPOINT. Segundo, using CMDnos permite proporcionar un comando completamente diferente (que será ejecutado por /bin/sh -c) al pasar argumentos al contenedor, lo que facilita la depuración.

Por último, debe ejecutar chowncomo root antes de comenzar supervisordpara evitar problemas de permisos en el volumen de datos y permitir que los procesos secundarios abran stdout. Esto también significa que debe usar gosuen lugar de la USERinstrucción para cambiar de usuario.

Así es como Dockerfilelucirá una vez completado:

~/thunderbird/archivo Docker

FROM golang:1.14-buster AS easy-novnc-buildWORKDIR /srcRUN go mod init build      go get github.com/geek1011/easy-novnc@v1.1.0      go build -o /bin/easy-novnc github.com/geek1011/easy-novncFROM debian:busterRUN 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-directoriesRUN 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/listsRUN apt-get update -y      apt-get install -y --no-install-recommends thunderbird      rm -rf /var/lib/apt/listsCOPY --from=easy-novnc-build /bin/easy-novnc /usr/local/bin/COPY menu.xml /etc/xdg/openbox/COPY supervisord.conf /etc/EXPOSE 8080RUN groupadd --gid 1000 app      useradd --home-dir /data --shell /bin/bash --uid 1000 --gid 1000 app      mkdir -p /dataVOLUME /dataCMD ["sh", "-c", "chown app:app /data /dev/stdout  exec gosu app supervisord"]

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

Paso 4: creación y ejecución del contenedor

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

Primero, construya el contenedor. Asegúrese de ejecutar estos comandos en el ~/thunderbirddirectorio:

docker build -t thunderbird .

Ahora crea una nueva red que se compartirá entre los contenedores de la aplicación:

docker network create thunderbird-net

Luego crea un volumen para almacenar los datos de la aplicación:

docker volume create thunderbird-data

Por último, ejecútelo y configúrelo 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 reemplazar el thunderbird-appdespués de la --nameopción por un nombre diferente. Independientemente de lo que haya elegido, su aplicación ahora está en contenedores y en ejecución. Ahora, usemos el servidor web Caddy para protegerla y conectarnos a ella de forma remota.

Paso 5: Configuración de Caddy

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

Crea un nuevo directorio y luego muévete dentro de él:

mkdir ~/caddy
cd ~/caddy

Ahora crea uno nuevo Dockerfileusando nanotu editor preferido:

nano ~/caddy/Dockerfile

A continuación agregue las siguientes directivas:

~/caddy/archivo Docker

FROM golang:1.14-buster AS caddy-buildWORKDIR /srcRUN echo 'module caddy'  go.mod      echo 'require github.com/caddyserver/caddy/v2 v2.1.1'  go.mod      echo 'require github.com/mholt/caddy-webdav v0.0.0-20200523051447-bc5d19941ac3'  go.modRUN 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.goRUN go build -o /bin/caddy .FROM debian:busterRUN apt-get update -y      apt-get install -y --no-install-recommends gosu      rm -rf /var/lib/apt/listsCOPY --from=caddy-build /bin/caddy /usr/local/bin/COPY Caddyfile /etc/EXPOSE 8080RUN groupadd --gid 1000 app      useradd --home-dir /data --shell /bin/bash --uid 1000 --gid 1000 app      mkdir -p /dataVOLUME /dataWORKDIR /dataCMD ["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 inicia en el puerto 8080con el Caddyfilesímbolo del sistema /etc/Caddyfile. Guarde y cierre el archivo.

A continuación, configurará el servidor web Caddy. Cree un archivo con el nombre Caddyfileen el directorio que acaba de crear:

nano ~/caddy/Caddyfile

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

~/caddy/archivoCaddy

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

Esto Caddyfileconvierte el directorio raíz en proxy del thunderbird-appcontenedor que creaste en el paso 4 (Docker lo resuelve en la IP correcta). También servirá como explorador de archivos basado en web de solo lectura /filesy ejecutará un servidor WebDAV en /webdavel que puedes montar localmente para acceder a tus archivos. El nombre de usuario y la contraseña se leen desde las variables de entorno APP_USERNAMEy APP_PASSWORD_HASH.

Ahora construya el contenedor:

docker build -t thunderbird-caddy .

Caddy v2 requiere que introduzcas en hash la contraseña deseada. Ejecuta el siguiente comando y recuerda reemplazarla mypasspor una contraseña segura de tu elección:

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

Este comando generará una cadena de caracteres. Cópiela en el portapapeles para preparar la ejecución del siguiente comando.

Ahora está listo para ejecutar el contenedor. Asegúrese de reemplazar myusercon un nombre de usuario de su elección y reemplácelo mypass-hashcon el resultado del comando que ejecutó en el paso anterior. También puede cambiar el puerto ( 8080aquí) 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 estamos listos para acceder y probar nuestra aplicación.

Paso 6: Prueba y gestión de la aplicación

Accedamos a su aplicación y asegurémonos de que esté funcionando.

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

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

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

Ahora ábrelo en un navegador web. Deberías poder acceder a tus archivos.http://your_server_ip:8080/files/

Opcionalmente, puede intentar montarlo en un cliente WebDAV. Debería poder acceder a sus archivos y modificarlos directamente. Si utiliza la opción Asignar unidad de red en el Explorador de Windows, deberá utilizar un proxy inverso para agregar HTTPS o configurarlo en .http://your_server_ip:8080/webdav/HKLMSYSTEMCurrentControlSetServicesWebClientParametersBasicAuthLevelDWORD:2

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

Conclusión

Ahora ha configurado correctamente un contenedor Docker para Thunderbird y, luego, con 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 generar las imágenes y, luego, vuelva a ejecutar los docker runcomandos de los pasos anteriores. Sus datos se conservarán ya que están almacenados en un volumen.

Si quieres aprender más sobre los comandos básicos de Docker, puedes leer este tutorial o esta hoja de referencia. Para un uso más prolongado, también puedes considerar habilitar HTTPS (esto requiere un dominio) para mayor seguridad.

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

• Wine, una capa de compatibilidad para ejecutar aplicaciones de 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 contenerizar y acceder de forma remota a aplicaciones GUI. Con esta configuración, ahora puede utilizar un servidor con una capacidad de procesamiento considerablemente mayor que la que podría tener localmente para ejecutar herramientas que consumen muchos recursos, como Cutter.