Compilation de l'image

4.1 Bases de la commande docker build

La commande docker build est la méthode principale pour créer une image Docker à partir d’un Dockerfile. Elle prend les instructions du Dockerfile et les exécute étape par étape, formant une image à partir de couches. Dans cette conférence, on va examiner comment fonctionne la commande docker build, quels sont ses paramètres et comment l’utiliser en pratique.

La commande docker build assemble une image à partir d’un Dockerfile et du soi-disant contexte de build. Le contexte de build est constitué des fichiers que Docker utilise pour créer une image. Cela peut être un dossier local sur votre machine ou, par exemple, un repository sur GitHub.

Syntaxe

docker build [OPTIONS] PATH | URL | -

Où :

• PATH: le chemin vers un répertoire contenant le Dockerfile et le contexte de build.
• URL: l'URL d’un repository distant.
• -: lecture du Dockerfile depuis l’entrée standard (stdin).

Exemple d’utilisation de base

Dans cet exemple, Docker utilisera le Dockerfile du répertoire actuel (.) et créera une image nommée myimage avec le tag latest.

docker build -t myimage:latest .

4.2 Personnalisation de la commande build

Paramètres principaux de la commande docker build

La commande docker build prend en charge de nombreuses options qui permettent de configurer le processus de création.

1. Paramètres -t, --tag

Le paramètre -t ou --tag est utilisé pour attribuer un nom et un tag à l'image créée.

docker build -t myimage:latest .

2. Paramètres -f, --file

Le paramètre -f ou --file permet de spécifier un Dockerfile alternatif s'il diffère du Dockerfile standard.

docker build -f Dockerfile.dev -t myimage:dev .

3. Paramètre --build-arg

Le paramètre --build-arg est utilisé pour transmettre des arguments de construction définis dans le Dockerfile à l'aide de la directive ARG.

docker build --build-arg APP_VERSION=1.0 -t myimage:1.0 .

4. Paramètre --no-cache

Le paramètre --no-cache permet d'exécuter une création sans utiliser le cache. C'est utile pour s'assurer que toutes les commandes sont exécutées à nouveau.

docker build --no-cache -t myimage:latest .

5. Paramètre --target

Le paramètre --target est utilisé pour spécifier une étape cible dans une création multi-étapes.

docker build --target builder -t myimage:builder .

6. Paramètre --rm

Le paramètre --rm indique à Docker de supprimer les conteneurs intermédiaires après une création d'image réussie (activé par défaut).

docker build --rm -t myimage:latest .

4.3 Exemples de docker build

Exemple 1 : Construction de base

Supposons que vous avez une application simple en Node.js, et vous voulez créer une image Docker pour son déploiement.

Dockerfile :

FROM node:14

WORKDIR /app
        
COPY package*.json ./
RUN npm install
        
COPY . .
        
EXPOSE 3000
        
CMD ["node", "app.js"]

Commande de construction :

docker build -t mynodeapp:latest .

Dans cet exemple, Docker va créer une image mynodeapp avec le tag latest, en utilisant le Dockerfile de l'annuaire actuel.

Exemple 2 : Construction avec des arguments

Les arguments de construction permettent de passer des variables dans un Dockerfile pendant la construction.

Dockerfile

FROM node:14

ARG APP_VERSION
ENV APP_VERSION=${APP_VERSION}
        
WORKDIR /app
        
COPY package*.json ./
RUN npm install
        
COPY . .
        
EXPOSE 3000
        
CMD ["node", "app.js"]

Commande de construction :

docker build --build-arg APP_VERSION=1.0 -t mynodeapp:1.0 .

Dans cet exemple, l'argument APP_VERSION est passé dans le Dockerfile, ce qui permet de spécifier la version de l'application pendant la construction.

Exemple 3 : Construction multi-étapes

La construction multi-étapes est utilisée pour créer des images qui incluent seulement les composants nécessaires. Cela permet de réduire la taille de l'image finale.

Dockerfile

# Étape de construction
FROM node:14 AS builder
        
WORKDIR /app
        
COPY package*.json ./
RUN npm install
        
COPY . .
RUN npm run build
        
# Former l'image finale avec un ensemble minimal de fichiers
FROM nginx:alpine
        
COPY --from=builder /app/build /usr/share/nginx/html

Commande de construction :

docker build -t mywebapp:latest .

Dans cet exemple, une image intermédiaire builder est d'abord créée, où l'application est construite. Après la construction, l'application est transférée dans l'image finale, qui utilise Nginx pour servir le contenu prêt.

4.4 Conseils pratiques

1. Optimisation de l'ordre des instructions

Pour une utilisation efficace du cache Docker, il est important d’ordonner correctement les instructions. Par exemple, commence par copier les fichiers qui changent rarement, comme package.json, pour minimiser la reconstruction des dépendances. Ensuite, copie les autres fichiers.

COPY package*.json ./
RUN npm install
COPY . .

2. Utilisation de .dockerignore

Ajoute un fichier .dockerignore pour exclure les fichiers et répertoires inutiles du contexte de build. Cela réduira la taille du contexte et accélérera la création de l'image.

Exemple de .dockerignore:

node_modules
dist
*.log

3. Construction multi-étape

Utilise la construction multi-étape pour créer des images minimalistes et légères. Cette approche permet d'inclure uniquement les fichiers et dépendances réellement nécessaires au fonctionnement de l'application, en excluant les données inutiles du résultat final, telles que les fichiers temporaires ou le code source.