Quando si esegue Docker per molto tempo, ci sono molte immagini nel sistema. Come posso rimuovere tutte le immagini Docker inutilizzate contemporaneamente per liberare la memoria?

Inoltre, voglio anche rimuovere le immagini estratte mesi fa, che hanno il corretto TAG.

Quindi, non sto chiedendo di rimuovere solo immagini senza tag. Sto cercando un modo per rimuovere immagini inutilizzate generali, che includa sia le immagini senza tag sia altre immagini come quelle estratte mesi fa con corrette TAG.

Aggiornamento settembre 2016: Docker 1.13: PR 26108 e commit 86de7c0 introducono alcuni nuovi comandi per aiutare a visualizzare quanto spazio occupano i dati del daemon docker sul disco e consentire di eliminare facilmente l'eccesso "non necessario".

docker system pruneeliminerà TUTTI i dati penzolanti (cioè nell'ordine: contenitori fermi, volumi senza contenitori e immagini senza contenitori). Anche i dati non utilizzati, con -aopzione.

Hai anche:

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

Per immagini inutilizzate , utilizzare docker image prune -a(per rimuovere immagini pendenti e non consultate).
Avvertenza: " non utilizzato " significa "immagini non referenziate da nessun contenitore": fare attenzione prima dell'uso -a.

Come illustrato nella AL 's risposta , docker system prune --allrimuoverà tutti i inutilizzati immagini non solo penzoloni quelli ... che può essere un po' troppo.

La combinazione docker xxx prunecon l' --filteropzione può essere un ottimo modo per limitare la potatura ( docker SDK API 1.28 minimo, quindi docker 17.04+ )

I filtri attualmente supportati sono:

• until (<timestamp>) - rimuove solo i contenitori, le immagini e le reti create prima della data e ora
• label( label=<key>, label=<key>=<value>, label!=<key>, O label!=<key>=<value>) - rimuovere solo contenitori, immagini, reti e volumi con (o senza , in caso label!=...è utilizzato) le etichette specificate.

Vedi " Elimina le immagini " per un esempio.

Risposta originale (settembre 2016)

Di solito faccio:

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

Ho un alias per rimuovere quelle [immagini penzolanti] 13 :drmi

Il dangling=truefiltro trova immagini inutilizzate

In questo modo, qualsiasi immagine intermedia a cui non fa più riferimento un'immagine etichettata viene rimossa.

Faccio lo stesso prima per i processi usciti (container)

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

Come sottolinea haridsv nei commenti :

Tecnicamente, dovresti prima pulire i contenitori prima di ripulire le immagini, in quanto ciò catturerà più immagini penzolanti e meno errori .

Jess Frazelle (jfrazelle) ha la funzione 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
}

Per rimuovere vecchie immagini e non solo immagini "senza riferimenti", puoi considerare docker-gc:

Un semplice contenitore Docker e uno script di raccolta dati inutili.

• I contenitori che sono usciti più di un'ora fa vengono rimossi.
• Le immagini che non appartengono ad alcun contenitore rimanente dopo che sono state rimosse.

Aggiorna il secondo (08-07-2017):

Fare riferimento (di nuovo) a VonC, usando il più recente system prune. L'impaziente può saltare il prompt con l' -f, --forceopzione:

docker system prune -f

L'impaziente e sconsiderato possono inoltre rimuovere "immagini inutilizzate, non solo quelle penzolanti" con l' -a, --allopzione:

docker system prune -af

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

Aggiornare:

Fare riferimento alla risposta di VonC che utilizza i prunecomandi aggiunti di recente . Ecco la convenienza della shell alias corrispondente:

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

Vecchia risposta:

Elimina contenitori arrestati (usciti):

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

Elimina immagini non utilizzate (penzolanti):

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

Se hai prestato estrema cautela in merito alla perdita di dati irrevocabile , puoi eliminare i volumi non utilizzati (penzolanti) (v1.9 e successivi):

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

Eccoli in un comodo alias 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'

Riferimenti:

• docker ps -f
• docker rm
• docker images -f
• docker rmi
• Note sulla versione di Docker v1.9.0
• docker volume ls
• docker volume rm

Per rimuovere vecchie immagini taggate che hanno più di un mese:

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

Si noti che non riuscirà a rimuovere le immagini utilizzate da un contenitore, a cui si fa riferimento in un repository, con immagini secondarie dipendenti ... che è probabilmente ciò che si desidera. Altrimenti aggiungi -fbandiera.

Esempio di /etc/cron.daily/docker-gcsceneggiatura:

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

Le altre risposte sono fantastiche, in particolare:

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

Ma avevo bisogno di qualcosa nel mezzo dei due comandi, quindi l' filteropzione era ciò di cui avevo bisogno:

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

Spero che aiuti :)

Per riferimento: https://docs.docker.com/config/pruning/#prune-images

Supponendo di avere Docker 1.13 o versioni successive, è possibile utilizzare solo i comandi di eliminazione. Per la tua domanda specifica sulla rimozione di vecchie immagini, vuoi la prima.

# 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

Consiglierei di non abituarmi ad usare il docker system prunecomando. Suppongo che gli utenti rimuoveranno accidentalmente cose che non intendono fare. Personalmente userò principalmente i comandi docker image prunee docker container prune.

Fino ad ora (Docker versione 1.12) stiamo usando il seguente comando per eliminare tutti i container in esecuzione. Inoltre, se vogliamo eliminare i volumi, possiamo farlo manualmente usando il rispettivo tag -v nel seguente comando.

Elimina tutti i contenitori usciti

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

Elimina tutti i contenitori arrestati

docker rm $(docker ps -a -q)

Elimina tutti i contenitori in esecuzione e arrestati

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

Rimuovere tutti i contenitori, senza alcun criterio

docker container rm $(docker container ps -aq)

Ma, nella versione 1.13 e successive, per il sistema completo e la pulizia, possiamo utilizzare direttamente il seguente comando:

docker system prune

Tutti i contenitori, le immagini, le reti e i volumi non utilizzati verranno eliminati. Possiamo anche farlo usando i seguenti comandi per ripulire i singoli componenti:

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

Questo ha funzionato per me:

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

Il seguente comando eliminerà le immagini più vecchie di 48 ore.

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

Di recente ho scritto uno script per risolverlo su uno dei miei server:

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

Ecco uno script per ripulire le immagini Docker e recuperare lo spazio.

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

Sceneggiatura originale

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

Di solito Docker mantiene tutti i file temporanei relativi alla creazione dell'immagine e ai livelli

/ Var / lib / finestra mobile

Questo percorso è locale per il sistema, di solito nella partizione radice "/" .

È possibile montare uno spazio su disco più grande e spostare il contenuto /var/lib/dockernella nuova posizione di montaggio e creare un collegamento simbolico.

In questo modo, anche se le immagini Docker occupano spazio, ciò non influirà sul sistema in quanto utilizzerà un'altra posizione di montaggio.

Post originale: gestire le immagini Docker sul disco locale

Sto usando questo 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

Ciò rimuoverà tutte le immagini il cui tempo di creazione è superiore a 10 settimane fa.

Se desideri rimuovere le immagini estratte X mesi fa, puoi provare l'esempio seguente che rimuove le immagini create tre mesi fa:

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

Per eliminare anche tutte le immagini e i volumi
docker system prune -af --volumes

docker system prune -a

(Ti verrà chiesto di confermare il comando. Usa -fper forzare la corsa, se sai cosa stai facendo.)

@VonC ha già dato una risposta molto bella, ma per completezza ecco un piccolo script che ho usato --- e che annulla anche qualsiasi processo Docker se dovessi avere alcuni:

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

Per rimuovere le immagini taggate che non hanno container in esecuzione, dovrai usare un piccolo 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

Rimuovi i vecchi contenitori settimane fa.

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

Rimuovi le vecchie immagini settimane fa. Stai attento. Questo rimuoverà le immagini di base che sono state create settimane fa ma che potrebbero essere utilizzate dalle tue nuove immagini.

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

Come rimuovere un'immagine taggata

1. docker rmi prima il tag

2. docker rmi l'immagine.

   # che può essere fatto in una chiamata rmi docker ad es .: # docker rmi <repo: tag> <imageid>

(funziona il novembre 2016, Docker versione 1.12.2)

per esempio

$ 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

ad es. con script rimuovere qualcosa di più vecchio di 2 settimane.

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 forza

-a tutto

-q in modalità

docker rm `docker ps -aq`

o

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

Di tanto in tanto mi sono imbattuto in problemi in cui Docker allocerà e continuerà a utilizzare lo spazio su disco, anche quando lo spazio non è assegnato a nessuna particolare immagine o contenitore esistente. L'ultimo modo in cui ho generato questo problema per errore è stato l'utilizzo di centos build "docker-engine" anziché "docker" in RHEL 7.1. Ciò che sembra accadere a volte è che le pulizie del contenitore non vengono completate correttamente e quindi lo spazio non viene mai riutilizzato. Quando l'unità da 80 GB che ho allocato come / era piena di file / var / lib / docker, ho dovuto trovare un modo creativo per risolvere il problema.

Ecco cosa mi è venuto in mente. Innanzitutto per risolvere l'errore completo del disco:

1. Stop docker: systemctl stop docker
2. Allocato un nuovo disco montato come dire / mnt / docker.
3. Sposta tutti i file in / var / lib / docker in / mnt / docker. Ho usato il comando: rsync -aPHSx --remove-source-files / var / lib / docker / / mnt / docker /
4. Montare la nuova unità su / var / lib / docker.

A questo punto non ho più avuto un errore completo del disco, ma stavo ancora sprecando una grande quantità di spazio. I prossimi passi sono di occuparsene.

1. Start Docker: systemctl start docker

2. Salva tutte le immagini: finestra mobile salva $ (immagini finestra mobile | sed -e '/ ^ / d' -e '/ ^ REPOSITORY / d' -e 's, [] [] ,:,' -e 's, [ ]. ,, ')> /root/docker.img

3. Disinstalla docker.

4. Cancella tutto in / var / lib / docker: rm -rf / var / lib / docker / [cdintv] *

5. Reinstallare la finestra mobile

6. Abilita docker: systemctl abilita docker

7. Start docker: systemctl start docker

8. Ripristina immagini: docker load </root/docker.img

9. Avviare eventuali contenitori persistenti che è necessario eseguire.

Ciò ha ridotto l'utilizzo del mio disco da 67 GB per docker a 6 GB per docker.

Non lo consiglio per l'uso quotidiano. Ma è utile eseguire quando sembra che la finestra mobile abbia perso la traccia dello spazio su disco utilizzato a causa di errori del software o riavvii imprevisti.

Se si desidera ripulire automaticamente / periodicamente i contenitori usciti e rimuovere immagini e volumi non utilizzati da un contenitore in esecuzione, è possibile scaricare l'immagine meltwater/docker-cleanup.

Corri:

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

Viene eseguito ogni 30 minuti per impostazione predefinita. Puoi comunque impostare il tempo di ritardo usando questo flag in secondi (opzione DELAY_TIME = 1800).

Maggiori dettagli: https://github.com/meltwater/docker-cleanup/blob/master/README.md

Se costruisci tu stesso queste immagini potate (da alcune altre immagini di base più vecchie), fai attenzione alle soluzioni accettate sopra basate su docker image prune, poiché il comando è smussato e proverà a rimuovere anche tutte le dipendenze richieste dalle tue ultime immagini (il comando dovrebbe essere probabilmente rinominato in docker image*s* prune).

La soluzione che mi è venuta in mente per le pipeline di creazione dell'immagine della mia finestra mobile (dove sono presenti build e tag giornalieri = le date sono nel YYYYMMDDformato) è questa:

# 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

Esistono plug -in sparrow docker-remove-dangling-images che è possibile utilizzare per ripulire i contenitori interrotti e le immagini non utilizzate (penzoloni):

$ sparrow plg run docker-remove-dangling-images

Funziona sia per sistemi operativi Linux che Windows.

Innanzitutto, esegui docker imagesper visualizzare un elenco di immagini e copia l'ID HASH IMMAGINE negli Appunti.

Correre docker rmi -f <Image>

Ricorda che l'opzione -fè l'eliminazione forzata.