Docker - Lancer des interfaces graphiques - Firefox, Chrome & GIMP

Dans mon article précédent, j'ai illustré comment démarrer Firefox ou GIMP dans un navigateur. C'était la première partie de cette série sur les interfaces graphiques car, jusqu'à très récemment, je ne savais pas qu'il était possible de lancer des GUI avec Docker et c'est tout simplement génial.

Donc, avec Docker, on peut démarrer Firefox, GIMP ou même... Doom 2. Et si une seule application ne suffit pas, Démarrer le bureau Lubuntu dans Docker vous offre un bureau complet.

Dans cet article, nous allons créer notre propre image Docker xeyes, puis jouer avec Firefox et GIMP.

Un premier aperçu​

Oui, c'est vrai, c'est inutile, mais wow ! il est possible de lancer une GUI depuis un container et de reproduire l'image en temps réel sur notre machine hôte. C'est xeyes — une paire d'yeux qui suit votre curseur — qui tourne entièrement dans un container, affiché comme une fenêtre native.

Pourquoi ça fonctionne​

• Le container partage la variable d'environnement DISPLAY de l'host, il sait donc sur quel affichage X dessiner.
• Le socket /tmp/.X11-unix de l'host est monté dans le container ; c'est le canal réel que les applications X11 utilisent pour parler au serveur d'affichage.
• xhost +local:docker autorise le socket Docker à se connecter au serveur X de l'host ; sans ça, la connexion est refusée.

Créer notre propre image Docker xeyes​

Commençons par quelque chose de vraiment geek.

Allez dans un dossier temporaire (p.ex. mkdir -p /tmp/xeyes && cd $_) et créez un fichier appelé Dockerfile avec ce contenu :

FROM ubuntu:latest

RUN apt-get update && apt-get install -y --no-install-recommends x11-apps && \?
    rm -rf /var/lib/apt/lists/*?

CMD [ "xeyes" ]

Créez maintenant l'image avec docker build comme ceci : docker build --tag cavo789/xeyes . (remplacez cavo789 par autre chose, comme votre pseudo).

Assurez-vous d'avoir une variable appelée DISPLAY. Vous pouvez le vérifier en lançant printenv | grep DISPLAY. Si vous ne l'avez pas, créez la variable en lançant export DISPLAY=:0 dans la console.

Lancez ensuite xhost +local:docker dans votre console. Cette commande autorise la connexion à un serveur X via le socket Docker. Cela signifie que les applications tournant dans des containers Docker peuvent afficher leur interface graphique (GUI) sur le système hôte. Le résultat attendu est ce texte : non-network local connections being added to access control list

Maintenant, lancez simplement un container en veillant à partager la variable DISPLAY : docker run --rm --env DISPLAY=$DISPLAY --volume /tmp/.X11-unix:/tmp/.X11-unix cavo789/xeyes — vous obtiendrez la fenêtre montrée plus haut.

Créer notre propre image Docker Firefox​

Une fois que vous avez compris l'exemple très basique de xeyes, vous pouvez sortir du cadre : quelle GUI puis-je installer avec Docker ?

Essayons Firefox... En utilisant mon moteur de recherche préféré, j'ai trouvé cet article : Install Official Firefox .deb in Dockerfile.

Dans un Dockerfile et avec quelques petites modifications, ça nous donne ceci :

# cspell:disable?

FROM ubuntu:latest

ENV DEBIAN_FRONTEND=noninteractive?

RUN apt-get update && \?
    apt-get install --no-install-recommends -y apt-utils ca-certificates curl gpg && \
    rm -rf /var/lib/apt/lists/*

# https://jetthoughts.com/blog/install-official-firefox-deb-in-dockerfile-docker-devops/
RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \?
    --mount=type=cache,target=/var/lib/apt,sharing=locked \
    --mount=type=tmpfs,target=/var/log \
    # Create a directory to store APT repository keys, repository lists, and preferences if they don't exist
    install -d -m 0755 /etc/apt/keyrings /etc/apt/preferences.d /etc/apt/sources.list.d > /dev/null && \?
    # Import the Mozilla APT repository signing key
    curl -fsSL https://packages.mozilla.org/apt/repo-signing-key.gpg |  \?
    gpg --dearmor --no-tty -o /etc/apt/keyrings/packages.mozilla.org.gpg > /dev/null && \?
    # Add the Mozilla APT repository to the APT sources list
    echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/packages.mozilla.org.gpg] https://packages.mozilla.org/apt mozilla main" |  \?
    tee /etc/apt/sources.list.d/packages.mozilla.org.list > /dev/null && \
    # Configure APT to prioritize packages from the Mozilla repository
    echo "Package: *\nPin: origin packages.mozilla.org\nPin-Priority: 1000\n\n" | tee /etc/apt/preferences.d/mozilla > /dev/null && \?
    # Update your package list and install the Firefox .deb package
    apt-get update -qq > /dev/null && \
    DEBIAN_FRONTEND=noninteractive apt-get install -qq --no-install-recommends firefox > /dev/null && \?
    rm -rf /var/lib/apt/lists/*

CMD [ "firefox" ]

Pour construire l'image, lancez la commande suivante (et n'oubliez pas de remplacer cavo789 par votre nom d'utilisateur) : docker build --tag cavo789/firefox ..

Et pour démarrer Firefox, lancez simplement docker run --rm -v /tmp/.X11-unix:/tmp/.X11-unix -e DISPLAY=$DISPLAY cavo789/firefox.

Comme vous le savez, mon OS est Windows 11 et je fais tourner Linux grâce à l'incroyable technologie WSL2. Donc, en bref, ci-dessus, vous voyez que j'ai démarré Firefox pour Debian comme une application fenêtrée dans mon Windows.

Le vieux développeur MS-DOS en moi reste émerveillé par cette possibilité.

Créer notre propre image Docker Chrome​

On peut faire la même chose avec Chrome :

FROM ubuntu:latest

ENV DEBIAN_FRONTEND=noninteractive?

RUN apt-get update \?
    && apt-get install -y --no-install-recommends wget \?
    && wget -q https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb \
    && apt-get install -y ./google-chrome-stable_current_amd64.deb \
    && rm -rf /var/lib/apt/lists/*?

CMD ["google-chrome", "--disable-dev-shm-usage", "--disable-gpu"]?

Construisez l'image avec docker build --tag cavo789/chrome . puis lancez-la avec docker run --rm -v /tmp/.X11-unix:/tmp/.X11-unix -e DISPLAY=$DISPLAY cavo789/chrome.

Créer notre propre image Docker GIMP​

Bon, maintenant, je pense que vous avez compris le principe. Donc, très rapidement, voici comment lancer GIMP pour Linux dans un container Docker :

FROM ubuntu:latest

ENV DEBIAN_FRONTEND=noninteractive?

RUN apt-get update && apt-get install --no-install-recommends -y gimp && rm -rf /var/lib/apt/lists/*?

CMD [ "gimp" ]

Créez l'image en lançant docker build --tag cavo789/gimp ..

Et pour démarrer GIMP, lancez simplement docker run --rm -v /tmp/.X11-unix:/tmp/.X11-unix -e DISPLAY=$DISPLAY cavo789/gimp.

Conclusion​

La même recette à chaque fois — partager DISPLAY, monter /tmp/.X11-unix, docker run — et n'importe quelle application graphique Linux apparaît comme une fenêtre native sur l'host, que ce soit une démo idiote comme xeyes, un navigateur complet ou un éditeur d'images. Si une seule application ne suffit pas et que vous préférez un bureau entier pour jouer, Démarrer le bureau Lubuntu dans Docker est l'étape suivante.