Image de l’éditeur | À mi-parcours et Canva
Optimiser les Dockerfiles peut considérablement accélérer les temps de construction en utilisant le cache de construction, en réduisant le contexte de construction, et plus encore. Ce tutoriel explore les meilleures pratiques pour créer des Dockerfiles efficaces.
Conditions préalables
Assurez-vous d’avoir Docker installé. Téléchargez Docker pour votre système d’exploitation si ce n’est pas déjà fait.
1. Utilisez une image de base plus petite
Commencez avec une image de base plus petite pour créer des images minimales. Cela réduit la taille globale de l’image Docker et accélère le processus de création.
Par exemple, pour les applications Python, utilisez une image python:3.x-slim au lieu de python:3.x, car elle contient uniquement les composants essentiels nécessaires à l’exécution de Python.
Pour en savoir plus, lisez Comment créer des images Docker minimales pour les applications Python.
2. Tirer parti du cache de construction Docker
L’ordre des instructions dans un Dockerfile influence les temps de construction grâce à l’utilisation du cache de construction par Docker.
Docker crée des images en exécutant les instructions du Dockerfile séquentiellement, créant une nouvelle couche d’image pour chaque instruction. Si une couche n’a pas changé depuis la dernière construction, Docker peut réutiliser la couche mise en cache, accélérant ainsi le processus de construction.
Pour maximiser les accès au cache, optimisez l’ordre des instructions:
- Placez en dernier les instructions qui changent fréquemment: Les instructions qui changent souvent, comme copier le code de l’application, doivent être placées à la fin du Dockerfile pour réduire les risques d’invalidation du cache.
- Placez les instructions qui changent moins fréquemment plus tôt: Les instructions telles que l’installation des packages du système d’exploitation, la définition des variables d’environnement et l’installation des dépendances (si elles ne changent pas souvent) doivent être placées tôt pour maximiser les accès au cache.
Exemple de Dockerfile suboptimal :
# Ordre suboptimal
FROM python:3.11-slim
# Définir le répertoire de travail
WORKDIR /app
# Copier l'ensemble du code de l'application
COPY . .
# Installer les packages Python requis
RUN pip install --no-cache-dir -r requirements.txt
# Exposer le port sur lequel l'application s'exécute
EXPOSE 5000
# Exécuter l'application
CMD ["python3", "app.py"]
Dans ce Dockerfile, toute modification du code de l’application invalidera le cache pour l’ensemble du processus de construction, y compris l’installation des dépendances.
Voici la version optimisée :
# Meilleur ordre des instructions
FROM python:3.11-slim
# Définir le répertoire de travail
WORKDIR /app
# Installer les dépendances
COPY requirements.txt requirements.txt
RUN pip install --no-cache-dir -r requirements.txt
# Copier le contenu du répertoire actuel dans le conteneur à /app
COPY . .
# Exposer le port sur lequel l'application s'exécute
EXPOSE 5000
# Exécuter l'application
CMD ["python3", "app.py"]
Dans ce Dockerfile optimisé, si le code de l’application change, Docker peut toujours utiliser les couches mises en cache pour installer les dépendances, évitant ainsi une réinstallation inutile des dépendances.
3. Utilisez des constructions en plusieurs étapes
Les builds en plusieurs étapes permettent de séparer l’environnement de build de l’environnement d’exécution final, réduisant ainsi la taille de l’image finale en incluant uniquement les dépendances d’exécution nécessaires.
Exemple de Dockerfile avec une construction en plusieurs étapes :
# Étape de build
FROM python:3.11 AS builder
RUN apt-get update && apt-get install -y build-essential
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
# Étape finale
FROM python:3.11-slim
COPY --from=builder /usr/local/lib/python3.11/site-packages /usr/local/lib/python3.11/site-packages
COPY --from=builder /usr/local/bin /usr/local/bin
COPY . /app
WORKDIR /app
CMD ["python3", "app.py"]
Dans cet exemple, les dépendances de build sont installées dans l’étape builder, et seules les dépendances d’exécution nécessaires sont copiées dans l’image finale.
4. Réduire le contexte de construction avec les fichiers .dockerignore
Utilisez un fichier .dockerignore pour exclure les fichiers inutiles du contexte Docker, réduisant ainsi le temps de construction. Semblable à .gitignore, ce fichier indique à Docker quels fichiers ignorer pendant le processus de construction, réduisant ainsi la taille du contexte.
Dans le fichier .dockerignore, incluez des fichiers temporaires, des environnements virtuels, des paramètres IDE et d’autres fichiers inutiles que vous ne souhaitez pas inclure dans le contexte de construction.
En appliquant ces optimisations, de la réduction de la taille de l’image de base à l’optimisation du contexte de build, vous pouvez rendre vos builds Docker plus efficaces.
Ressources additionnelles
Les ressources suivantes peuvent vous aider à en apprendre davantage :
Bala Priya C est une développeuse et rédactrice technique indienne. Elle aime travailler à l’intersection des mathématiques, de la programmation, de la science des données et de la création de contenu. Ses domaines d’intérêt et d’expertise incluent le DevOps, la science des données et le traitement du langage naturel. Elle aime lire, écrire, coder et boire du café ! Actuellement, elle se consacre à l’apprentissage et au partage de ses connaissances avec la communauté des développeurs en créant des tutoriels, des guides pratiques, des articles d’opinion, etc. Bala crée également des aperçus de ressources attrayants et des tutoriels de codage.
