4204d4

🐳 Dockerfile – Introduction

La Dockerfile – tout ce que vous avez toujours voulu savoir

Motivé par nos apprentissages précédents, nous voilà enfin près – du moins, nous tenterons l’exercice – à bâtir une image docker personnalisée.

YAML

Pré-requis:

Docker – Commandes de base
Docker – Conteneurs personnalisés
Publication sur hub.docker.com

Comment démarrer ce module?

Nous savons comment personnaliser un conteneur, puis le publier sur hub.docker.com.

Oui je sais, ce faisant, nous modifions le travail d’une autre personne.

Pas vraiment de mérite à celà.

Alors voici comment nous élever au dessus de la foule 👨‍👩‍👦‍👦:

Dockerfile

Il est possible de créer un image personnalisée à partir d’un fichier de directives.

Quoique cela ne soit pas une obligation, ce fichier est habituellement nommé ‘Dockerfile’.

Il propose la structure de directives suivante:

FROM
RUN
CMD

FROM – À partir d’une image existante, comme par exemple, ‘alpine’

RUN – Dans l’image, exécuter les commandes suivantes, comme par exemple, ‘apt update && apt install nano’

Note: RUN utilise la syntaxe ‘/bin/sh -c’ pour exécuter la commande.

CMD – Lors du démarrage du conteneur, exécuter la commande suivante: ‘/bin/bash’

Référence: Best practices

Testons,

1.1 – Dockerfile initial

Dans un dossier vide, créer un fichier Dockerfile.

# À partir d'une image
FROM ubuntu

# Optionnel
MAINTAINER Alain Boudreault <aboudrea@cstj.qc.ca>
LABEL Maintainer="Moi"
LABEL Auteur="Moi Moi"

# Exécuter des commandes dans l'image
RUN apt-get update
RUN mkdir /toto

# Commande à exécuter au démarrage d'un conteneur
CMD ["echo"," --------------------------\n","Ici la voix des Mistérons!\n","--------------------------\n"]

NOTE : Il est aussi possible d’utiliser LABEL au lieu de MAINTAINER, ce qui est présentement la méthode recommandée.

NOTE2 : Les directives peuvent-être inscrites en caractères minuscules mais NON RECOMMANDÉ.

1.2 – Construire l’image: `docker build`

$ docker build -t exercice01:latest .

NOTE : ATTENTION au . à la fin de la commande!!

Sortie de la construction (exemple) :

[+] Building 0.5s (6/6) FINISHED
 => [internal] load build definition from Dockerfile 0.0s
 => => transferring dockerfile: 364B 0.0s
 => [internal] load .dockerignore 0.0s
 => => transferring context: 2B 0.0s
 => [internal] load metadata for docker.io/library/ubuntu:latest 0.4s
 => [1/2] FROM docker.io/library/ubuntu@sha256:703218c0465075f4425e58fac086e09e1de5c340b12976ab9eb8ad26615c3715 0.0s
 => CACHED [2/2] RUN apt-get update 0.0s
 => exporting to image 0.0s
 => => exporting layers 0.0s
 => => writing image sha256:6a083629e78cc15116597087eabb9cce0dea4180748039cd18a1d90487ec4a10 0.0s
 => => naming to docker.io/library/exercice01:latest

1.3 – Tester l’image via un conteneur: `docker run`

 $ docker run exercice01              
 --------------------------
 Ici la voix des Mistérons!
 --------------------------

Note : Si le fichier source n’est pas nommé ‘Dockerfile’, il faut alors utiliser l’option -f:
docker build -f Dockerfile02 -t docker_build_02 .

1.4 – Copier un fichier vers l’image – créer le fichier `hello.sh`

#!/bin/bash

echo "------------------------------"
echo "  Ici la voix des Mistérons!"
echo "------------------------------"

1.4b – Modifier le fichier Dockerfile (avec ADD)

# À partir d'une image
FROM ubuntu

# Optionel
MAINTAINER Alain Boudreault <aboudrea@cstj.qc.ca>

# Exécuter des commandes dans l'image
RUN apt-get update

# Ajouter un fichier à l'image
ADD hello.sh /
RUN chmod a+x /hello.sh

# Commande à éxécuter au démarrage d'un conteneur
CMD ["/hello.sh"]

1.5 – Reconstruire l’image

docker build -t exercice01:latest .

1.6 – Tester dans un conteneur

$ docker run exercice01

1.7 - Labo – Modifier pour la version 1.1

Modifier le projet pour obtenir le résultat suivant au démarrage du conteneur version 1.1:

docker run exercice01:1.1

Résultat :

--------------------------------------
     Ici la voix des Mistérons!
--------------------------------------
 Il est : 16:30:50 dans le conteneur
--------------------------------------

Note : Sous Linux, pour afficher l’heure dans un echo : $(date +%X)

2.0 – Exemple d’une image Ubuntu avec un binaire écrit en ‘C’

NOTE : Démonstration de l’enseignant à partir d’un session Ubuntu – Explication des dépendances OS.

2.1 – Programme ‘C’ (bonjour.cpp)

// Fichier: bonjour.cpp
// Exemple d'une application 'bin' pour Linux
// Par Alain Boudreault
// Fichier source compilé avec 'gcc' sous Ubuntu
// Il est possible d'avoir à installer g++ et gcc: apt install g++ gcc
#include <stdio.h>;
#define MAXITERATION 10

/**
   Incroyable mais oui, il n'y a qu'une seule fonction dans ce programme ;-)
*/
int main(){
  for (int i=1; i <= MAXITERATION; i++) {
    printf("%d\t - Bonjour 420-4D4 !!!\n", i);
  } // for i
  return 0;
} // main()

2.2 – Compiler le code source

$ g++ bonjour.cpp -o bonjour

2.3 – Dockerfile

FROM ubuntu
COPY bonjour /bin
CMD ["/bin/bonjour"]

2.4 – Produire l’image

docker build -t alainboudreault/bonjour420:latest .

2.5 – Tester l’image

docker run alainboudreault/bonjour420

Laboratoire 2.6 – Durée 30 minutes

1 – Programmer un Dockerfile qui:

À partir de ubuntu:latest
Renseigne votre nom comme auteur
Installe le compilateur g++ (apt install -y -> installe sans confirmation)
Modifier le ficher bonjour.cpp pour que le programme affiche votre nom après la boucle
Copie le fichier de l’étape 2.1, bonjour.cpp, vers l’image
Compile le programme bonjour.cpp
Déplace l’exécutable de bonjour vers le dossier /bin
Fixe comme point d’entrée le programme bonjour

2 – Produire et tester l’image

3 – Publier l’image sous docker-hub-login/bonjour-420:latest

4 – Copier le lien dans la conversation Teams

Suggestion, tester vos étapes dans un conteneur Ubuntu avant de rédiger le Dockerfile.

3 – Construire l’image d’un site web

Pré-requis

git, doit-être installé sur votre poste de travail:

Sous windows: https://gitforwindows.org
Sous MacOS – git est probablement déjà installé. Sinon voir git-pour-MacOS
Sous Linux – Référez-vous à la documentation de votre distribution. Par exemple pour Debian

3.1 – Obtenir les fichiers de départ

À partir de https://github.com/ve2cuy/4204d4.git

Note: Placez-vous dans un dossier de travail vide!
git clone https://github.com/ve2cuy/superminou-depart

3.2 – Se déplacer vers le dossier de l’exercice

cd superminou-depart/

3.3 – Construire une image nommée ‘test’

À partir du fichier ‘Dockerfile’ ainsi que le contenu du dossier.

docker build -t test .

3.4 – Tester l’image

docker run -d -p 99:80 test

3.9 – Une version fonctionnelle (Exemple)

docker run -d -p 99:80 alainboudreault/420-4d4:exemple03

YAML

4.0 – Laboratoire – Durée 30 minutes

Reproduire l’exercice précédent à partir de l’image httpd
Y ajouter les applications git, nano, mc et tmux
Remplacer ‘Alain Boudreault’ par votre nom sur la page d’accueil du site Web
- Indice: la commande ‘sed’.
- NOTE: Ne pas éditer le fichier manuellement !!
Publier l’image sous votreCompteHub.docker.com/semaine02-lab4:latest

Afficher le lien de l’image dans la discussion de la séance pour que nous puissions la tester.

docker pull [votreCompteHub.docker.com/semaine02-lab4](https://votreCompteHub.docker.com/semaine02-lab4)

5.0 – Exemples supplémentaires

5.1 – Conteneur qui requiert la définition de variables d’environnement

# EXEMPLE AVEC UN TIME-ZONE et autres choses ...
# Valeurs passées au conteneur par des variables d'environnement
# docker build -t test:v1 .
FROM busybox:unstable-uclibc
LABEL maintainer="alain.boudreault@me.com"
RUN apt-get update && apt-get install -yq tzdata

# Ces variables d'environnement seront crées dans le conteneur. 
ENV TZ="PoleNord/NoelVille"
ENV MOT_DE_PASSE_ULTRA_SECRET="j3sU1um0TDEp2SSE"
ENV ADRESSE_DNS=1.1.1.1

RUN apt install -y mc

5.1.1 – Laboratoire – Durée 20 minutes

À partir de l’exemple précédent, contruire une image qui affiche le contenu des trois variables d’environnement au démarrage d’un conteneur.

1 - Il faut utiliser l’image ‘alpine:latest’ comme source
2 - Sous alpine, la commande utilisée pour installer des applications (packages) est ‘apk’.
- À vous de vérifier la syntaxe d’utilisation.

Résultat obtenu:

$ docker run labo5.1.1.1

Bienvenue dans le conteneur Docker!

Le mot de passe ultra secret est: j3sU1um0TDEp2SSE
Le fuseau horaire est: PoleNord/NoelVille
Et le DNS est: 1.1.1.1

**NOTE: Vérifier que la commande ‘mc’ fonctionne.

5.2 – Exemple d’utilisation d’une variable d’environnement lors du build

Voici comment passer des informations, pour le build, à partir de la ligne de commande:

# NOTE: BUILD_DATE et BUILD_VERSION seront passés via la ligne de commande. 
FROM alpine

# Labels
ARG BUILD_DATE
ARG BUILD_VERSION
LABEL org.label-schema.schema-version="1.0"
LABEL org.label-schema.build-date=${BUILD_DATE}
LABEL org.label-schema.version=${BUILD_VERSION:-1.0}
LABEL org.label-schema.docker.cmd="docker run --build-arg BUILD_DATE="" --build-arg BUILD_VERSION=1.0  mes-outils"

LABEL maintainer="dev@unprojet.org"

ENV DATE_DU_BUILD=${BUILD_DATE}

# COPY outils.tar.gz /mnt
# WORKDIR /mnt
# RUN tar zxvf /mnt/outils.tar.gz
# CMD ["/mnt/outils/outils.sh"]
CMD ["sh", "-c", "echo -e BUILD_DATE=$DATE_DU_BUILD"]

Commande de construction :

# NOTE: --no-cache indique de reconstruire toutes les couches de l'image
docker build --no-cache=true \
--build-arg BUILD_DATE=$(date -u +'%Y-%m-%dT%H:%M:%SZ') \
--build-arg BUILD_VERSION=1.0 \
-f Dockerfile-labo-5.2 \
-t mes-outils:latest .

Résultat:

$ docker run mes-outils:latest
BUILD_DATE=2025-12-22T15:11:36Z

Inspecter la structure json du conteneur:

$ docker inspect ID_CONTENEUR | grep -A5 Labels
    "Labels": {
         "maintainer": "dev@unprojet.org",
         "org.label-schema.build-date": "2025-12-22T15:21:48Z",
         "org.label-schema.schema-version": "1.0",
         "org.label-schema.version": "3.2"
            },

# Autre méthode,
$ docker inspect --format='' ID_CONTENEUR
# 'index' pointe sur la clé "Config": {"Labels": {"org.label-schema.build-date": ... }
# Voir la structure json retounée par la directive 'inspect'.

$ docker inspect --format='' mes-outils

  --> docker run --build-arg BUILD_DATE= --build-arg BUILD_VERSION=1.0  mes-outils

⚠️ Note importante : Cet exemple utilise la syntaxe org.label-schema qui est maintenant dépréciée (mais toujours largement utilisée). Voir le document Dockerfile convention de nommage pour des exemples avec le standard ‘OCI Image Spec Annotations’.

5.3 – Le fichier `.dockerignore`

Si présent dans le répertoire du Dockerfile, le fichier .dockerignore permet d’exclure des fichiers lorsque les directives ‘COPY’ et ‘ADD’ sont utilisées.

# Voici un exemple de contenu:
.git
.gitignore
node_modules
npm-debug.log
Dockerfile*
docker-compose*
README.md
LICENSE
.vscode

5.4 – La directive WORKDIR, exemple d’utilisation:

FROM nginx
# Se déplacer dans le dossier racine du serveur Web:
WORKDIR /usr/share/nginx/html
# Copier les fichiers du dossier courant vers le dossier WORKDIR 
COPY . ./

5.5 – Différences entre les directives ADD et COPY

COPY src dest: copie des fichiers/dossiers d’une source locale vers une destination dans l’image.
ADD src dest: Propose les fonctions de COPY et :
- la possibilité de renseigner une URL comme source,
- décompresse automatiquement les fichiers archives de la source (ADD rootfs.tar.gz .)

Si les fonctions supplémentaires de ADD ne sont pas requises, il est recommandé d’utiliser la directive COPY.

5.6 – Dockerfile de l’image Alpine

FROM scratch
ADD alpine-minirootfs-3.15.0-x86_64.tar.gz /
CMD ["/bin/sh"]

5.7 – Exécuter un bloc d’instruction pour créer un fichier

FROM alpine
	{ \
		echo 'opcache.memory_consumption=128'; \
		echo 'opcache.interned_strings_buffer=8'; \
		echo 'opcache.max_accelerated_files=4000'; \
		echo 'opcache.revalidate_freq=2'; \
		echo 'opcache.fast_shutdown=1'; \
	} > /config.ini

# Construire l'image et executer un shell interactif sur le conteneur
# pour vérifier le contenu du ficher config.ini

5.7.1 –Laboratoire – Durée 20 minutes

Contruire une image, à partir de ‘alpine’ qui crée le fichier d’alias suivant à partir d’un bloc ‘echo vers …’ Au besoin, revoir 5.7.

alias ll='ls -la'
alias t='top'
alias os='uname -a'
alias c='clear'

le fichier est localisé dans /etc/profile.d/alias.sh

NOTE: Pour fonctionner, il faut que la variable d’environnement ENV pointe sur /etc/profile