Docker : Comment supprimer des images, conteneurs et volumes

Les conteneurs et images Docker s'accumulent rapidement. Votre système se remplit d'images inutilisées, de conteneurs arrêtés et de volumes orphelins. L'espace disque se remplit. Le nettoyage devient nécessaire.

Mais le nettoyage peut être délicat. Supprimer la mauvaise chose, et vous cassez votre pipeline. Supprimer une image dont quelqu'un dépend, et votre déploiement échoue.

Ce guide vous montre exactement comment nettoyer Docker en toute sécurité, des commandes de base aux stratégies de niveau production.

Comprendre les couches de stockage Docker

Avant de nettoyer, comprenez ce que Docker stocke :

Images : Les modèles. Chaque image est immuable et peut être utilisée pour démarrer plusieurs conteneurs.

Conteneurs : Instances en cours d'exécution (ou arrêtées) des images. Chaque conteneur a une couche accessible en écriture au-dessus de l'image.

Volumes : Stockage de données persistant. Séparé des images et conteneurs.

Cache de compilation : Couches intermédiaires de docker build, utilisées pour accélérer les reconstructions.

Le nettoyage doit respecter les dépendances. Vous ne pouvez pas supprimer une image si un conteneur en dépend (même un conteneur arrêté).

Supprimer des images Docker

Lister les images

D'abord, voyez ce que vous avez :

docker images

Le résultat affiche : REPOSITORY, TAG, IMAGE ID, SIZE et la date de création.

Pour lister uniquement les images orphelines (images sans tags, généralement abandonnées) :

docker images -f "dangling=true"

Supprimer des images spécifiques

Supprimez une image unique par nom ou ID :

docker rmi image_name:tag

Ou par ID d'image :

docker rmi abc123def456

Supprimez plusieurs images à la fois :

docker rmi image1:tag1 image2:tag2 image3:tag3

Si un conteneur (même arrêté) utilise l'image, vous devez d'abord arrêter et supprimer le conteneur :

docker rm container_id
docker rmi image_id

Pour forcer la suppression (agressif, non recommandé en production) :

docker rmi -f image_id

Supprimer toutes les images orphelines

Les images orphelines sont des images abandonnées laissées par des compilations échouées ou des mises à jour :

docker image prune

Confirmez lorsque vous y êtes invité. C'est sûr, les images orphelines ne sont utilisées par rien.

Pour forcer sans confirmation :

docker image prune -f

Supprimez toutes les images inutilisées (y compris celles non référencées par aucun conteneur) :

docker image prune -a

C'est plus agressif. Utilisez-le quand vous savez que vous voulez un nettoyage en profondeur.

Supprimer des conteneurs Docker

Lister les conteneurs

Consultez tous les conteneurs (en cours d'exécution et arrêtés) :

docker ps -a

Affichez uniquement les conteneurs en cours d'exécution :

docker ps

Supprimer des conteneurs spécifiques

Supprimez un conteneur arrêté :

docker rm container_id

Supprimez par nom :

docker rm container_name

Si le conteneur est toujours en cours d'exécution, arrêtez-le d'abord :

docker stop container_id
docker rm container_id

Ou combinez arrêt et suppression :

docker rm -f container_id

Supprimer tous les conteneurs arrêtés

docker container prune

Cela supprime tous les conteneurs arrêtés. Les conteneurs en cours d'exécution sont sûrs.

Confirmez lorsque vous y êtes invité, ou forcez avec :

docker container prune -f

Supprimer des volumes Docker

Les volumes persistent indépendamment. Un volume peut survivre au conteneur qui l'a créé.

Lister les volumes

docker volume ls

Trouvez les volumes orphelines (non utilisés par aucun conteneur) :

docker volume ls -f "dangling=true"

Supprimer des volumes spécifiques

docker volume rm volume_name

Supprimez par nom :

docker volume rm my_app_data

Supprimez plusieurs volumes :

docker volume rm vol1 vol2 vol3

Supprimer tous les volumes orphelines

docker volume prune

Confirmez lorsque vous y êtes invité. Cela supprime les volumes non utilisés par aucun conteneur.

Forcez sans confirmation :

docker volume prune -f

Nettoyage complet : Docker System Prune

L'option nucléaire (mais sûre pour les objets orphelins) :

docker system prune

Cela supprime en une commande :

Tous les conteneurs arrêtés
Toutes les images orphelines
Tous les volumes orphelines
Tous les réseaux inutilisés

Forcez sans confirmation :

docker system prune -f

Pour supprimer également toutes les images inutilisées (pas seulement les orphelines) :

docker system prune -a

Pour supprimer également les volumes :

docker system prune -a --volumes

Cela supprime :

Tous les conteneurs arrêtés
Toutes les images inutilisées
Tous les volumes inutilisés
Tous les réseaux inutilisés

Utilisez cela quand vous voulez un nettoyage complet. C'est sûr tant que vous n'avez pas de conteneurs arrêtés ou d'images que vous prévoyez de réutiliser.

Meilleures pratiques Docker modernes : Optimisation de la compilation

Le nettoyage devient moins nécessaire si vous créez des images plus petites dès le départ.

Compilations multi-étapes

Les compilations multi-étapes réduisent considérablement la taille finale de l'image :

# Étape de compilation
FROM golang:1.21 AS builder
WORKDIR /app
COPY . .
RUN go build -o myapp .

# Étape finale - image d'exécution minuscule
FROM alpine:latest
COPY --from=builder /app/myapp /myapp
ENTRYPOINT ["/myapp"]

Les dépendances de l'étape de compilation (compilateur Go, outils de compilation) ne font pas partie de l'image finale. Taille finale : souvent 10-50 Mo au lieu de 500 Mo+.

Meilleures pratiques Dockerfile

Ordonnez les couches des moins changeantes aux plus changeantes :

FROM ubuntu:22.04
# Dépendances de base (rarement modifiées)
RUN apt-get update && apt-get install -y curl jq

# Dépendances d'application (changent occasionnellement)
COPY requirements.txt .
RUN pip install -r requirements.txt

# Code source (change fréquemment)
COPY . .

ENTRYPOINT ["python", "app.py"]

Docker met en cache les couches. Si vous modifiez le code source, Docker ne reconstruit que cette couche et au-delà. Les dépendances coûteuses sont déjà en cache.

Utilisez des images de base plus petites :

Image de base	Taille
ubuntu:22.04	77 Mo
debian:12-slim	28 Mo
alpine:latest	7 Mo
scratch	0 Mo (pour les binaires statiques)

Alpine peut créer des images 10 fois plus petites que Ubuntu.

Nettoyage du cache de compilation

Le système de compilation docker maintient les couches de cache. Purgez le cache de compilation obsolète :

docker builder prune

Supprimez tout le cache de compilation :

docker builder prune -a

Nettoyage Docker en production : Kubernetes/Hikube

Si vous exécutez Docker en production via Kubernetes (comme Hikube.cloud), la gestion des conteneurs est différente.

Cycle de vie des conteneurs dans Kubernetes

Kubernetes supprime automatiquement les conteneurs lorsque les pods sont supprimés. Vous ne supprimez pas manuellement les conteneurs.

Cependant, les anciennes images s'accumulent sur les nœuds. Kubernetes dispose d'une collecte des ordures intégrée :

# Les images sont collectées quand :
# - inutilisées depuis plus de 5 minutes (configurable)
# - ET l'utilisation du disque du nœud > seuil (généralement 85%)

Stratégie de nettoyage d'images pour Kubernetes

1. Utilisez des tags d'image spécifiques, pas latest :

# Bon : version explicite
image: myapp:v1.2.3

# À éviter : tag 'latest' masque les anciennes images
image: myapp:latest

Les tags spécifiques préviennent les restaurations accidentelles vers les anciennes versions et facilitent la collecte des ordures.

2. Définissez une imagePullPolicy appropriée :

# Pour les images de votre registre privé
imagePullPolicy: IfNotPresent  # Utilisez la copie locale si elle existe

# Pour les images que vous mettez à jour fréquemment
imagePullPolicy: Always  # Récupérez toujours la version fraîche

3. Utilisez des hooks de cycle de vie d'image pour le nettoyage :

Pour les clusters auto-hébergés, implémentez le nettoyage d'images :

# Sur chaque nœud, périodiquement :
docker image prune -a --filter "until=72h" -f

Cela supprime les images inutilisées depuis 3+ jours.

4. Limitez la rétention d'images dans votre registre :

Dans votre registre de conteneurs (Docker Hub, ECR, Harbor, etc.), définissez des politiques de nettoyage automatique :

# Exemple de règle de nettoyage Harbor :
Pattern: "*"
Keep the recent: 10  # Conservez seulement les 10 dernières images par référentiel

Considérations Hikube

Si vous utilisez Hikube (Kubernetes managé de Hidora) :

Le stockage des nœuds est géré automatiquement
La collecte des ordures s'exécute sur tous les nœuds
Le nettoyage des images respecte vos exigences de déploiement
Aucune intervention manuelle nécessaire

Hikube gère le nettoyage des images dans le cadre du service managé, vous permettant de vous concentrer sur les déploiements d'applications.

Automatiser le nettoyage

Le nettoyage manuel est oublié. Automatisez-le :

Docker System Prune via Cron

Créez un script de nettoyage :

#!/bin/bash
# /usr/local/bin/docker-cleanup.sh
docker system prune -a --volumes -f
echo "Docker cleanup completed at $(date)" >> /var/log/docker-cleanup.log

Rendez-le exécutable :

chmod +x /usr/local/bin/docker-cleanup.sh

Ajoutez à crontab (exécutez hebdomadairement) :

crontab -e
# Ajoutez la ligne :
0 2 * * 0 /usr/local/bin/docker-cleanup.sh

Nettoyage du pipeline CI/CD

Dans votre GitHub Actions ou GitLab CI, ajoutez le nettoyage des images :

# Exemple GitHub Actions
- name: Clean up Docker images
  run: docker image prune -a -f --filter "until=720h"

Cela s'exécute après les déploiements, conservant les images récentes mais supprimant les anciennes.

Liste de contrôle de nettoyage sécurisé

Avant d'exécuter les commandes de nettoyage :

Vérifiez quelles images/conteneurs/volumes seront supprimés
Listez-les d'abord (sans drapeau -f)
Confirmez qu'aucun conteneur en cours d'exécution ne dépend de ces ressources
Vérifiez si un conteneur est arrêté mais prévu pour un redémarrage
Vérifiez que les volumes ne contiennent pas de données importantes
Ayez des sauvegardes des données d'état si nécessaire
Exécutez d'abord sur un système non critique
Documentez ce que vous nettoyez (à des fins d'audit)

Le résultat final

Le nettoyage Docker est simple une fois que vous comprenez les dépendances :

Supprimez les images que vous n'utilisez pas : docker image prune
Supprimez les conteneurs arrêtés : docker container prune
Supprimez les volumes inutilisés : docker volume prune
Ou faites tout à la fois : docker system prune

Pour la production, préférez :

Les compilations multi-étapes pour garder les images petites
Les tags spécifiques au lieu de 'latest'
La collecte des ordures Kubernetes (automatique)
Les horaires de nettoyage automatisés

Dans les environnements Kubernetes managés comme Hikube, le nettoyage des images est géré automatiquement, permettant à votre équipe de se concentrer sur le développement d'applications plutôt que sur la maintenance de l'infrastructure.

Lectures connexes

Exécutez Docker en production ? La plateforme Hikube d'Hidora gère le cycle de vie des images, la collecte des ordures et la complexité de l'infrastructure : Kubernetes managé (Hikube) · Consultation technique