Cómo eliminar imágenes Docker antiguas y sin usar


762

Cuando se ejecuta Docker durante mucho tiempo, hay muchas imágenes en el sistema. ¿Cómo puedo eliminar todas las imágenes de Docker no utilizadas a la vez de forma segura para liberar el almacenamiento?

Además, también quiero eliminar las imágenes extraídas hace meses, que tienen la correcta TAG.

Por lo tanto, no estoy pidiendo eliminar solo imágenes sin etiquetar. Estoy buscando una manera de eliminar las imágenes generales no utilizadas, que incluye imágenes sin etiquetar y otras, como las que se obtuvieron hace meses con la correcta TAG.

Respuestas:


1402

Actualización de septiembre de 2016: Docker 1.13: PR 26108 y commit 86de7c0 introducen algunos comandos nuevos para ayudar a facilitar la visualización de cuánto espacio ocupan los datos del demonio de Docker en el disco y permiten limpiar fácilmente el exceso "innecesario".

docker system pruneeliminará TODOS los datos colgantes (es decir, en orden: contenedores detenidos, volúmenes sin contenedores e imágenes sin contenedores). Incluso datos no utilizados, con -aopción.

Tu también tienes:

Para imágenes sin usar , use docker image prune -a(para eliminar imágenes colgantes y sin usar).
Advertencia: ' sin usar ' significa "imágenes a las que ningún contenedor hace referencia": tenga cuidado antes de usar -a.

Como se ilustra en la respuesta de AL , eliminará todas las imágenes no utilizadas, no solo las que cuelgan ... lo que puede ser demasiado.docker system prune --all

La combinación docker xxx prunecon la --filteropción puede ser una excelente manera de limitar la poda ( docker SDK API 1.28 mínimo, por lo que docker 17.04+ )

Los filtros compatibles actualmente son:

  • until (<timestamp>) - solo elimine contenedores, imágenes y redes creados antes de la marca de tiempo dada
  • label( label=<key>, label=<key>=<value>, label!=<key>, O label!=<key>=<value>) - solamente eliminar los recipientes, imágenes, redes, y los volúmenes con (o sin , en caso de que label!=...se utiliza) las etiquetas especificadas.

Consulte " Podar imágenes " para ver un ejemplo.


Respuesta original (septiembre de 2016)

Yo suelo hacer:

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

Tengo un alias para eliminar esas [imágenes colgantes] 13 :drmi

El dangling=truefiltro encuentra imágenes no utilizadas

De esa forma, se elimina cualquier imagen intermedia que ya no haga referencia a una imagen etiquetada.

Hago lo mismo primero para los procesos salidos (contenedores)

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

Como haridsv señala en los comentarios :

Técnicamente, primero debe limpiar los contenedores antes de limpiar las imágenes, ya que esto capturará más imágenes colgantes y menos errores .


Jess Frazelle (jfrazelle) tiene la función 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
}

Para eliminar imágenes antiguas, y no solo imágenes "colgantes sin referencia", puede considerar docker-gc:


Un simple contenedor de Docker y script de recolección de basura de imagen.

  • Los contenedores que salieron hace más de una hora se eliminan.
  • Las imágenes que no pertenecen a ningún contenedor restante después de eso se eliminan.

29
¿Existe documentación sobre lo que "dangling=true"realmente significa?
CivFan

1
Este script no puede eliminar algunas imágenes extraídas hace meses
Quanlong

2
dcleanup¡es increíble!
Quanlong

44
@herm Primero, docker system pruneelimina mucho más que solo imágenes. Asegúrese de usar docker image pruneen su lugar. Y tenga mucho cuidado con -a: a docker system prune -apuede tener un efecto devastador (también eliminando volúmenes). Finalmente, sí, -aelimina las imágenes no utilizadas, editaré la respuesta.
VonC

2
@stom: 'no utilizado' significa "imágenes a las que ningún contenedor hace referencia, pero colgar significa que no está etiquetado (solo una identificación).
VonC

125

Actualice el segundo (2017-07-08):

Consulte (nuevamente) a VonC, utilizando el aún más reciente system prune. El impaciente puede omitir el mensaje con la -f, --forceopción:

docker system prune -f

Los impacientes y temerarios también pueden eliminar "imágenes no utilizadas, no solo las que cuelgan" con la -a, --allopción:

docker system prune -af

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

Actualizar:

Consulte la respuesta de VonC que utiliza los prunecomandos agregados recientemente . Aquí está la conveniencia de alias de shell correspondiente:

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

Vieja respuesta:

Eliminar contenedores detenidos (salidos):

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

Eliminar imágenes no utilizadas (colgantes):

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

Si ha ejercido una extrema precaución con respecto a la pérdida irrevocable de datos , puede eliminar los volúmenes no utilizados (colgantes) (v1.9 y posteriores):

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

Aquí están en un conveniente alias de shell:

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'

Referencias


3
Tendría precaución con la limpieza del volumen. Tanto los volúmenes de contenedor creados automáticamente como los volúmenes con nombre que no están actualmente en uso se enumeran junto con el dangling = true.
BMitch

1
@BMitch, tienes toda la razón; He agregado una severa advertencia a la docker volume rmreceta. Agradeceré cualquier sugerencia que tenga.
rubicks

1
Me encantaría que Docker nos diera una opción de filtro diferente para los volúmenes nombrados. Si se me ocurre una buena solución, me aseguraré de compartir.
BMitch

2
sí, pero desafortunadamente no separa el volumen nombrado de un volumen contenedor anónimo con una simple marca. El comando que he estado usando es el docker volume ls -qf dangling=true | egrep '^[a-z0-9]{64}$' | xargs --no-run-if-empty docker volume rmque funcionará siempre que nunca nombre sus volúmenes con algo similar a un guid. Puedo ajustar esto para la nueva sintaxis de filtro.
BMitch

1
¡Eliminar volúmenes no utilizados (colgantes) realmente nos ayuda!
Kane

61

Para eliminar viejas imágenes etiquetadas que tienen más de un mes:

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

Tenga en cuenta que va a fallar para eliminar las imágenes que se utilizan en un recipiente, se hace referencia en un repositorio, tiene imágenes de niños dependientes ... que es probablemente lo que quiere. De lo contrario, solo agregue la -fbandera.

Ejemplo 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

2
+1 Para el comando para eliminar imágenes antiguas de docker. Es un poco raro, pero la solución es original y funciona perfectamente :)
Rick

3
Esto es bueno, sin embargo, creo que esto solo elimina las imágenes de la ventana acoplable que tienen al menos 4 meses de antigüedad. .CreatedSinceusa semanas como la unidad de tiempo en la salida incluso en imágenes que tienen muchas semanas de antigüedad, por ejemplo 12 weeks.
joelittlejohn

2
Esto funcionó para mí, agradable y simple:docker images | grep ' months' | awk '{ print $3 }' | xargs --no-run-if-empty docker rmi -f
Kent Bull

34

Las otras respuestas son geniales, específicamente:

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

Pero necesitaba algo en medio de los dos comandos, así que la filteropción era lo que necesitaba:

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

Espero que ayude :)

Para referencia: https://docs.docker.com/config/pruning/#prune-images


1
Respuesta muy subestimada! Poder podar con una fecha de corte es extremadamente útil.
Nik Reiman

24

Suponiendo que tiene Docker 1.13 o superior, puede usar los comandos de poda. Para su pregunta específica para eliminar imágenes antiguas, desea la primera.

# 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

Recomendaría no acostumbrarse a usar el docker system prunecomando. Creo que los usuarios eliminarán accidentalmente cosas que no pretenden. Personalmente, voy a usar principalmente los comandos docker image pruney docker container prune.


44
no quieres podar redes no utilizadas, ¿verdad? por ejemplo, si todos los contenedores se detienen y elimino esas redes, ¿cómo funcionarán si los inicio? ¿Las redes se crean junto con Docker Run?
meffect

@meffect Estoy completamente de acuerdo y descubrí que había salido de la red. Incluí eso y agregué una parte al final que indica que no recomendaría usar docker system prunesino las ciruelas pasas individuales.
Programador

15

Hasta ahora (Docker versión 1.12) estamos utilizando el siguiente comando para eliminar todos los contenedores en ejecución. Además, si queremos eliminar los volúmenes, podemos hacerlo manualmente usando su respectiva etiqueta -v en el siguiente comando.

Eliminar todos los contenedores salidos

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

Eliminar todos los contenedores detenidos

docker rm $(docker ps -a -q)

Eliminar todos los contenedores en ejecución y detenidos

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

Retire todos los contenedores, sin ningún criterio.

docker container rm $(docker container ps -aq)

Pero, en la versión 1.13 y superior, para el sistema completo y la limpieza, podemos usar directamente el siguiente comando:

docker system prune

Todos los contenedores, imágenes, redes y volúmenes no utilizados se eliminarán. También podemos hacer esto usando los siguientes comandos que limpian los componentes individuales:

docker container prune
docker image prune
docker network prune
docker volume prune

14

Esto funcionó para mí:

docker rmi $(docker images | grep "^<none>" | awk "{print $3}")

13

El siguiente comando eliminará imágenes de más de 48 horas.

$ docker image prune --all --filter until=48h

1
El uso de filtros también es posible para enumerar todas las versiones antes de una versión especificada: docker image ls --all --filter reference=monolito --filter before=monolito:0.1.8y luego aplicar un comando rmi para eliminar. docker rmi $(docker image ls -q --all --filter reference=monolito --filter before=monolito:0.1.8)
rodvlopes

9

Recientemente escribí un script para resolver esto en uno de mis servidores:

#!/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

8

Aquí hay un script para limpiar las imágenes de Docker y recuperar el espacio.

#!/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.

Guion original

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

Por lo general, Docker mantiene todos los archivos temporales relacionados con la creación de imágenes y capas en

/ var / lib / docker

Esta ruta es local al sistema, generalmente en LA partición raíz, "/" .

Puede montar un espacio de disco más grande y mover el contenido /var/lib/dockera la nueva ubicación de montaje y crear un enlace simbólico.

De esta manera, incluso si las imágenes de Docker ocupan espacio, no afectará a su sistema, ya que utilizará alguna otra ubicación de montaje.

Publicación original: administre las imágenes de Docker en el disco local


6

Estoy usando este comando:

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

Esto eliminará todas las imágenes cuyo tiempo de creación sea mayor que hace 10 semanas.


Creo que intercambiaste IMAGE_CTIMEy BEFORE_DATETIMEen ese echocomando
Udo G

5

Si desea eliminar imágenes extraídas hace X meses, puede probar el siguiente ejemplo que elimina imágenes creadas hace tres meses:

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

1
Esto no es correcto. Esto elimina las imágenes creadas hace 3 meses, no las imágenes extraídas hace 3 meses (si las extrae de una fuente remota, ya pueden tener 3 meses de inmediato).
Andrew Ferrier

Esto me ayudó a crear más filtros, basados ​​en diferentes criterios
david.sansay

4

Para podar todas las imágenes y volúmenes también
docker system prune -af --volumes


3

docker system prune -a

(Se le pedirá que confirme el comando. Utilícelo -fpara forzar la ejecución, si sabe lo que está haciendo).


55
Esto es peligroso , vea otros comentarios sobre cómo docker system pruneeliminar incluso los volúmenes con nombre -a.
RichVel

3

@VonC ya dio una respuesta muy agradable, pero para completar, aquí hay un pequeño script que he estado usando --- y que también destruye cualquier proceso de recado Docker si tienes algunos:

#!/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

Funciona muy bien pero aún puede obtener Error response from daemon: You cannot remove a running container. Agregado docker kill $(docker ps -q)antes de la línea 3 para abordar
Vincent

¿Por qué no usar en $(docker images -q)lugar de $(docker images | awk '/<none>/ { print $3 }')?
SeF

1
@SeF: si lo hago docker images -q, obtengo un vector de identificadores de imagen, nada más. Si hago lo que hago, obtengo más, lo que me permite filtrar <none>como lo hago aquí. ¿Tiene sentido?
Dirk Eddelbuettel

2

Para eliminar imágenes etiquetadas que no tienen un contenedor en ejecución, deberá usar un pequeño 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

2

Retire los contenedores viejos hace semanas.

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

Eliminar imágenes antiguas hace semanas. Ten cuidado. Esto eliminará las imágenes base que se crearon hace semanas pero que podrían estar usando sus nuevas imágenes.

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


2

Cómo eliminar una imagen etiquetada

  1. docker rmi la etiqueta primero

  2. docker rmi la imagen.

    # que se puede hacer en una llamada docker rmi, por ejemplo: # docker rmi <repo: tag> <imageid>

(esto funciona en noviembre de 2016, Docker versión 1.12.2)

p.ej

$ 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

Por ejemplo, eliminar por secuencias de comandos cualquier cosa anterior a 2 semanas.

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

2
docker rm $(docker ps -faq)
docker rmi $(docker ps -faq)

-f fuerza

-a todos

-q en el modo


1
docker rm `docker ps -aq`

o

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

3
Creo que esta respuesta es peligrosa porque esos comandos eliminan contenedores. En primer lugar, OP preguntaba cómo eliminar imágenes, no contenedores. Y lo que es más importante, esos comandos pueden causar la pérdida de datos debido a que las personas pueden tener algunos datos valiosos en contenedores salidos.
u.unver34

Debe describir los resultados potencialmente no deseados de aplicar estos comandos en el servidor de producción.
Daniel

Esto elimina los contenedores, no las imágenes.
SeF

1

Ocasionalmente, me he encontrado con problemas en los que Docker asignará y continuará utilizando el espacio en disco, incluso cuando el espacio no esté asignado a ninguna imagen en particular o contenedor existente. La última forma en que generé este problema accidentalmente fue usando la construcción de centos "motor acoplable" en lugar de "acoplador" en RHEL 7.1. Lo que parece suceder es que a veces las limpiezas de contenedores no se completan con éxito y luego el espacio nunca se reutiliza. Cuando la unidad de 80 GB que asigné como / estaba llena de archivos / var / lib / docker, tuve que encontrar una forma creativa de resolver el problema.

Esto es lo que se me ocurrió. Primero para resolver el error completo del disco:

  1. Stop docker: systemctl stop docker
  2. Asignado una nueva unidad montada como say / mnt / docker.
  3. Mueva todos los archivos en / var / lib / docker a / mnt / docker. Usé el comando: rsync -aPHSx --remove-source-files / var / lib / docker / / mnt / docker /
  4. Monte la nueva unidad en / var / lib / docker.

En este punto ya no tenía un error de disco lleno, pero todavía estaba desperdiciando una gran cantidad de espacio. Los siguientes pasos son ocuparse de eso.

  1. Start Docker: systemctl start docker

  2. Guarde todas las imágenes: docker save $ (imágenes de docker | sed -e '/ ^ / d' -e '/ ^ REPOSITORY / d' -e 's, [] [] ,:,' -e 's, [ ]. ,, ')> /root/docker.img

  3. Desinstalar la ventana acoplable.

  4. Borre todo en / var / lib / docker: rm -rf / var / lib / docker / [cdintv] *

  5. Vuelva a instalar la ventana acoplable

  6. Habilitar docker: systemctl enable docker

  7. Iniciar docker: systemctl start docker

  8. Restaurar imágenes: docker load </root/docker.img

  9. Inicie cualquier contenedor persistente que necesite ejecutar.

Esto redujo el uso de mi disco de 67 GB para docker a 6 GB para docker.

No lo recomiendo para uso diario. Pero es útil para ejecutar cuando parece que Docker ha perdido la pista del espacio en disco usado debido a errores de software o reinicios inesperados.


1

Si desea limpiar automáticamente / periódicamente los contenedores salidos y eliminar imágenes y volúmenes que no están en uso por un contenedor en ejecución, puede descargar la imagen meltwater/docker-cleanup .

Solo corre:

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

Se ejecuta cada 30 minutos por defecto. Sin embargo, puede establecer el tiempo de retraso utilizando este indicador en segundos (opción DELAY_TIME = 1800).

Más detalles: https://github.com/meltwater/docker-cleanup/blob/master/README.md


1

Si construye estas imágenes podadas usted mismo (de algunas otras imágenes base más antiguas), tenga cuidado con las soluciones aceptadas anteriormente basadas docker image prune, ya que el comando es contundente e intentará eliminar también todas las dependencias requeridas por sus últimas imágenes (el comando debe ser probablemente renombrado a docker image*s* prune).

La solución que se me ocurrió para las canalizaciones de compilación de imágenes de mi ventana acoplable (donde hay compilaciones diarias y etiquetas = las fechas están en el YYYYMMDDformato) es esta:

# 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

0

Hay un plugin de gorrión docker-remove-dangling-images que puede usar para limpiar contenedores detenidos e imágenes no utilizadas (colgantes):

$ sparrow plg run docker-remove-dangling-images

Funciona tanto para el sistema operativo Linux y Windows.


0

Primer intento docker images para ver la lista de imágenes y copie el ID de HASH de IMAGEN en el portapapeles.

correr docker rmi -f <Image>

La opción de recordar -fes forzar la eliminación.

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.