Créer des images Docker personnalisées
Créez votre première image Docker personnalisée pour une application simple, puis étiquetez-la et versionnez-la correctement.
Créer des images Docker personnalisées est une leçon Docker & DevOps Fundamentals gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Docker & DevOps Fundamentals, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Docker & DevOps Fundamentals comprend 4 leçons au total.
Construire votre première image Docker
Pourquoi construire des images personnalisées ? Elles vous permettent de regrouper votre application spécifique, ses dépendances et sa configuration dans une seule unité portable. C'est essentiel pour assurer la cohérence et faciliter le déploiement.
Vous définissez la manière de construire cette image à l'aide d'un fichier appelé Dockerfile.
Notre application web simple
Nous allons conteneuriser une application web Python Flask très simple. Elle renvoie simplement « Hello from Docker! » lorsque vous consultez son adresse web.
Imaginez que nous avons ces fichiers dans un répertoire :
app.py: le code de l'application Pythonrequirements.txt: répertorie les dépendances PythonDockerfile: les instructions pour construire l'image
Le code de l’application Flask
Voici notre application Flask Python de base. Elle écoute sur le port 5000 et répond par « Hello from Docker! ».
Vous pouvez l’exécuter localement (après avoir installé Flask) pour la voir en action !
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello():
return 'Hello from Docker!'
if __name__ == '__main__':
app.run(debug=True, host='0.0.0.0')Définir les dépendances
Notre application a besoin de la bibliothèque Flask. Nous la répertorions dans requirements.txt. Ce fichier indique à Docker (ainsi qu’au gestionnaire de paquets de Python, pip) ce qu’il faut installer.
Ainsi, notre image contient toutes les bibliothèques nécessaires à l’exécution de l’application.
Flask==2.3.2Anatomie de notre Dockerfile
Un Dockerfile est un fichier texte contenant des instructions pour créer une image. Chaque instruction crée une couche. Voici celles que nous allons utiliser :
FROM: indique l’image de base (par exemple, Python).WORKDIR: définit le répertoire de travail à l’intérieur du conteneur.COPY: copie des fichiers de votre machine locale dans l’image.RUN: exécute des commandes (par exemple, pour installer les dépendances).EXPOSE: informe Docker des ports sur lesquels le conteneur écoute.CMD: définit la commande par défaut à exécuter au démarrage du conteneur.
Créer le Dockerfile
Voici le Dockerfile complet de notre application Flask. Placez ce fichier dans le même répertoire que app.py et requirements.txt.
# Use an official Python runtime as a parent image
FROM python:3.9-slim-buster
# Set the working directory in the container
WORKDIR /app
# Copy the current directory contents into the container at /app
COPY requirements.txt .
COPY app.py .
# Install any needed packages specified in requirements.txt
RUN pip install --no-cache-dir -r requirements.txt
# Make port 5000 available to the world outside this container
EXPOSE 5000
# Run app.py when the container launches
CMD ["python", "app.py"]La commande `docker build`
Construisons maintenant notre image ! Ouvrez votre terminal dans le répertoire où se trouvent votre Dockerfile et les fichiers de l’application.
L’option -t associe à notre image un nom (my-flask-app) et une version (1.0). Le . indique à Docker d’utiliser le répertoire actuel comme contexte de création.
docker build -t my-flask-app:1.0 .
Vérifier votre nouvelle image
Une fois la création terminée, vous pouvez vérifier que votre nouvelle image existe en affichant toutes les images Docker locales.
Dans le résultat, recherchez my-flask-app avec l’étiquette 1.0.
docker images
Lancer le conteneur de votre application
Il est temps de voir votre application en action ! Utilisez docker run pour créer et démarrer un conteneur à partir de votre image.
-p 5000:5000 associe le port 5000 de votre machine hôte au port 5000 à l’intérieur du conteneur. -d l’exécute en mode détaché (en arrière-plan).
docker run -d -p 5000:5000 my-flask-app:1.0
Ouvrez http://localhost:5000 dans votre navigateur pour voir « Hello from Docker! ».
Bonnes pratiques pour l’étiquetage des images
Les étiquettes sont essentielles pour gérer différentes versions de vos images. Une pratique courante consiste à utiliser le versionnage sémantique (par exemple, 1.0.0, 2.1.5) ainsi qu’une étiquette latest.
Vous pouvez ajouter plusieurs étiquettes à une image avec docker tag :
docker tag my-flask-app:1.0 my-flask-app:latest
Vous pouvez ainsi désigner la même image par différents noms, ce qui offre davantage de souplesse pour les déploiements.
Vérification rapide
Examinez le Dockerfile et la commande de création suivants :
# Dockerfile content
FROM alpine:latest
WORKDIR /app
COPY . .
CMD ["echo", "Hello"]
docker build -t my-app:v1 .Laquelle des affirmations suivantes est TRUE à propos de la commande docker build -t my-app:v1 . ?
Récapitulatif : images personnalisées
Excellent travail ! Vous avez appris à :
- Préparer une application simple pour la conteneurisation.
- Écrire un
Dockerfilede base en utilisant des instructions clés (FROM,WORKDIR,COPY,RUN,EXPOSE,CMD). - Créer une image Docker personnalisée avec
docker build -t. - Vérifier votre image avec
docker images. - Exécuter un conteneur à partir de votre image personnalisée avec
docker run -p. - Comprendre l’importance de l’étiquetage et du versionnage des images.
Nous allons maintenant approfondir la structure des images Docker, avec leurs couches et les techniques permettant d’optimiser leur taille et leur temps de création !
Questions Fréquemment Posées
La leçon « Créer des images Docker personnalisées » est-elle gratuite ?
Oui — le texte complet de « Créer des images Docker personnalisées » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Docker & DevOps Fundamentals, passe à CoddyKit PRO. Le cours Docker & DevOps Fundamentals comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Créer des images Docker personnalisées » ?
Créez votre première image Docker personnalisée pour une application simple, puis étiquetez-la et versionnez-la correctement. Tu pratiques Docker & DevOps Fundamentals avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Docker & DevOps Fundamentals ?
Aucune expérience préalable n'est requise. Docker & DevOps Fundamentals sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.
Combien de temps prend la leçon « Créer des images Docker personnalisées » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Docker & DevOps Fundamentals ?
Oui. Chaque leçon Docker & DevOps Fundamentals inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Comprendre les Dockerfiles
- Créer des images Docker personnalisées
- Couches d’images et optimisation
- Constructions en plusieurs étapes et images plus légères