Comment supprimer les images Docker anciennes et inutilisées

762

Lors de l'exécution de Docker pendant une longue période, il y a beaucoup d'images dans le système. Comment puis-je supprimer toutes les images Docker inutilisées à la fois pour libérer de l'espace de stockage?

En outre, je souhaite également supprimer les images extraites il y a des mois, qui sont correctes TAG.

Donc, je ne demande pas de supprimer uniquement les images non marquées. Je cherche un moyen de supprimer les images générales inutilisées, qui incluent à la fois les images non marquées et d'autres images telles que celles tirées il y a des mois avec correct TAG.

Quanlong
la source

Réponses:

1402

Mise à jour de septembre 2016: Docker 1.13: PR 26108 et commit 86de7c0 introduisent quelques nouvelles commandes pour faciliter la visualisation de l'espace que les données du démon docker prennent sur le disque et permettant de nettoyer facilement l'excès «inutile».

docker system prunesupprimera TOUTES les données pendantes (c'est-à-dire dans l'ordre: conteneurs arrêtés, volumes sans conteneurs et images sans conteneurs). Même les données inutilisées, avec -aoption.

Vous avez aussi:

Pour les images inutilisées , utilisez docker image prune -a(pour supprimer les images pendantes et non marquées).
Attention: « inutilisé » signifie «images non référencées par aucun conteneur»: soyez prudent avant utilisation -a.

Comme illustré dans la réponse de AL , supprimera toutes les images inutilisées , pas seulement celles qui pendent ... ce qui peut être un peu trop.docker system prune --all

La combinaison docker xxx pruneavec l' --filteroption peut être un excellent moyen de limiter l'élagage ( docker SDK API 1.28 minimum, donc docker 17.04+ )

Les filtres actuellement pris en charge sont les suivants:

  • until (<timestamp>) - supprimer uniquement les conteneurs, les images et les réseaux créés avant l'horodatage donné
  • label( label=<key>, label=<key>=<value>, label!=<key>, Ou label!=<key>=<value>) - seulement retirer des récipients, des images, des réseaux et des volumes avec (ou sans , dans le cas où label!=...est utilisé) , les étiquettes spécifiées.

Voir " Prune images " pour un exemple.


Réponse originale (sept. 2016)

Je fais habituellement:

docker rmi $(docker images --filter "dangling=true" -q --no-trunc)

J'ai un alias pour supprimer ces [images pendantes] 13 :drmi

Le dangling=truefiltre trouve les images inutilisées

De cette façon, toute image intermédiaire qui n'est plus référencée par une image étiquetée est supprimée.

Je fais la même chose d' abord pour les processus sortis (conteneurs)

alias drmae='docker rm $(docker ps -qa --no-trunc --filter "status=exited")'

Comme le souligne haridsv dans les commentaires :

Techniquement, vous devez d'abord nettoyer les conteneurs avant de nettoyer les images, car cela capturera plus d'images pendantes et moins d'erreurs .


Jess Frazelle (jfrazelle) a la fonction bashrc :

dcleanup(){
    docker rm -v $(docker ps --filter status=exited -q 2>/dev/null) 2>/dev/null
    docker rmi $(docker images --filter dangling=true -q 2>/dev/null) 2>/dev/null
}

Pour supprimer les anciennes images, et pas seulement les images "sans référence", vous pouvez envisager docker-gc:


Un conteneur Docker simple et un script de récupération de place d'image.

  • Les conteneurs sortis il y a plus d'une heure sont supprimés.
  • Les images qui n'appartiennent à aucun conteneur restant après cela sont supprimées.
VonC
la source
29
Existe-t-il une documentation sur ce que "dangling=true"signifie réellement?
CivFan
1
Ce script ne peut pas supprimer certaines images extraites il y a des mois
Quanlong
2
dcleanupest génial!
Quanlong du
4
@herm Tout d'abord, docker system prunesupprime bien plus que des images. Assurez-vous d'utiliser à la docker image pruneplace. Et soyez très prudent avec -a: un docker system prune -apeut avoir un effet dévastateur (en supprimant également les volumes). Enfin, oui, -asupprime les images inutilisées, je vais modifier la réponse.
VonC
2
@stom: «inutilisé» signifie «des images qui ne sont référencées par aucun conteneur, mais pendantes signifie pas du tout étiquetées (juste un identifiant).
VonC
125

Mettre à jour le second (2017-07-08):

Reportez-vous (encore) à VonC, en utilisant le plus récent encore system prune. Les impatients peuvent sauter l'invite avec l' -f, --forceoption:

docker system prune -f

Les impatients et les imprudents peuvent en outre supprimer "les images inutilisées, pas seulement celles qui pendent" avec l' -a, --alloption:

docker system prune -af

https://docs.docker.com/engine/reference/commandline/system_prune/

Mise à jour:

Reportez-vous à la réponse de VonC qui utilise les prunecommandes récemment ajoutées . Voici la commodité de l'alias de shell correspondant:

alias docker-clean=' \
  docker container prune -f ; \
  docker image prune -f ; \
  docker network prune -f ; \
  docker volume prune -f '

Ancienne réponse:

Supprimer les conteneurs arrêtés (sortis):

$ docker ps --no-trunc -aqf "status=exited" | xargs docker rm

Supprimez les images inutilisées (pendantes):

$ docker images --no-trunc -aqf "dangling=true" | xargs docker rmi

Si vous avez fait preuve d'une extrême prudence en ce qui concerne la perte de données irrévocable , vous pouvez supprimer les volumes inutilisés (pendants) (v1.9 et plus):

$ docker volume ls -qf "dangling=true" | xargs docker volume rm

Les voici dans un alias de shell pratique:

alias docker-clean=' \
  docker ps --no-trunc -aqf "status=exited" | xargs docker rm ; \
  docker images --no-trunc -aqf "dangling=true" | xargs docker rmi ; \
  docker volume ls -qf "dangling=true" | xargs docker volume rm'

Références:

rubicks
la source
3
Je ferais preuve de prudence avec le nettoyage du volume. Les volumes de conteneur créés automatiquement et les volumes nommés qui ne sont pas actuellement utilisés sont répertoriés avec la balise = true.
BMitch
1
@BMitch, vous avez absolument raison; J'ai ajouté un avertissement sévère à la docker volume rmrecette. J'accueillerai vos suggestions.
rubicks
1
J'aimerais que Docker nous donne une option de filtre différente pour les volumes nommés. Si je trouve une bonne solution de contournement, je serai sûr de partager.
BMitch
2
oui, mais malheureusement, il ne sépare pas le volume nommé d'un volume de conteneur anonyme avec un simple indicateur. La commande que j'utilise est celle docker volume ls -qf dangling=true | egrep '^[a-z0-9]{64}$' | xargs --no-run-if-empty docker volume rmqui fonctionnera tant que vous ne nommerez jamais vos volumes avec quelque chose de similaire à un guid. Je peux modifier cela pour la nouvelle syntaxe de filtre.
BMitch
1
La suppression des volumes inutilisés (pendantes) nous aide vraiment!
Kane
61

Pour supprimer les anciennes images balisées datant de plus d'un mois:

$ docker images --no-trunc --format '{{.ID}} {{.CreatedSince}}' \
    | grep ' months' | awk '{ print $1 }' \
    | xargs --no-run-if-empty docker rmi

Notez qu'il ne parviendra pas à supprimer les images utilisées par un conteneur, référencées dans un référentiel, qui ont des images enfants dépendantes ... ce qui est probablement ce que vous voulez. Sinon, ajoutez simplement le -fdrapeau.

Exemple de /etc/cron.daily/docker-gcscript:

#!/bin/sh -e

# Delete all stopped containers (including data-only containers).
docker ps -a -q --no-trunc --filter "status=exited" | xargs --no-run-if-empty docker rm -v

# Delete all tagged images more than a month old
# (will fail to remove images still used).
docker images --no-trunc --format '{{.ID}} {{.CreatedSince}}' | grep ' months' | awk '{ print $1 }' | xargs --no-run-if-empty docker rmi || true

# Delete all 'untagged/dangling' (<none>) images
# Those are used for Docker caching mechanism.
docker images -q --no-trunc --filter dangling=true | xargs --no-run-if-empty docker rmi

# Delete all dangling volumes.
docker volume ls -qf dangling=true | xargs --no-run-if-empty docker volume rm
Wernight
la source
2
+1 Pour la commande de suppression des anciennes images de docker. C'est un peu hacky, mais la solution est originale et fonctionne parfaitement :)
Rick
3
C'est bien mais je pense que cela ne supprime que les images docker qui ont au moins 4 mois . .CreatedSinceutilise des semaines comme unité de temps dans la sortie même sur des images vieilles de plusieurs semaines, par exemple 12 weeks.
joelittlejohn
2
Cela a fonctionné pour moi, simple et agréable:docker images | grep ' months' | awk '{ print $3 }' | xargs --no-run-if-empty docker rmi -f
Kent Bull
34

Les autres réponses sont excellentes, en particulier:

docker system prune # doesn't clean out old images
docker system prune --all # cleans out too much

Mais j'avais besoin de quelque chose au milieu des deux commandes, donc l' filteroption était ce dont j'avais besoin:

docker image prune --all --filter "until=4320h" # delete images older than 6 months ago; 4320h = 24 hour/day * 30 days/month * 6 months

J'espère que cela pourra aider :)

Pour référence: https://docs.docker.com/config/pruning/#prune-images

Zhao Li
la source
1
Réponse très sous-estimée! Pouvoir tailler avec une date limite est extrêmement utile.
Nik Reiman
24

En supposant que vous avez Docker 1.13 ou supérieur, vous pouvez simplement utiliser les commandes de pruneau. Pour votre question spécifiquement pour supprimer les anciennes images, vous voulez la première.

# Remove unused images
docker image prune

# Remove stopped containers.
docker container prune

# Remove unused volumes
docker volume prune

# Remove unused networks
docker network prune

# Command to run all prunes:
docker system prune

Je recommanderais de ne pas vous habituer à utiliser la docker system prunecommande. Je pense que les utilisateurs supprimeront accidentellement des choses qu'ils ne veulent pas. Personnellement, je vais principalement utiliser les commandes docker image pruneet docker container prune.

Programster
la source
4
vous ne voulez pas tailler les réseaux inutilisés, n'est-ce pas? comme si tous les conteneurs sont arrêtés et que je supprime ces réseaux, comment fonctionneront-ils si je les démarre. Est-ce que les réseaux sont créés avec Docker Run?
meffect
@meffect Je suis tout à fait d'accord et je pense que j'avais laissé l'élagage du réseau. J'ai inclus cela et ajouté une partie à la fin indiquant que je ne recommanderais pas d'utiliser docker system prunemais les pruneaux individuels.
Programster
15

Jusqu'à présent (Docker version 1.12), nous utilisons la commande suivante pour supprimer tous les conteneurs en cours d'exécution. De plus, si nous voulons supprimer les volumes, nous pouvons le faire manuellement en utilisant sa balise respective -v dans la commande suivante.

Supprimer tous les conteneurs sortis

docker rm $(docker ps -q -f status=exited)

Supprimer tous les conteneurs arrêtés

docker rm $(docker ps -a -q)

Supprimer tous les conteneurs en cours d'exécution et arrêtés

docker stop $(docker ps -a -q)
docker rm $(docker ps -a -q)

Retirez tous les conteneurs, sans aucun critère

docker container rm $(docker container ps -aq)

Mais, dans la version 1.13 et supérieure, pour le système complet et le nettoyage, nous pouvons directement utiliser la commande suivante:

docker system prune

Tous les conteneurs, images, réseaux et volumes inutilisés seront supprimés. Nous pouvons également le faire en utilisant les commandes suivantes qui nettoient les composants individuels:

docker container prune
docker image prune
docker network prune
docker volume prune
mohan08p
la source
14

Cela a fonctionné pour moi:

docker rmi $(docker images | grep "^<none>" | awk "{print $3}")
Mahmoud Zalt
la source
13

La commande suivante supprimera les images de plus de 48 heures.

$ docker image prune --all --filter until=48h
Shree Prakash
la source
1
L'utilisation de filtres est également possible pour répertorier toutes les versions avant une version spécifiée: docker image ls --all --filter reference=monolito --filter before=monolito:0.1.8puis appliquer une commande rmi pour supprimer. docker rmi $(docker image ls -q --all --filter reference=monolito --filter before=monolito:0.1.8)
rodvlopes
9

J'ai récemment écrit un script pour résoudre ce problème sur l'un de mes serveurs:

#!/bin/bash

# Remove all the dangling images
DANGLING_IMAGES=$(docker images -qf "dangling=true")
if [[ -n $DANGLING_IMAGES ]]; then
    docker rmi "$DANGLING_IMAGES"
fi

# Get all the images currently in use
USED_IMAGES=($( \
    docker ps -a --format '{{.Image}}' | \
    sort -u | \
    uniq | \
    awk -F ':' '$2{print $1":"$2}!$2{print $1":latest"}' \
))

# Get all the images currently available
ALL_IMAGES=($( \
    docker images --format '{{.Repository}}:{{.Tag}}' | \
    sort -u \
))

# Remove the unused images
for i in "${ALL_IMAGES[@]}"; do
    UNUSED=true
    for j in "${USED_IMAGES[@]}"; do
        if [[ "$i" == "$j" ]]; then
            UNUSED=false
        fi
    done
    if [[ "$UNUSED" == true ]]; then
        docker rmi "$i"
    fi
done
Ell Neal
la source
8

Voici un script pour nettoyer les images Docker et récupérer l'espace.

#!/bin/bash -x
## Removing stopped container
docker ps -a | grep Exited | awk '{print $1}' | xargs docker rm

## If you do not want to remove all container you can have filter for days and weeks old like below
#docker ps -a | grep Exited | grep "days ago" | awk '{print $1}' | xargs docker rm
#docker ps -a | grep Exited | grep "weeks ago" | awk '{print $1}' | xargs docker rm

## Removing Dangling images
## There are the layers images which are being created during building a Docker image. This is a great way to recover the spaces used by old and unused layers.

docker rmi $(docker images -f "dangling=true" -q)

## Removing images of perticular pattern For example
## Here I am removing images which has a SNAPSHOT with it.

docker rmi $(docker images | grep SNAPSHOT | awk '{print $3}')

## Removing weeks old images

docker images | grep "weeks ago" | awk '{print $3}' | xargs docker rmi

## Similarly you can remove days, months old images too.

Script original

https://github.com/vishalvsh1/docker-image-cleanup

Docker conserve généralement tous les fichiers temporaires liés à la création d'images et aux couches à

/ var / lib / docker

Ce chemin est local au système, généralement sur LA partition racine, "/" .

Vous pouvez monter un espace disque plus grand et déplacer le contenu de /var/lib/dockervers le nouvel emplacement de montage et créer un lien symbolique.

De cette façon, même si les images Docker occupent de l'espace, cela n'affectera pas votre système car il utilisera un autre emplacement de montage.

Article d'origine: gérer les images Docker sur le disque local

vishal sahasrabuddhe
la source
6

J'utilise cette commande:

export BEFORE_DATETIME=$(date --date='10 weeks ago' +"%Y-%m-%dT%H:%M:%S.%NZ")
docker images -q | while read IMAGE_ID; do
    export IMAGE_CTIME=$(docker inspect --format='{{.Created}}' --type=image ${IMAGE_ID})
    if [[ "${BEFORE_DATETIME}" > "${IMAGE_CTIME}" ]]; then
        echo "Removing ${IMAGE_ID}, ${BEFORE_DATETIME} is earlier then ${IMAGE_CTIME}"
        docker rmi -f ${IMAGE_ID};
    fi;
done

Cela supprimera toutes les images dont le temps de création est supérieur à 10 semaines auparavant.

Yonatan Kiron
la source
Je pense que vous avez échangé IMAGE_CTIMEet BEFORE_DATETIMEdans cette echocommande
Udo G
5

Si vous souhaitez supprimer des images extraites il y a X mois, vous pouvez essayer l'exemple ci-dessous qui supprime les images créées il y a trois mois:

three_months_old_images=`docker images | grep -vi "<none>" | tr -s ' ' | cut -d" " -f3,4,5,6 | grep "3 months ago" | cut -d" " -f1`
docker rmi $three_months_old_images
spectre007
la source
1
Ce n'est pas correct. Cela supprime les images créées il y a 3 mois, pas les images extraites il y a 3 mois (si vous les retirez d'une source distante, elles peuvent déjà avoir 3 mois immédiatement).
Andrew Ferrier
Cela m'a aidé à créer plus de filtres, en fonction de différents critères
david.sansay
4

Pour tailler également toutes les images et tous les volumes
docker system prune -af --volumes

Zaytsev Dmitry
la source
3

docker system prune -a

(Vous serez invité à confirmer la commande. Utilisez -fpour forcer l'exécution, si vous savez ce que vous faites.)

Vojtech Vitek
la source
5
C'est dangereux , voir les autres commentaires sur la docker system prunesuppression de volumes même nommés avec -a.
RichVel
3

@VonC a déjà donné une très belle réponse, mais pour être complet, voici un petit script que j'utilise --- et qui annule également tous les processus de Docker si vous en avez:

#!/bin/bash

imgs=$(docker images | awk '/<none>/ { print $3 }')
if [ "${imgs}" != "" ]; then
   echo docker rmi ${imgs}
   docker rmi ${imgs}
else
   echo "No images to remove"
fi

procs=$(docker ps -a -q --no-trunc)
if [ "${procs}" != "" ]; then
   echo docker rm ${procs}
   docker rm ${procs}
else
   echo "No processes to purge"
fi
Dirk Eddelbuettel
la source
Fonctionne très bien mais peut toujours l'être Error response from daemon: You cannot remove a running container. Ajouté docker kill $(docker ps -q)avant la ligne 3 pour adresser
Vincent
Pourquoi ne pas utiliser à la $(docker images -q)place de $(docker images | awk '/<none>/ { print $3 }')?
SeF
1
@SeF: Si je le fais, docker images -qj'obtiens un vecteur d'identifiants d'image, rien d'autre. Si je fais ce que je fais, j'obtiens plus - me permettant de filtrer <none>comme je le fais ici. Logique?
Dirk Eddelbuettel
2

Pour supprimer les images marquées qui n'ont pas de conteneur en cours d'exécution, vous devrez utiliser un petit script:

#!/bin/bash

# remove not running containers
docker rm $(docker ps -f "status=exited" -q)

declare -A used_images

# collect images which has running container
for image in $(docker ps | awk 'NR>1 {print $2;}'); do
    id=$(docker inspect --format="{{.Id}}" $image);
    used_images[$id]=$image;
done

# loop over images, delete those without a container
for id in $(docker images --no-trunc -q); do
    if [ -z ${used_images[$id]} ]; then
        echo "images is NOT in use: $id"
        docker rmi $id
    else
        echo "images is in use:     ${used_images[$id]}"
    fi
done
araignée
la source
2

Retirez les vieux conteneurs il y a des semaines.

docker rm $(docker ps -a | grep "weeks" | awk '{ print $1; }')

Supprimer les anciennes images il y a des semaines. Faites attention. Cela supprimera les images de base qui ont été créées il y a des semaines mais que vos nouvelles images pourraient utiliser.

docker rmi $(docker images | grep 'weeks' | awk '{ print $3; }')

Antony.H
la source
2

Comment supprimer une image balisée

  1. docker rmi le tag en premier

  2. docker rmi l'image.

    # qui peut être fait en un seul appel docker rmi par exemple: # docker rmi <repo: tag> <imageid>

(cela fonctionne novembre 2016, Docker version 1.12.2)

par exemple

$ docker images 
REPOSITORY              TAG                 IMAGE ID            CREATED             SIZE
usrxx/the-application   16112805            011fd5bf45a2        12 hours ago        5.753 GB
usryy/the-application   vx.xx.xx            5af809583b9c        3 days ago          5.743 GB
usrzz/the-application   vx.xx.xx            eef00ce9b81f        10 days ago         5.747 GB
usrAA/the-application   vx.xx.xx            422ba91c71bb        3 weeks ago         5.722 GB
usrBB/the-application   v1.00.18            a877aec95006        3 months ago        5.589 GB

$ docker rmi usrxx/the-application:16112805 && docker rmi 011fd5bf45a2
$ docker rmi usryy/the-application:vx.xx.xx && docker rmi 5af809583b9c
$ docker rmi usrzz/the-application:vx.xx.xx eef00ce9b81f
$ docker rmi usrAA/the-application:vx.xx.xx 422ba91c71bb
$ docker rmi usrBB/the-application:v1.00.18 a877aec95006

Par exemple, le script supprime tout élément datant de plus de 2 semaines.

IMAGESINFO=$(docker images --no-trunc --format '{{.ID}} {{.Repository}} {{.Tag}} {{.CreatedSince}}' |grep -E " (weeks|months|years)")
TAGS=$(echo "$IMAGESINFO" | awk '{ print $2 ":" $3 }' )
IDS=$(echo "$IMAGESINFO" | awk '{ print $1 }' )
echo remove old images TAGS=$TAGS IDS=$IDS
for t in $TAGS; do docker rmi $t; done
for i in $IDS; do docker rmi $i; done
gaoithe
la source
2
docker rm $(docker ps -faq)
docker rmi $(docker ps -faq)

-f force

-un tout

-q dans le mode

Hamit YILDIRIM
la source
1
docker rm `docker ps -aq`

ou

docker rm $(docker ps -q -f status=exited)
mainframer
la source
3
Je pense que cette réponse est dangereuse car ces commandes suppriment les conteneurs. Premièrement, OP demandait comment supprimer des images, pas des conteneurs. Et plus important encore, ces commandes peuvent entraîner une perte de données car les personnes peuvent avoir des données précieuses dans les conteneurs sortants.
u.unver34
Vous devez décrire les résultats potentiellement indésirables de l'application de ces commandes sur le serveur de production.
Daniel
cela supprime les conteneurs, pas les images.
SeF
1

Parfois, j'ai rencontré des problèmes où Docker allouera et continuera à utiliser l'espace disque, même lorsque l'espace n'est pas alloué à une image particulière ou à un conteneur existant. La dernière façon dont j'ai généré ce problème accidentellement était d'utiliser la génération de centos "moteur docker" au lieu de "docker" dans RHEL 7.1. Ce qui semble se produire est parfois que les nettoyages des conteneurs ne sont pas terminés avec succès et que l'espace n'est jamais réutilisé. Lorsque le disque de 80 Go que j'ai alloué en tant que / était rempli de fichiers / var / lib / docker, j'ai dû trouver un moyen créatif de résoudre le problème.

Voici ce que j'ai trouvé. D'abord pour résoudre l'erreur de disque plein:

  1. Stop docker: systemctl stop docker
  2. Alloué un nouveau disque monté comme disons / mnt / docker.
  3. Déplacez tous les fichiers de / var / lib / docker vers / mnt / docker. J'ai utilisé la commande: rsync -aPHSx --remove-source-files / var / lib / docker / / mnt / docker /
  4. Montez le nouveau lecteur sur / var / lib / docker.

À ce stade, je n'avais plus d'erreur de disque plein, mais je gaspillais toujours une énorme quantité d'espace. Les prochaines étapes consistent à prendre soin de cela.

  1. Démarrer Docker: systemctl start docker

  2. Sauvegardez toutes les images: docker save $ (docker images | sed -e '/ ^ / d' -e '/ ^ REPOSITORY / d' -e 's, [] [] ,:,' -e 's, [ ]. ,, ')> /root/docker.img

  3. Désinstaller docker.

  4. Effacez tout dans / var / lib / docker: rm -rf / var / lib / docker / [cdintv] *

  5. Réinstaller Docker

  6. Activer le docker: systemctl activer le docker

  7. Démarrer Docker: Systemctl Start Docker

  8. Restaurer des images: chargement du docker </root/docker.img

  9. Démarrez les conteneurs persistants dont vous avez besoin en cours d'exécution.

Cela a fait chuter mon utilisation du disque de 67 Go pour docker à 6 Go pour docker.

Je ne le recommande pas pour un usage quotidien. Mais il est utile de l'exécuter lorsqu'il semble que le docker a perdu la trace de l'espace disque utilisé en raison d'erreurs logicielles ou de redémarrages inattendus.

briemers
la source
1

Si vous souhaitez nettoyer automatiquement / périodiquement les conteneurs sortis et supprimer les images et les volumes qui ne sont pas utilisés par un conteneur en cours d'exécution, vous pouvez télécharger l'image meltwater/docker-cleanup.

Exécutez simplement:

docker run -d -v /var/run/docker.sock:/var/run/docker.sock:rw  -v /var/lib/docker:/var/lib/docker:rw --restart=unless-stopped meltwater/docker-cleanup:latest

Il s'exécute toutes les 30 minutes par défaut. Vous pouvez cependant définir le temps de retard en utilisant ce drapeau en secondes (option DELAY_TIME = 1800).

Plus de détails: https://github.com/meltwater/docker-cleanup/blob/master/README.md

Innocent Anigbo
la source
1

Si vous créez vous-même ces images élaguées (à partir d'autres images de base plus anciennes), veuillez faire attention aux solutions acceptées ci-dessus docker image prune, car la commande est émoussée et essaiera de supprimer également toutes les dépendances requises par vos dernières images (la commande doit être probablement renommé en docker image*s* prune).

La solution que j'ai trouvée pour mes pipelines de construction d'images Docker (où il y a des versions quotidiennes et des balises = les dates sont au YYYYMMDDformat) est la suivante:

# carefully narrow down the image to be deleted (to avoid removing useful static stuff like base images)
my_deleted_image=mirekphd/ml-cpu-py37-vsc-cust

# define the monitored image (tested for obsolescence), which will be usually the same as deleted one, unless deleting some very infrequently built image which requires a separate "clock"
monitored_image=mirekphd/ml-cache

# calculate the oldest acceptable tag (date)
date_week_ago=$(date -d "last week" '+%Y%m%d')

# get the IDs of obsolete tags of our deleted image
# note we use monitored_image to test for obsolescence
my_deleted_image_obsolete_tag_ids=$(docker images --filter="before=$monitored_image:$date_week_ago" | grep $my_deleted_image | awk '{print $3}')

# remove the obsolete tags of the deleted image
# (note it typically has to be forced using -f switch)
docker rmi -f $my_deleted_image_obsolete_tag_ids
mirekphd
la source
0

Il y a des images de docker-remove-dangling- plugin de moineau que vous pouvez utiliser pour nettoyer les conteneurs arrêtés et les images inutilisées (pendantes):

$ sparrow plg run docker-remove-dangling-images

Il fonctionne à la fois pour Linux et Windows OS.

Alexey Melezhik
la source
0

Tout d'abord, exécutez docker imagespour voir la liste des images et copiez l'IMAGE HASH ID dans le presse-papiers.

Courir docker rmi -f <Image>

Rappelez-vous que l'option -fconsiste à forcer la suppression.

Le Khiem
la source