tag - eliminar imagen docker




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

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 el TAG correcto.

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 etiqueta correcta.


docker system prune -a

(Se le pedirá que confirme el comando. Use -f para 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 Docker en caso de que tengas 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

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 dacker de Docker en el disco y permiten limpiar fácilmente el exceso "innecesario".

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

Tu también tienes:

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

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

La combinación de la docker xxx prune con la opción --filter 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 se eliminan los contenedores, las imágenes y las redes creadas antes de la marca de tiempo dada
  • label ( label=<key> , label=<key>=<value> , label!=<key> , o label!=<key>=<value> ) - solo elimine contenedores, imágenes, redes y volúmenes con ( o sin , en caso de que se use label!=... ) 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 filtro dangling=true encuentra imágenes no utilizadas

De esa manera, cualquier imagen intermedia que ya no esté referenciada por una imagen etiquetada se elimina.

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.

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 de /var/lib/docker a 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


Esto funcionó para mí:

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

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.


Hay un complemento 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.


Las otras respuestas son geniales, específicamente:

# 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

Pero necesitaba algo en el medio de los dos comandos, por lo que la opción de filter era lo que necesitaba:

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

Espero que ayude :)

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


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 no podrá eliminar las imágenes que utiliza un contenedor, al que se hace referencia en un repositorio, tiene imágenes secundarias dependientes ... que probablemente es lo que desea. De lo contrario, solo agregue la bandera -f .

Ejemplo de script /etc/cron.daily/docker-gc :

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

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

Primero, ejecute las docker images para ver la lista de imágenes y copie el ID DE HASH DE IMAGEN en el portapapeles.

Ejecute docker rmi -f <Image>

Recuerde que la opción -f es forzar la eliminación.


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

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

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

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


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-image