Comprendre les Instructions Dockerfile et les Couches
Commençons par créer un Dockerfile utilisant diverses instructions. Nous allons construire une image pour une application web Python utilisant Flask, et nous verrons comment chaque instruction contribue aux couches de notre image Docker.
- Tout d'abord, créons un nouveau répertoire pour notre projet. Dans le terminal de l'IDE Web, exécutez :
mkdir -p ~/project/advanced-dockerfile && cd ~/project/advanced-dockerfile
Cette commande crée un dossier nommé advanced-dockerfile à l'intérieur du dossier project, puis se déplace dedans.
-
Créons maintenant notre fichier d'application. Dans l'explorateur de fichiers de l'IDE (généralement à gauche), faites un clic droit sur le dossier advanced-dockerfile et sélectionnez "New File". Nommez ce fichier app.py.
-
Ouvrez app.py et ajoutez le code Python suivant :
from flask import Flask
import os
app = Flask(__name__)
@app.route('/')
def hello():
return f"Hello from {os.environ.get('ENVIRONMENT', 'unknown')} environment!"
if __name__ == '__main__':
app.run(host='0.0.0.0', port=5000)
Il s'agit d'une application Flask simple qui renvoie un message de bienvenue incluant le nom de l'environnement dans lequel elle s'exécute.
- Ensuite, nous devons créer un fichier
requirements.txt pour spécifier nos dépendances Python. Créez un nouveau fichier nommé requirements.txt dans le même répertoire et ajoutez le contenu suivant :
Flask==2.0.1
Werkzeug==2.0.1
Nous spécifions ici des versions exactes pour Flask et Werkzeug afin de garantir la compatibilité.
- Créons maintenant notre Dockerfile. Créez un nouveau fichier nommé
Dockerfile (avec un 'D' majuscule) dans le même répertoire et ajoutez le contenu suivant :
## Use an official Python runtime as the base image
FROM python:3.9-slim
## Set the working directory in the container
WORKDIR /app
## Set an environment variable
ENV ENVIRONMENT=production
## Copy the requirements file into the container
COPY requirements.txt .
## Install the required packages
RUN pip install --no-cache-dir -r requirements.txt
## Copy the application code into the container
COPY app.py .
## Specify the command to run when the container starts
CMD ["python", "app.py"]
## Expose the port the app runs on
EXPOSE 5000
## Add labels for metadata
LABEL maintainer="Your Name <your.email@example.com>"
LABEL version="1.0"
LABEL description="Flask app demo for advanced Dockerfile techniques"
Analysons ces instructions pour comprendre comment elles génèrent les couches de notre image :
FROM python:3.9-slim : C'est toujours la première instruction. Elle définit l'image de base. Cela crée la première couche de notre image, incluant l'environnement d'exécution Python.WORKDIR /app : Définit le répertoire de travail pour les instructions suivantes. Cela ne crée pas de nouvelle couche de données, mais modifie le comportement des instructions suivantes.ENV ENVIRONMENT=production : Définit une variable d'environnement. Les variables d'environnement ne créent pas de couches de fichiers, mais sont stockées dans les métadonnées de l'image.COPY requirements.txt . : Copie le fichier des dépendances depuis notre machine hôte vers l'image. Cela crée une nouvelle couche contenant uniquement ce fichier.RUN pip install --no-cache-dir -r requirements.txt : Exécute une commande dans le conteneur pendant la construction. Cela installe nos dépendances Python et crée une nouvelle couche contenant tous les paquets installés.COPY app.py . : Copie le code de notre application dans l'image, créant une autre couche.CMD ["python", "app.py"] : Spécifie la commande à exécuter au démarrage du conteneur. Cela ne crée pas de couche, mais définit la commande par défaut.EXPOSE 5000 : Il s'agit en réalité d'une forme de documentation. Cela indique à Docker que le conteneur écoutera sur ce port, mais ne publie pas réellement le port. Aucune couche n'est créée.LABEL ... : Ajoute des métadonnées à l'image. Comme l'instruction ENV, les labels ne créent pas de couches mais sont stockés dans les métadonnées.
Chaque instruction RUN, COPY et ADD dans un Dockerfile crée une nouvelle couche. Les couches sont un concept fondamental de Docker permettant un stockage et un transfert efficaces des images. Lorsque vous modifiez votre Dockerfile et reconstruisez l'image, Docker réutilise les couches en cache qui n'ont pas changé, accélérant ainsi le processus.
- Maintenant que nous comprenons le rôle de notre Dockerfile, construisons l'image. Dans le terminal, exécutez :
docker build -t advanced-flask-app .
Cette commande construit une nouvelle image Docker taguée advanced-flask-app. Le . à la fin indique à Docker de chercher le Dockerfile dans le répertoire courant.
Vous verrez défiler les étapes du processus de construction. Notez comment chaque étape correspond à une instruction et comment Docker mentionne "Using cache" pour les étapes inchangées si vous relancez la commande.
- Une fois la construction terminée, nous pouvons lancer un conteneur basé sur notre nouvelle image :
docker run -d -p 5000:5000 --name flask-container advanced-flask-app
Explication des options :
-d lance le conteneur en mode détaché (en arrière-plan).-p 5000:5000 mappe le port 5000 de votre hôte sur le port 5000 du conteneur.--name flask-container donne un nom personnalisé à notre conteneur.advanced-flask-app est le nom de l'image utilisée.
Vérifiez que le conteneur est bien actif :
docker ps
- Pour tester si l'application fonctionne, utilisez la commande
curl :
curl http://localhost:5000
Vous devriez voir le message : "Hello from production environment!"
Si vous préférez, vous pouvez aussi ouvrir un nouvel onglet dans votre navigateur et accéder à http://localhost:5000.
En cas de problème, consultez les journaux du conteneur :
docker logs flask-container
Cela affichera les messages d'erreur ou les sorties de votre application Flask.
