Skip to content
arch.log | Corentin BRINGER

Réduire la taille de vos conteneurs Docker

Dans le monde de la conteneurisation, avoir des images Docker légères, c’est un peu comme voyager avec un bagage cabine : plus rapide, plus pratique, et beaucoup moins de stress. Voici quelques astuces concrètes pour optimiser vos images Docker.

1. Optez pour des images de base légères Fondamental

Section titled “1. Optez pour des images de base légères ”

Commencer avec une image légère, c’est comme construire une maison avec des briques plutôt que des rochers. Faites le bon choix dès le départ.

Exemple Spring Boot :

Section titled “Exemple Spring Boot :”

dockerfile FROM eclipse-temurin:21

L’image eclipse-temurin:21-jre-alpine offre tout ce dont vous avez besoin sans les extras inutiles. Moins de poids, plus de vitesse.

2. Faites le ménage

Section titled “2. Faites le ménage”

Installer des dépendances, c’est bien, mais pensez à faire le ménage après pour ne pas encombrer votre image avec des fichiers temporaires inutiles.

RUN apt-get update
RUN apt-get install -y openjdk-21-jre
RUN apt-get clean
RUN rm -rf /var/lib/apt/lists/*

Le ménage post-installation garantit une image propre et efficace. Pas de déchets !

3. Utilisez .dockerignore

Section titled “3. Utilisez .dockerignore”

Comme avec .gitignore, le fichier .dockerignore vous permet d’exclure tout ce qui n’a pas besoin d’être dans votre image Docker (et croyez-moi, il y en a souvent beaucoup).

Exemple de .dockerignore :

target/
.git

En ignorant des dossiers comme target/ ou .git, vous réduisez directement la taille de votre image. Gardez uniquement l’essentiel.

4. Minimisez les couches Performance

Section titled “4. Minimisez les couches ”

Chaque instruction RUN, COPY ou ADD ajoute une couche à votre image. Trop de couches ? Trop de poids ! Combinez-les pour un Dockerfile plus compact.

RUN apt-get update && apt-get install -y \
    openjdk-21-jre && \
    apt-get clean && \
    rm -rf /var/lib/apt/lists/*

Moins de couches, c’est une image plus légère et une construction plus rapide. Simple, non ?

Ah, l’erreur classique du composant <Steps> ! Je plaide coupable, j’ai voulu faire trop propre avec les titres en dehors des blocs de code.

Le composant <Steps> de Starlight est très pointilleux : il veut un seul et unique bloc de liste ordonnée (1., 2., etc.). Si tu insères un bloc de code entre deux items de liste, le Markdown interprète cela comme deux listes séparées par un div, et <Steps> perd les pédales.

Pour corriger ça, il faut imbriquer le code directement dans l’item de la liste (en utilisant l’indentation).

Voici le bloc corrigé pour ton fichier .mdx :

5. Builds multi-steps : faites simple, faites efficace

Section titled “5. Builds multi-steps : faites simple, faites efficace”

Les builds multi-steps permettent de tout faire dans une première étape (compilation, tests, etc.) et de ne garder que le strict nécessaire dans l’image finale.

  1. Étape 1 : Compilation On utilise une image Maven complète pour compiler le projet.

    FROM maven:3.9.9-eclipse-temurin-21 AS build
    WORKDIR /app
    COPY . .
    RUN mvn clean package -DskipTests

  2. Étape 2 : Déploiement

    On ne garde que le JAR final sur une image JRE légère.

    FROM eclipse-temurin:21-jre-alpine
    COPY --from=build /app/target/*.jar /app/app.jar
    CMD ["java", "-jar", "/app/app.jar"]

Ce processus divise le travail en étapes claires et optimise le résultat final. Votre image sera légère et prête pour la production.

Conclusion

Section titled “Conclusion”

En appliquant ces astuces, vous pouvez transformer vos images Docker en véritables modèles d’efficacité. Moins de poids, plus de rapidité, et des déploiements fluides 🚀.