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.

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:

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

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.

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

• docker ps -f
• docker rm
• docker images -f
• docker rmi
• Notas de la versión de Docker v1.9.0
• docker volume ls
• docker volume rm

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

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

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.

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

Esto funcionó para mí:

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

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

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

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

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

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.

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

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

docker system prune -a

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

@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

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

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; }')

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

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

-f fuerza

-a todos

-q en el modo

docker rm `docker ps -aq`

o

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

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.

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

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

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.

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.