Creating Your First Docker Image: A Comprehensive Guide

À l'ère de l'informatique en nuage et des microservices, Docker s'est imposé comme une plateforme de premier plan pour créer, déployer et gérer des applications dans des conteneurs. La capacité à regrouper une application et ses dépendances dans une seule image permet d'assurer la cohérence des environnements entre le développement, les tests et la production. Dans cet article, nous explorerons le processus de création de votre première image Docker, ainsi que les bonnes pratiques, les pièges courants et les techniques avancées.

Qu'est-ce que Docker ?

Docker est une plateforme open-source qui automatise le déploiement d'applications à l'intérieur de conteneurs logiciels. Un conteneur est un package léger, autonome et exécutable qui inclut tout ce qui est nécessaire pour faire fonctionner un logiciel, y compris le code, le runtime, les bibliothèques et les outils système. Cette encapsulation garantit que l'application fonctionnera de manière fiable dans différents environnements informatiques.

Key Concepts

Avant de se lancer dans la création d'images Docker, il est essentiel de comprendre quelques concepts clés.

• Image Docker: A read-only template used to create containers. Images can be built from a Dockerfile or pulled from a Docker registry.
• Conteneur DockerUne instance en cours d'exécution d'une image Docker. Les conteneurs sont isolés les uns des autres et du système hôte.
• DockerfileUn fichier texte contenant des instructions de construction d'une image Docker. Chaque instruction dans le Dockerfile crée une couche dans l'image.
• Docker RegistryUn dépôt pour stocker et partager des images Docker. Le plus populaire est Docker Hub.

Prérequis

Avant de commencer, assurez-vous d'avoir les éléments suivants :

1. Docker installéAssurez-vous que Docker est installé sur votre machine. Vérifiez la documentation officielle Guide d'installation de Docker pour les étapes détaillées.
2. Basic Understanding of Command Line: Familiarity with command-line interfaces (CLI) is necessary for executing Docker commands.
3. Text EditorTout éditeur de texte fonctionnera, mais la familiarité avec des éditeurs de code comme Visual Studio Code ou Sublime Text peut améliorer votre expérience.

Étape 1 : Créer une application simple

For this guide, we will create a simple Python web application using Flask, a lightweight web framework. Follow these steps:

1. Mettre en place la structure du projet

Create a directory for your project:

mkdir my-flask-app
cd my-flask-app

Dans ce répertoire, créez les fichiers suivants :

• app.pyLe fichier principal de l'application.
• requirements.txt: A file listing the required Python packages.

2. Write the Flask Application

Ouvert app.py in your text editor and add the following code:

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, Docker!'

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

Next, create the requirements.txt file and input the following line:

Flask==2.0.1

Étape 2 : Écriture du Dockerfile

Now that we have our application, the next step is to write a Dockerfile that will define how to build our Docker image.

1. Créez un Dockerfile

Dans le même répertoire que vos fichiers d'application, créez un fichier nommé Dockerfile (sans aucune extension) et ajoutez-y le contenu suivant :

# Utiliser l'image officielle Python de Docker Hub comme image de base
FROM python:3.9

# Définir le répertoire de travail dans le conteneur
WORKDIR /usr/src/app

# Copier le fichier requirements dans le conteneur
COPY requirements.txt ./

# Installer les paquets Python requis
RUN pip install --no-cache-dir -r requirements.txt

# Copier le contenu du répertoire actuel dans le conteneur
COPY . .

# Exposer le port sur lequel l'application s'exécute
EXPOSE 5000

# Définir la commande pour exécuter l'application
CMD ["python", "app.py"]

Explication des Instructions Dockerfile

• DEPUIS python:3.9: This line specifies the base image for our application. We are using the official Python image available on Docker Hub.
• WORKDIR /usr/src/appDéfinit le répertoire de travail à l'intérieur du conteneur. Toutes les commandes suivantes seront exécutées à partir de cet emplacement.
• COPIER requirements.txt ./: Copie requirements.txt Transférer le fichier du répertoire local vers le répertoire de travail dans le conteneur.
• RUN pip install --no-cache-dir -r requirements.txtExécute une commande pour installer les paquets requis. --no-cache-dir L'option permet de garder l'image plus petite en évitant la mise en cache des fichiers d'installation.
• COPY . .Copie tous les fichiers du répertoire local vers le répertoire de travail dans le conteneur.
• EXPOSE 5000: Documents the port on which the application will run, allowing users to know which port to access.
• CMD ["python", "app.py"]: Specifies the default command to run when a container is launched from the image.

Step 3: Building the Docker Image

Avec notre Dockerfile rédigé, nous pouvons maintenant construire notre image Docker. Exécutez la commande suivante dans votre terminal, en vous assurant d'être dans le répertoire du projet :

docker build -t my-flask-app .

Explication de la commande

• docker buildLa commande pour construire une image Docker.
• -t my-flask-appLe -t flag tags the image with a name (mon-flask-app).
• .Indique le contexte de construction, qui est le répertoire courant.

Étape 4 : Exécution du conteneur Docker

Once the image has been built successfully, you can run it with the following command:

docker run -p 5000:5000 my-flask-app

Explication de la commande

• docker run: The command to create and start a container from an image.
• -p 5000:5000: Maps port 5000 on the host to port 5000 in the container, enabling access to the Flask application.
• mon-flask-app: Le nom de l'image à exécuter.

Après avoir exécuté cette commande, vous devriez voir une sortie indiquant que l'application Flask est en cours d'exécution. Vous pouvez maintenant accéder à l'application dans votre navigateur web en vous rendant sur http://localhost:5000.

Step 5: Managing Docker Images and Containers

Lister les images Docker

Pour afficher les images actuellement disponibles sur votre machine, utilisez la commande :

docker images

2. Liste des conteneurs en cours d'exécution

Pour voir les conteneurs actuellement en cours d'exécution, utilisez :

docker ps

3. Stopping a Container

If you need to stop a running container, you can use its container ID (obtained from docker ps):

docker stop 

4. Supprimer des conteneurs et des images

Pour supprimer un conteneur arrêté, utilisez :

docker rm 

Pour supprimer une image, utilisez :

docker rmi my-flask-app

Bonnes pratiques pour les images Docker

La création d'images Docker peut sembler simple ; cependant, le respect des meilleures pratiques peut considérablement améliorer l'efficacité, la sécurité et la maintenabilité.

1. Use Official Base Images

Always prefer official images from Docker Hub as your base images. They are regularly updated and maintained to mitigate security vulnerabilities.

2. Minimize the Number of Layers

Each instruction in a Dockerfile creates a layer in the image. To keep your images lean, combine commands where possible. For example, merge COPIE commandes lors de la copie de plusieurs fichiers.

3. Clean Up Intermediate Files

Si votre processus de construction génère des fichiers temporaires, supprimez-les pour garder la taille de l'image réduite. Par exemple, après l'installation des paquets, nettoyez le cache.

4. Utilisez .dockerignore

Tout comme .gitignore, the .dockerignore Le fichier peut être utilisé pour exclure des fichiers et des répertoires du contexte de construction Docker, ce qui aide à réduire la taille du contexte de construction.

5. Pin Dependency Versions

Spécifiez toujours la version exacte des dépendances dans votre requirements.txt afin d'éviter des changements inattendus ou des incompatibilités lors de la reconstruction de l'image.

Techniques Avancées

Une fois que vous êtes à l'aise avec les bases, vous pouvez explorer certaines techniques avancées qui peuvent encore améliorer votre expérience Docker.

1. Multi-Stage Builds

Les constructions multi-étapes vous permettent de réduire la taille finale de l'image en utilisant plusieurs FROM statements in a Dockerfile. This technique is beneficial for compiling applications where you need a build environment that differs from the production environment.

# Première étape : construction
FROM python:3.9 AS builder

WORKDIR /usr/src/app
COPY requirements.txt ./
RUN pip install --no-cache-dir -r requirements.txt

# Deuxième étape : production
FROM python:3.9

WORKDIR /usr/src/app
COPY --from=builder /usr/local/lib/python3.9/site-packages /usr/local/lib/python3.9/site-packages
COPY . .

EXPOSE 5000
CMD ["python", "app.py"]

2. Docker Compose

Lorsque l'on travaille avec des applications multi-conteneurs, Docker Compose est un outil précieux. Il permet de définir et d'exécuter des applications Docker multi-conteneurs à l'aide d'un simple fichier YAML. docker-compose.yml file to define your application services, networks, and volumes.

3. Versioning Your Images

Il est recommandé de versionner vos images Docker pour éviter toute confusion. Utilisez le versionnement sémantique (par ex.,)., my-flask-app:1.0.0) pour étiqueter différentes versions et vous assurer que vous pouvez revenir aux versions précédentes si nécessaire.

Conclusion

Créer votre première image Docker peut ouvrir un monde de possibilités pour déployer des applications de manière cohérente et efficace. En suivant les étapes de ce guide et en respectant les bonnes pratiques, vous êtes bien parti pour maîtriser Docker. À mesure que vous explorerez des techniques avancées, le potentiel d'optimisation et de mise à l'échelle de vos applications ne fera que croître.

Docker not only simplifies deployment but also enhances collaboration across development teams, allowing for a smoother transition from development to production. Whether you are developing microservices or monolithic applications, Docker is an essential tool in modern software development workflows.

As you continue your journey, embrace the learning process, experiment with different configurations, and tap into the vast community support available. Happy Dockering!