12.12.2024

Linux

Comment utiliser un fichier Docker pour construire une image Docker ?

Qu’est-ce qu’un fichier Docker ?

Un Dockerfile est un script qui contient une série d’instructions indiquant à Docker comment construire une image. Ces instructions spécifient l’image de base, copient des fichiers, définissent des variables d’environnement et exécutent des commandes à l’intérieur du conteneur. Lorsque Docker traite un Dockerfile, il crée une nouvelle image basée sur ces instructions.

Le flux de travail de base se présente comme suit :

Rédiger un fichier Docker avec les instructions nécessaires.
Construire l’image Docker à l’aide du fichier Docker.
Exécuter le conteneur Docker à partir de l’image construite.

Guide étape par étape pour la création d’un fichier Docker et la construction d’une image

Étape 1 : Configurer votre projet

Pour commencer, vous avez besoin d’une application simple à conteneuriser. Pour cet exemple, nous allons créer une application Node.js basique. Si vous n’avez pas installé Node.js, vous pouvez suivre les étapes suivantes pour créer une application Node.js simple.

Créez un répertoire de projet :

Créez un fichier package.json pour votre application Node.js :

Créez un fichier server.js :

Ajoutez le contenu suivant au fichier server.js:

const http = require('http');
 const hostname = '0.0.0.0';
 const port = 3000;
 const server = http.createServer((req, res) => { res.statusCode = 200;
 res.setHeader('Content-Type', 'text/plain');
 res.end('Hello World\n'); });
 server.listen(port, hostname, () => {
 console.log(Server running at http://${hostname}:${port}/); });

Maintenant que vous avez votre application de base, la prochaine étape est de créer un Dockerfile qui sera utilisé pour construire une image Docker pour cette application.

Créez un Dockerfile dans le répertoire racine de votre projet :

Ajouter des instructions au fichier Docker :

Voici un fichier Docker simple pour votre application Node.js :

FROM node:14   # Use an official Node.js runtime as a base image
 WORKDIR /app # Set the working directory inside the container
 COPY package*.json ./ # Copy package.json and install dependencies
 RUN npm install
 COPY . .  # Copy the rest of the application code
 EXPOSE 3000  # Expose the port that the app runs on
 CMD ["node", "server.js"] # Command to run the application

Explication du fichier Docker :

FROM: Spécifie l’image de base sur laquelle votre image sera construite. Dans ce cas, il s’agit de l’image officielle Node.js 14.
WORKDIR: Définit le répertoire de travail à l’intérieur du conteneur. Toutes les commandes suivantes seront exécutées dans ce répertoire.
COPY: Copie les fichiers de la machine hôte dans le conteneur Docker.
- COPY package*.json ./: Cette commande copie les fichiers package.json et package-lock.json .
- COPY …: Copie l’ensemble du projet dans le conteneur.
RUN: Exécute une commande à l’intérieur du conteneur, dans ce cas, npm install pour installer les dépendances Node.js.
EXPOSE: Informe Docker que le conteneur écoute sur le port 3000.
CMD: Spécifie la commande à exécuter à l’intérieur du conteneur lorsqu’il démarre (dans ce cas, exécuter l’application Node.js avec node server.js).

Étape 3 : Construire l’image Docker

Une fois que votre fichier Docker est prêt, vous pouvez construire l’image Docker à l’aide de la commande docker build.

Dans le répertoire de votre projet, exécutez la commande suivante :

Voici ce que fait la commande :

–t my-docker-app: Marque l’image avec le nom my-docker-app.
Le symbole . indique le répertoire actuel (où se trouve le fichier Docker).

Docker traitera le fichier Docker, étape par étape, en construisant l’image selon vos instructions. Si tout est configuré correctement, vous devriez voir un message indiquant que l’image a été construite avec succès.

Étape 4 : Exécuter le conteneur Docker

Une fois l’image construite, vous pouvez créer et exécuter un conteneur à l’aide de la commande docker run.

–p 3000:3000: fait correspondre le port 3000 de votre machine locale au port 3000 à l’intérieur du conteneur.
my-docker-app: Le nom de l’image Docker que vous avez construite.

Vous devriez voir le message suivant : Le serveur s’exécute à l’adresse http://0.0.0.0:3001/.

Pour tester l’application, ouvrez votre navigateur web ou utilisez curl pour visiter :

Vous devriez voir s’afficher “Hello World”.

Étape 5 : Pousser l’image Docker vers Docker Hub (optionnel)

Si vous souhaitez partager votre image avec d’autres personnes ou la déployer sur un serveur, vous pouvez la pousser vers Docker Hub.

Tout d’abord, connectez-vous à Docker Hub :

Marquez ensuite votre image avec votre nom d’utilisateur Docker Hub :

Pousser l’image vers Docker Hub :

Maintenant, votre image Docker est disponible publiquement (ou en privé) sur Docker Hub.

Meilleures pratiques pour Dockerfile

Lorsqu’on écrit un Dockerfile, il est essentiel de réfléchir au choix de l’image de base. Utiliser une image légère et spécifique, comme une variante alpine ou slim, permet de réduire considérablement la taille de l’image finale et de limiter les dépendances inutiles. Non seulement cela accélère le téléchargement et le déploiement, mais cela diminue aussi la surface d’attaque potentielle en production. Choisir une image trop lourde ou trop générique peut au contraire introduire des paquets superflus, ce qui alourdit le conteneur et complique sa maintenance.

Un autre point crucial est la gestion des couches. Chaque instruction dans un Dockerfile crée une nouvelle couche qui s’ajoute à l’image finale. Trop de couches augmentent le poids global et rallongent le temps de construction. En regroupant les actions logiquement liées au sein d’une seule instruction, on parvient à optimiser la structure de l’image. Cette approche contribue aussi à une meilleure lisibilité et facilite la maintenance à long terme, car on garde un Dockerfile clair, efficace et sans redondances inutiles.

Enfin, les bonnes pratiques incluent l’utilisation des builds multi-étapes et l’exploitation intelligente du cache Docker. Les builds multi-étapes permettent de séparer l’environnement de compilation et l’environnement d’exécution, de sorte que l’image finale ne contienne que ce qui est strictement nécessaire. De plus, comprendre le fonctionnement du cache et organiser les instructions pour le réutiliser efficacement accélère les reconstructions successives. Ensemble, ces techniques garantissent des images plus petites, plus rapides à déployer et plus fiables en production.