Exercice 02 : Optimiser les layers d'une image Docker

🎯 Objectifs

À la fin de cet exercice, vous serez capable de :

• ✅ Expliquer pourquoi l'ordre des instructions impacte le cache
• ✅ Copier requirements.txt avant le reste du code source
• ✅ Utiliser docker history pour visualiser les layers d'une image
• ✅ Inspecter les métadonnées d'une image avec docker image inspect --format
• ✅ Mesurer l'impact de --no-cache sur le temps de build

Durée estimée : 30 min | Difficulté : ⭐⭐⭐☆☆

📖 Contexte

Docker met en cache chaque layer. Si une instruction et ses fichiers sources n'ont pas changé, Docker réutilise le layer existant - le build est quasi-instantané. Un mauvais ordre d'instructions invalide le cache prématurément : copier tout le code source avant pip install force une réinstallation complète à chaque modification du code.

📋 Énoncé

Comparez deux Dockerfiles pour une application Python Flask : l'un avec un mauvais ordre (cache inefficace), l'autre optimisé. Mesurez la différence et analysez les layers produits.

🧭 Déroulement

Tâche 1 : Créer l'application Flask

Créez un dossier flask-cache/ avec les fichiers suivants :

requirements.txt

flask==3.0.3

app.py

from flask import Flask
app = Flask(__name__)

@app.route('/')
def index():
    return 'Optimisation des layers Docker\n'

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

Indice : Ces deux fichiers sont tout ce dont vous avez besoin.

Vérification : Les deux fichiers existent dans flask-cache/.

Tâche 2 : Dockerfile non optimisé

Créez Dockerfile.bad - il copie tout le code avant d'installer les dépendances :

FROM python:3.12-slim
WORKDIR /app
COPY . .
RUN pip install --no-cache-dir -r requirements.txt
EXPOSE 5000
CMD ["python", "app.py"]

Construisez l'image, modifiez une ligne dans app.py, puis reconstruisez. Notez le temps.

Indice : docker build -f Dockerfile.bad -t flask-bad . utilise un Dockerfile avec un nom personnalisé.

Vérification : Au second build, le layer pip install est re-exécuté même si requirements.txt n'a pas changé.

Tâche 3 : Dockerfile optimisé

Créez Dockerfile.good - il copie requirements.txt en premier :

FROM python:3.12-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 5000
CMD ["python", "app.py"]

Construisez, modifiez app.py, puis reconstruisez. Comparez le temps.

Indice : Le layer pip install n'est re-exécuté que si requirements.txt change. Modifier app.py n'invalide que le dernier COPY.

Vérification : Au second build, vous voyez ---> Using cache pour le layer pip install.

Tâche 4 : Analyser les layers avec docker history

Affichez l'historique des layers de flask-good pour visualiser leur taille et leur commande d'origine.

Indice : docker history <image> liste les layers du plus récent au plus ancien. Chaque ligne correspond à une instruction du Dockerfile.

Vérification : Vous identifiez les layers COPY, RUN pip install, et CMD avec leurs tailles respectives.

Tâche 5 : Inspecter les métadonnées

Affichez uniquement la taille totale de l'image flask-good en octets via docker image inspect.

Indice : docker image inspect --format '{{.Size}}' <image> extrait un champ spécifique au format Go template.

Vérification : Vous obtenez un nombre entier représentant la taille en octets (ex: 148234567).

🗂️ Mini-Projet

Comparez les deux Dockerfiles et validez chaque checkpoint :

mkdir flask-cache && cd flask-cache
# Créer requirements.txt et app.py
docker build -f Dockerfile.bad  -t flask-bad  .
docker build -f Dockerfile.good -t flask-good .
# Modifier app.py, puis rebuildez les deux images
docker history flask-good
docker image inspect --format '{{.Size}}' flask-good
docker build --no-cache -f Dockerfile.good -t flask-good:clean .

Checkpoints de validation :

• Dockerfile.good place COPY requirements.txt . avant RUN pip install
• Après modification de app.py, flask-good affiche Using cache pour pip install
• flask-bad re-exécute pip install à chaque modification de app.py
• docker history flask-good liste tous les layers avec leur taille
• docker image inspect --format '{{.Size}}' retourne la taille en octets
• --no-cache force la réinstallation complète des dépendances