Pour qu'une application graphique fonctionne, il faut utiliser un serveur XServer disponible dans tous les environnements de bureau Linux. Toutefois, par défaut, un conteneur Docker ne peut pas exécuter une application graphique.

Il existe différentes options pour exécuter des applications graphiques dans un conteneur Docker, telles que l'utilisation de SSH avec transfert X11 ou de VNC, mais la plus simple consiste à partager un socket X11 avec le conteneur et à l'utiliser directement.

• Créer un volume --volume="$HOME/.Xauthority:/root/.Xauthority:rw"
• partager la variable d’environnement DISPLAY de l’hôte avec le conteneur --env="DISPLAY"
• Exécuter le conteneur avec le pilote de réseau hôte avec --net=host

Par exemple avec un conteneur Android Studio en utilisant le fichier Docker suivant comme point de départ:

$ cat Dockerfile

FROM ubuntu:14.04
MAINTAINER Admatic Engineering
Team@ADMATIC.INENV DEBIAN_FRONTEND=noninteractiveRUN apt-get update# Default jdk
RUN apt-get install -y default-jdk
#Dépendances 32 bits d'androïde et d'utils
Lancez apt-get install -y \
    bison \
    git \
    gperf \
    lib32gcc1 \
    lib32bz2-1.0 \
    lib32ncurses5 \
    lib32stdc ++ 6 \
    lib32z1 \
    libc6-i386 \
    libxml2-utils \
    faire \
    Zip
# Télécharger et décompresser Android Studio pour Linux
ADD
http://dl.google.com/dl/android/studio/ide-zips/1.2.1.1/android-studio-ide-141.1903250-linux.zip /opt/android-studio.zip
RUN cd /opt/ && unzip android-studio.zip && rm android-studio.zip
CMD /opt/android-studio/bin/studio.sh

construire l'image du conteneur

$ sudo docker build -t android-studio.

lancer Android Studio à l'intérieur du conteneur.

$ sudo docker run --net=host --env="DISPLAY" --volume="$HOME/.Xauthority:/root/.Xauthority:rw" android-studio

Si tout se passe bien, on doit voir Android Studio s'exécuter depuis un conteneur Docker.

L'idée est assez simple et on peut facilement la mettre oeuvre, il suffit de monter dans un volume du système de fichiers le socket X11 de l'hôte (/tmp/.X11-unix) sur le même chemin d'accès au conteneur et de définir la variable d'environnement DISPLAY du conteneur comme affichage du serveur X de L'hôte, donc lorsque l'application du conteneur envoie les instructions de rendu, il les envoie au serveur X hôte.

Pour pouvoir lancer une application X depuis un conteneur Docker, il faut réaliser les opérations suivantes :

• Donner à Docker les droits d’accès au serveur X (sur le système hôte, bien entendu) : xhost +local:docker
• Lancer le conteneur avec (au moins) les options -e DISPLAY=$DISPLAY et -v /tmp/.X11-unix/:/tmp/.X11-unix

Par exemple avec un conteneur Firefox en utilisant le fichier Docker suivant comme point de départ:

From Ubuntu: 14.04
RUN apt-get update && apt-get install -y firefox

# Replace 1000 with your user / group id
RUN export uid=1000 gid=1000 && \
    mkdir -p /home/developer && \
    echo "developer:x:${uid}:${gid}:Developer,,,:/home/developer:/bin/bash" >> /etc/passwd && \
    echo "developer:x:${uid}:" >> /etc/group && \
    echo "developer ALL=(ALL) NOPASSWD: ALL" > /etc/sudoers.d/developer && \
    chmod 0440 /etc/sudoers.d/developer && \
    chown ${uid}:${gid} -R /home/developer

USER developer
ENV HOME /home/developer
CMD /usr/bin/firefox

construire l'image du conteneur

$ docker build -t firefox. et exécutez le conteneur avec:

lancer Firefox à l'intérieur du conteneur.

docker run -ti --rm \
       -e DISPLAY=$DISPLAY \
       -v /tmp/.X11-unix:/tmp/.X11-unix \
       firefox

Si tout se passe bien, on doit voir Firefox s'exécuter depuis un conteneur Docker.

• Indiquer à xhost d'autoriser le transfert depuis l'ID du conteneur:

$ sudo docker run -it -d \
    --net = hôte \
    --env = "AFFICHER" \
    --env = "QT_X11_NO_MITSHM = 1" \
    --volume = "/tmp/.X11-unix:/tmp/.X11-unix:rw" \
    --device = "/dev/video0:/dev/video0" \
    --volume = "/chemin/vers/sharedDockerFiles: /root/sharedDockerFiles" \
    --volume = "/etc/machine-id:/etc/machine-id" \
    yourdockerrepo/image:tag \
    [image-du-conteneur]

$ export containerId=$(docker ps -l -q)
$ sudo xhost + local: `sudo docker inspect --format = '{{.Config.Hostname}}' $ containerId`
$ sudo docker start $containerId

• Copier .Xauthority de l’hôte principal vers le répertoire sharedDockerFiles:

sudo cp ~/.Xauthority /chemin/vers/sharedDockerFiles

• Démarrer le conteneur et vérifier que la variable $DISPLAY du conteneur est identique à celle de l'hôte. la sortie echo $DISPLAY devrait être identique dans l'hôte et dans le conteneur,si ce n'est pas le cas, redémarrer le conteneur en utilisant export DISPLAY={sortie de la variable $DISPLAY de l'hôte}
• copier le fichier .Xauthority dans le dossier partagé du conteneur

sudo cp /root/sharedDockerFiles/.Xauthority ~/

• Editer le fichier /etc/ssh/ssh_config du conteneur sous Host (nécessaire une fois) pour inclure:

ForwardX11 yes
X11Forwarding yes

• Redémarrer le conteneur et lancer l'application graphique