Dockerfile : création et structure du fichier

2.1 Concepts de base de Dockerfile

Dockerfile — c'est un fichier texte qui contient une série de commandes que Docker utilise pour construire une image. Il sert de "recette" décrivant comment l’image doit être assemblée, de la couche de base à l'état final. Comprendre la structure et le processus de création d’un Dockerfile est essentiel pour utiliser Docker efficacement.

Concepts de base de Dockerfile :

1. Idempotence: les commandes dans un Dockerfile doivent être idempotentes — leur exécution répétée produit toujours le même résultat.
2. Séquence: les commandes sont exécutées séquentiellement de haut en bas. L'ordre est important, car chaque commande crée une nouvelle couche dans l'image.
3. Structure en couches: presque chaque instruction ajoute une nouvelle couche à l'image. Ces couches sont mises en cache, ce qui permet d’optimiser le processus de construction.

Structure de Dockerfile :

Le Dockerfile est composé d'instructions, chacune exécutant une fonction spécifique. Voici les principales :

1. FROM: définit l'image de base qui sera utilisée pour créer la nouvelle image.
2. MAINTAINER: spécifie l’auteur du Dockerfile (obsolète, mais utile pour information).
3. RUN: exécute des commandes dans le conteneur et crée une nouvelle couche.
4. COPY: copie des fichiers et répertoires du contexte de construction vers le système de fichiers du conteneur.
5. ADD: copie des fichiers et répertoires, prend en charge l’extraction des archives et le téléchargement de fichiers à partir d’URL.
6. WORKDIR: définit le répertoire de travail pour les commandes suivantes.
7. ENV: configure des variables d’environnement.
8. CMD: définit la commande par défaut qui est exécutée lors du démarrage du conteneur.
9. ENTRYPOINT: spécifie une commande exécutée au démarrage du conteneur, avec la possibilité de passer des arguments.
10. EXPOSE: indique les ports utilisés par le conteneur.
11. VOLUME: crée un point de montage pour les volumes externes.

2.2 Création d'un Dockerfile

Exemple de création d'un Dockerfile

Prenons un exemple simple de création d'un Dockerfile pour une application web en Node.js.

Étape 1 : Création d'un Dockerfile de base

Créez un fichier nommé Dockerfile à la racine de votre projet et ajoutez les lignes suivantes :

# On utilise une image de base Node.js
FROM node:14

# On configure le répertoire de travail
WORKDIR /app

# On copie package.json et package-lock.json
COPY package*.json ./

# On installe les dépendances
RUN npm install

# On copie tous les fichiers du projet
COPY . .

# On expose le port que l'application va utiliser 
EXPOSE 3000

# On définit la commande pour démarrer l'application
CMD ["node", "app.js"]

Ce Dockerfile réalise les actions suivantes :

1. FROM node:14 : utilise l'image officielle Node.js version 14 comme base.
2. WORKDIR /app : définit le répertoire de travail pour les prochaines commandes.
3. COPY package*.json ./ : copie les fichiers package.json et package-lock.json dans le répertoire de travail.
4. RUN npm install : installe les dépendances à partir de package.json.
5. COPY . . : copie tous les fichiers du projet dans le répertoire de travail du conteneur.
6. EXPOSE 3000 : indique que l'application utilisera le port 3000.
7. CMD ["node", "app.js"] : définit la commande pour démarrer l'application.

Étape 2 : Construction de l'image

Après avoir créé le Dockerfile, construisez l'image à l'aide de la commande docker build :

docker build -t my-node-app .

Cette commande créera une image nommée my-node-app à partir du Dockerfile dans le répertoire actuel.

Étape 3 : Lancement du conteneur

Lancez le conteneur basé sur l'image créée avec la commande docker run :

docker run -d -p 3000:3000 my-node-app

Cet exemple lance le conteneur en arrière-plan, en redirigeant le port 3000 du conteneur vers le port 3000 de la machine hôte. Maintenant, vous pouvez accéder à l'application via http://localhost:3000.

2.3 Instructions supplémentaires dans un Dockerfile

1. Définir des variables d'environnement

Tu peux définir des variables d'environnement disponibles dans le container en utilisant l'instruction ENV.

ENV NODE_ENV=production

2. Utiliser plusieurs commandes RUN

Parfois, il est utile de combiner plusieurs commandes dans une seule instruction RUN, afin de réduire le nombre de couches, diminuer la taille de l'image et accélérer le build.

RUN apt-get update && apt-get install -y \
  curl \
  git \
  && rm -rf /var/lib/apt/lists/*

Pratique! Si une commande ne tient pas en une seule ligne, tu peux utiliser le symbole \ pour continuer sur la ligne suivante. Cela sera interprété comme une seule commande.

Pratique! Pour écrire plusieurs commandes sur une ligne, tu peux utiliser && : command1 && command2 && command3. Cela permet d'exécuter des commandes successivement.

Optimisation de l'ordre des commandes

Pour une utilisation efficace du cache Docker, commence par copier les fichiers qui changent rarement (par exemple, package.json), et installe les dépendances avant d'ajouter le reste des fichiers du projet.

Exemple de Dockerfile avancé

Dans des projets plus complexes, un Dockerfile avancé avec des configurations supplémentaires peut être nécessaire.

# On utilise une image de base minimaliste de Node.js
FROM node:14-alpine

# On définit le répertoire de travail
WORKDIR /usr/src/app

# On copie le package.json et on installe les dépendances
COPY package*.json ./
RUN npm install --only=production

# On copie le code source
COPY . .

# On spécifie le port à utiliser
EXPOSE 8080

# On définit des variables d'environnement
ENV NODE_ENV=production

# On lance l'application
CMD ["node", "server.js"]