Ao executar o Docker por um longo período, há muitas imagens no sistema. Como posso remover todas as imagens não utilizadas do Docker de uma só vez para liberar o armazenamento?

Além disso, também quero remover imagens obtidas meses atrás, com as correções corretas TAG .

Portanto, não estou pedindo para remover apenas imagens não marcadas. Estou procurando uma maneira de remover imagens gerais não utilizadas, que incluem imagens sem marcação e outras, como as que foram obtidas meses atrás com a correta TAG.

Atualização em setembro de 2016: o Docker 1.13: PR 26108 e o commit 86de7c0 apresentam alguns novos comandos para facilitar a visualização de quanto espaço os dados do daemon do estivador estão ocupando no disco e permitindo limpar facilmente o excesso "desnecessário".

docker system pruneexcluirá TODOS os dados pendentes (ou seja, em ordem: contêineres parados, volumes sem contêineres e imagens sem contêineres). Mesmo dados não utilizados, com -aopção.

Você também tem:

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

Para imagens não utilizadas , use docker image prune -a(para remover imagens pendentes e não utilizadas).
Aviso: ' não utilizado ' significa "imagens não referenciadas por nenhum contêiner": tenha cuidado antes de usar-a .

Como ilustrado na AL 's resposta , docker system prune --allirá remover todos os não utilizados imagens não apenas balançando aqueles ... que pode ser um pouco demais.

Combinar docker xxx prunecom a --filteropção pode ser uma ótima maneira de limitar a remoção ( docker SDK API 1.28 no mínimo, portanto docker 17.04+ )

Os filtros atualmente suportados são:

• until (<timestamp>) - remova apenas contêineres, imagens e redes criadas antes do carimbo de data / hora
• label( label=<key>, label=<key>=<value>, label!=<key>Ou label!=<key>=<value>) - só remover os recipientes, imagens, redes e volumes com (ou sem , no caso label!=...é usado) os rótulos especificados.

Consulte " Remover imagens " para obter um exemplo.

Resposta original (setembro de 2016)

Eu costumo fazer:

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

Eu tenho um apelido para remover essas [imagens pendentes] 13 :drmi

O dangling=truefiltro encontra imagens não utilizadas

Dessa forma, qualquer imagem intermediária que não seja mais referenciada por uma imagem rotulada será removida.

Eu faço o mesmo primeiro para processos encerrados (contêineres)

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

Como haridsv aponta nos comentários :

Tecnicamente, você deve primeiro limpar os contêineres antes de limpar as imagens, pois isso captura mais imagens pendentes e menos erros .

Jess Frazelle (jfrazelle) tem a função 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 remover imagens antigas e não apenas imagens "pendentes não referenciadas", considere docker-gc:

Um contêiner Docker simples e um script de coleta de lixo de imagens.

• Os contêineres que saíram há mais de uma hora atrás são removidos.
• Imagens que não pertencem a nenhum contêiner restante depois disso são removidas.

Atualize o segundo (08/07/2017):

Consulte (novamente) o VonC, usando o ainda mais recente system prune. O impaciente pode ignorar o prompt com a -f, --forceopção:

docker system prune -f

O impaciente e imprudente pode remover adicionalmente "imagens não utilizadas, não apenas as pendentes" com a -a, --allopção:

docker system prune -af

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

Atualizar:

Consulte a resposta do VonC, que usa os prunecomandos adicionados recentemente . Aqui está a conveniência do alias do shell correspondente:

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

Resposta antiga:

Excluir contêineres parados (saídos):

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

Exclua imagens não utilizadas (pendentes):

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

Se você tiver tomado muito cuidado com relação à perda irrevogável de dados , poderá excluir volumes não utilizados (pendentes) (v1.9 e posterior):

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

Aqui eles estão em um conveniente apelido 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'

Referências:

• docker ps -f
• docker rm
• docker images -f
• docker rmi
• Notas de versão do Docker v1.9.0
• docker volume ls
• docker volume rm

Para remover imagens marcadas antigas com mais de um mês:

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

Observe que ele falhará ao remover imagens usadas por um contêiner, referenciadas em um repositório, com imagens filhas dependentes ... o que provavelmente é o que você deseja. Caso contrário, basta adicionar-f bandeira.

Exemplo 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

As outras respostas são ótimas, especificamente:

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

Mas eu precisava de algo no meio dos dois comandos, então a filteropção era o que eu precisava:

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 ajude :)

Para referência: https://docs.docker.com/config/pruning/#prune-images

Supondo que você tenha o Docker 1.13 ou superior, basta usar os comandos de remoção. Para sua pergunta especificamente para remover imagens antigas, você quer a primeira.

# 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

Eu recomendaria não me acostumar a usar o docker system prunecomando Eu acho que os usuários removerão acidentalmente coisas que não pretendem. Pessoalmente, vou usar principalmente os comandos docker image prunee docker container prune.

Até agora (Docker versão 1.12), estamos usando o seguinte comando para excluir todos os contêineres em execução. Além disso, se quisermos excluir os volumes, podemos fazer isso manualmente usando sua respectiva tag -v no comando a seguir.

Excluir todos os contêineres encerrados

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

Excluir todos os contêineres parados

docker rm $(docker ps -a -q)

Excluir todos os contêineres em execução e parados

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

Remova todos os recipientes, sem nenhum critério

docker container rm $(docker container ps -aq)

Porém, na versão 1.13 e superior, para limpeza e sistema completos, podemos usar diretamente o seguinte comando:

docker system prune

Todos os contêineres, imagens, redes e volumes não utilizados serão excluídos. Também podemos fazer isso usando os seguintes comandos que limpam os componentes individuais:

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

Isso funcionou para mim:

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

O comando a seguir excluirá imagens com mais de 48 horas.

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

Recentemente, escrevi um script para resolver isso em um dos meus 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

Aqui está um script para limpar imagens do Docker e recuperar o espaço.

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

Roteiro original

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

Normalmente, o Docker mantém todos os arquivos temporários relacionados à criação e às camadas de imagens em

/ var / lib / docker

Esse caminho é local para o sistema, geralmente na partição raiz, " " / " .

Você pode montar um espaço em disco maior e mover o conteúdo de /var/lib/docker para o novo local de montagem e criar um link simbólico.

Dessa forma, mesmo que as imagens do Docker ocupem espaço, isso não afetará o sistema, pois estará usando outro local de montagem.

Postagem original: Gerenciar imagens do Docker no disco local

Estou 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

Isso removerá todas as imagens cujo tempo de criação é maior que 10 semanas atrás.

Se você deseja remover imagens extraídas X meses atrás, tente o exemplo abaixo, que remove imagens criadas há três 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 remover todas as imagens e volumes também
docker system prune -af --volumes

docker system prune -a

(Você será solicitado a confirmar o comando. Use -fpara forçar a execução, se você souber o que está fazendo.)

O @VonC já deu uma resposta muito boa, mas, para completar, aqui está um pequeno script que eu tenho usado --- e que também destrói todos os processos do Docker, caso você tenha alguns:

#!/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 remover imagens marcadas que não possuem contêiner em execução, você precisará usar um pequeno 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

Remova os contêineres antigos semanas atrás.

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

Remova as imagens antigas semanas atrás. Seja cuidadoso. Isso removerá as imagens de base criadas há semanas, mas que as novas imagens podem estar usando.

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

Como remover uma imagem marcada

1. docker rmi a tag primeiro

2. docker rmi a imagem.

   # que pode ser feito em uma chamada do docker rmi, por exemplo: # docker rmi <repo: tag> <imageid>

(funciona em novembro de 2016, versão 1.12.2 do Docker)

por exemplo

$ 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 exemplo, com script remova qualquer coisa com mais de 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 force

-um tudo

-q no modo

docker rm `docker ps -aq`

ou

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

Ocasionalmente, tenho problemas com os quais o Docker alocará e continuará usando o espaço em disco, mesmo quando o espaço não estiver alocado para nenhuma imagem específica ou contêiner existente. A maneira mais recente de gerar esse problema acidentalmente foi usando a compilação de centos "docker-engine" em vez de "docker" no RHEL 7.1. O que parece acontecer é que, às vezes, as limpezas dos contêineres não são concluídas com êxito e o espaço nunca é reutilizado. Quando a unidade de 80 GB que aloquei como / foi preenchida com arquivos / var / lib / docker, tive que criar uma maneira criativa de resolver o problema.

Aqui está o que eu vim com. Primeiro para resolver o erro de disco cheio:

1. Parar janela de encaixe: systemctl stop docker
2. Alocou uma nova unidade montada como say / mnt / docker.
3. Mova todos os arquivos em / var / lib / docker para / mnt / docker. Eu usei o comando: rsync -aPHSx --remove-source-files / var / lib / docker / / mnt / docker /
4. Monte a nova unidade em / var / lib / docker.

Nesse ponto, eu não tinha mais um erro de disco cheio, mas ainda estava desperdiçando uma quantidade enorme de espaço. Os próximos passos são para cuidar disso.

1. Iniciar Docker: systemctl start docker

2. Salve todas as imagens: janela de encaixe save $ (imagens de janela de encaixe | sed -e '/ ^ / d' -e '/ ^ REPOSITORY / d' -e 's, [] [] ,:,' -e 's, [ ]. ,, ')> /root/docker.img

3. Desinstale a janela de encaixe.

4. Apague tudo em / var / lib / docker: rm -rf / var / lib / docker / [cdintv] *

5. Reinstalar a janela de encaixe

6. Ativar janela de encaixe: systemctl enable docker

7. Iniciar janela de encaixe: systemctl start docker

8. Restaurar imagens: carregamento do docker </root/docker.img

9. Inicie todos os contêineres persistentes que você precisa em execução.

Isso reduziu o uso do meu disco de 67 GB para docker para 6 GB para docker.

Eu não recomendo isso para o uso diário. Mas é útil executar quando parece que o docker perdeu o controle do espaço em disco usado devido a erros de software ou reinicializações inesperadas.

Se você deseja limpar automaticamente / periodicamente os contêineres existentes e remover imagens e volumes que não estão em uso por um contêiner em execução, é possível fazer o download da imagem meltwater/docker-cleanup .

Apenas corra:

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

É executado a cada 30 minutos por padrão. No entanto, você pode definir o tempo de atraso usando esse sinalizador em segundos (opção DELAY_TIME = 1800).

Mais detalhes: https://github.com/meltwater/docker-cleanup/blob/master/README.md

Se você mesmo criar essas imagens removidas (de outras imagens básicas mais antigas), tenha cuidado com as soluções aceitas acima, com base em docker image prune, pois o comando é brusco e tentará remover também todas as dependências exigidas pelas imagens mais recentes (o comando deve ser provavelmente renomeado paradocker image*s* prune ).

A solução que eu encontrei para meus pipelines de criação de imagem de janela de encaixe (onde existem compilações diárias e tags = datas estão no YYYYMMDDformato) é 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

Existem docker-remove-dangling-images do plugin pardal que você pode usar para limpar contêineres parados e imagens não usadas (dangling):

$ sparrow plg run docker-remove-dangling-images

Funciona para Linux e Windows OS.

Primeiro, corra docker imagespara ver a lista de imagens e copie o IMAGE HASH ID na área de transferência.

Corre docker rmi -f <Image>

A opção Lembrar -fé forçar exclusão.