Optimisation du Dockerfile

6.1 Introduction à l'optimisation des images

Les images Docker, bien qu'elles soient compactes, prennent toujours un peu de place. Réduire leur taille est donc super important, et ça aide à améliorer les perfs, accélérer les chargements et les déploiements de conteneurs, tout en réduisant les coûts de stockage. On peut optimiser une image en améliorant le Dockerfile, vu qu'il peut être organisé de différentes manières. Dans cette conférence, on va checker quelques stratégies et best practices pour créer des images Docker optimisées et légères.

Pourquoi c'est important de réduire la taille des images Docker ?

1. Rapidité de déploiement: des images plus petites se téléchargent plus vite depuis le registre Docker et se déploient plus rapidement dans des conteneurs, ce qui est super utile dans des systèmes CI/CD automatisés.
2. Utilisation efficace des ressources: des images légères prennent moins de place sur le disque, économisent les ressources réseau lors du transfert et utilisent les capacités de calcul de manière plus efficace.
3. Sécurité: des images plus petites contiennent généralement moins de composants inutiles, ce qui diminue le risque de failles potentielles.
4. Simplification des mises à jour: mettre à jour des images légères est plus rapide et demande moins de ressources, ce qui accélère le process de maintenance.

6.2 Stratégies pour réduire la taille des images Docker

1. Utilisation d'images de base minimales

Le choix de l'image de base influence directement la taille finale de l'image Docker. L'utilisation d'images de base minimales comme alpine permet de réduire significativement la taille de l'image.

Exemple :

Remplacement de l'image ubuntu par alpine :

# FROM ubuntu:20.04
FROM alpine:3.12

alpine est une distribution Linux légère qui occupe environ 5 MB, tandis que l'image ubuntu peut occuper des centaines de mégaoctets.

2. Minimisation du nombre de layers

Chaque instruction dans un Dockerfile ajoute un nouveau layer à l'image. Combiner plusieurs commandes dans une seule instruction RUN réduit le nombre de layers, ce qui aide à réduire la taille globale de l'image.

Exemple :

Avant optimisation :

RUN apt-get update
RUN apt-get install -y curl
RUN apt-get install -y git
RUN rm -rf /var/lib/apt/lists/*

Après optimisation :

RUN apt-get update && apt-get install -y curl git && rm -rf /var/lib/apt/lists/*

Supprimer le cache du gestionnaire de paquets (rm -rf /var/lib/apt/lists/*) réduit également la taille de l'image en supprimant les fichiers temporaires créés pendant l'installation.

3. Suppression des fichiers temporaires

Supprimer les fichiers temporaires et les données inutiles après l'installation des paquets aide à maintenir l'image propre et légère.

Exemple :

RUN apt-get update && apt-get install -y curl git && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/*

4. Utilisation du fichier .dockerignore

Le fichier .dockerignore aide à exclure les fichiers et répertoires inutiles du contexte de construction, réduisant ainsi la taille de l'image et accélérant le processus de construction.

Exemple .dockerignore :

node_modules
dist
*.log
Dockerfile*
.dockerignore

5. Construction multi-stage (multi-stage builds)

La construction multi-stage permet d'utiliser plusieurs images intermédiaires pour créer une image finale légère qui contient uniquement les fichiers et dépendances nécessaires.

Exemple :

# Étape de construction
FROM node:14 AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build

# Étape finale
FROM nginx:alpine
COPY --from=builder /app/build /usr/share/nginx/html

Dans cet exemple, la première étape construit l'application, tandis que l'étape finale n'utilise que les résultats de la construction pour réduire la taille de l'image finale.

6. Optimisation de l'installation des paquets

N'installer que les paquets nécessaires et utiliser les options des gestionnaires de paquets pour une installation minimale permet de réduire la taille de l'image.

Exemple :

Utilisation du paramètre --no-install-recommends avec apt-get :

RUN apt-get update && apt-get install -y --no-install-recommends curl git && \
    rm -rf /var/lib/apt/lists/*

7. Compression et minimisation des données

L'utilisation d'outils pour compresser et minimiser les données aide à réduire la taille de l'image.

Exemple :

Compression de fichiers texte et de journaux :

RUN gzip /path/to/large/file.log

8. Suppression des bibliothèques et dépendances inutilisées

Supprimer les bibliothèques et dépendances inutilisées après l'installation des paquets nécessaires aide à maintenir l'image légère.

Exemple :

Pour les applications Python :

RUN pip install --no-cache-dir -r requirements.txt

6.3 Exemples de Dockerfile optimisés

Exemple 1 : Dockerfile optimisé pour Node.js

FROM node:14-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build
        
FROM nginx:alpine
COPY --from=builder /app/build /usr/share/nginx/html

Cet exemple utilise une construction multi-étapes. D'abord, l'application est construite dans une étape intermédiaire, puis uniquement les résultats de la construction sont copiés dans l'image finale basée sur Nginx.

Exemple 2 : Dockerfile optimisé pour Python

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

Dans cet exemple, une image de base légère python:3.9-slim est utilisée. L'installation des dépendances est placée dans une étape séparée, ce qui permet d'utiliser le cache Docker si le fichier requirements.txt n'a pas changé.