Il y a plusieurs façons d'aboutir à une nouvelle image:

• A partir d'un conteneur existant et la commande docker container save, facile à mettre en place mais compliqué à maintenir.
• From scratch, plus complexe et difficile à maintenir.
• Via un Dockerfile, un fichier contenant les instructions de création en se basant sur une image existante.

Les instructions du Dockerfile sont listés ci-dessous:

FROM # Pour choisir l'image sur laquelle on se base, toujours en premier
RUN # Permet d'exécuter une commande
CMD # Commande exécutée au démarrage du conteneur par défaut
EXPOSE # Ouvre un port
ENV # Permet d'éditer des variables d'environnement
ARG # Variables utilisées seulement le temps de la construction de l'image
COPY # Permet de copier un fichier ou répertoire de l'hôte vers l'image
ADD # Permet de copier un fichier de l'hôte ou depuis une URL vers l'image, permet également de décompresser une archive tar
LABEL # Des métadonnées utiles pour certains logiciels de gestion de conteneurs, comme rancher ou swarm, ou tout simplement pour mettre des informations sur l'image.
ENTRYPOINT # Commande exécutée au démarrage du conteneur, non modifiable, utilisée pour package une commande
VOLUME # Crée une partition spécifique
WORKDIR # Permet de choisir le répertoire de travail
USER # Choisit l'utilisateur qui lance la commande du ENTRYPOINT ou du CMD
ONBUILD # Crée un step qui sera exécuté seulement si notre image est choisie comme base
HEALTHCHECK # Permet d'ajouter une commande pour vérifier le fonctionnement de votre conteneur
STOPSIGNAL # permet de choisir le [signal](http://man7.org/linux/man-pages/man7/signal.7.html) qui sera envoyé au conteneur lorsque vous ferez un docker container stop

Pour construire l'image on utilisera la commande:

docker image build -t [imagename][:tag] [Dockerfile folder]

L'option –tag, -t permet de définir le nom de l'image.

Dans l'exemple ci-dessous, on a écrit un fichier script.sh qui affiche régulièrement un message:

script.sh

while true;
do
        echo $(date +"%d-%m-%Y %H:%M:%S")": [APP version="$APP_VERSION"]"
        sleep 5 
done
exit 0

La variable APP_VERSION non définie dans le script sera présente dans l’environnement. On souhaite partir d'une image de busybox existante pour y ajouter notre script

Dockerfile

FROM busybox:1.24-glibc
RUN mkdir -p /usr/local/bin
COPY script.sh /usr/local/bin
CMD /usr/local/bin/script.sh

Pour construire la nouvelle image:

docker image build --tag test_script:0.1.1 .

On peut ensuite créer le conteneur à partir de notre image:

docker container run --detach --env APP_VERSION="0.1" test_script:0.1.1

Chaque instruction modifiant la structure du système de fichier dans le Dockerfile produit un layer (calque). Un nombre important de layers conduit à une image de taille importante et peu nuire au temps d'accès de lecture/écriture. Pour éviter cela on groupe au maximum les commandes:

Ci dessous un exemple non optimisé:

# layer 1
RUN apt-get update && apt-get install -y --no-install-recommends --no-install-suggests perl \
                                                                        ca-certificates \
                                                                        shared-mime-info \
                                                                        perlmagick \
                                                                        make \
                                                                        gcc \
                                                                        ca-certificates \
                                                                        libssl-dev \
                                                                        git
# layer 2
RUN cpan install Carton

# layer 3
RUN cd / && git clone https://git.framasoft.org/luc/lutim.git

# layer 4
RUN cd /lutim && carton install

# layer 5
RUN apt-get purge -y make gcc ca-certificates libssl-dev git

# layer 6                       
RUN apt-get autoremove --purge -y && apt-get clean

#layer 7
RUN rm -rf /var/lib/apt/lists/* /root/.cpan* /lutim/local/cache/* /lufi/utilities

Les mêmes commandes regroupées conduiront à la création d'un seul calque:

RUN apt-get update \
    && apt-get install -y --no-install-recommends --no-install-suggests perl \
                                                                        ca-certificates \
                                                                        shared-mime-info \
                                                                        perlmagick \
                                                                        make \
                                                                        gcc \
                                                                        ca-certificates \
                                                                        libssl-dev \
                                                                        git \
    && cpan install Carton \
    && cd / \
    && git clone https://git.framasoft.org/luc/lutim.git \
    && cd /lutim \
    && carton install \
    && apt-get purge -y make \
                        gcc \
                        ca-certificates \
                        libssl-dev \
                        git \
    && apt-get autoremove --purge -y \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/* /root/.cpan* /lutim/local/cache/* /lufi/utilities

Limiter au maximum les processus s'executant en tant que root meme dans le container. Utiliser exec, su-exec pour remplacer dès que possible les processus root.