Podczas długotrwałego uruchamiania Dockera w systemie jest wiele obrazów. Jak mogę jednocześnie usunąć wszystkie nieużywane obrazy Dockera, aby zwolnić pamięć?

Ponadto chcę również usunąć obrazy ściągnięte kilka miesięcy temu, które mają poprawne TAG.

Więc nie proszę o usunięcie tylko nieoznaczonych obrazów. Poszukuję sposobu na usunięcie ogólnie nieużywanych obrazów, które obejmują zarówno nieoznaczone, jak i inne obrazy, takie jak ściągnięte kilka miesięcy temu z poprawnością TAG.

Aktualizacja września 2016: Docker 1.13: PR 26108 i zatwierdzenie 86de7c0 wprowadzają kilka nowych poleceń, aby ułatwić wizualizację, ile miejsca zajmują dane demona dokera na dysku i pozwalając na łatwe usunięcie „niepotrzebnego” nadmiaru.

docker system pruneusunie WSZYSTKIE wiszące dane (tzn. W kolejności: pojemniki zatrzymane, woluminy bez pojemników i obrazy bez pojemników). Nawet nieużywane dane, z -aopcją.

Masz także:

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

W przypadku nieużywanych obrazów użyj docker image prune -a(do usuwania wiszących i nieskróconych obrazów).
Ostrzeżenie: „ nieużywany ” oznacza „obrazy, do których nie odwołuje się żaden pojemnik”: przed użyciem należy zachować ostrożność -a.

Jak pokazano na AL „s odpowiedzi , docker system prune --allusunie wszystkie nieużywane obrazy nie tylko zwisające z nich ... co może być trochę za dużo.

Połączenie docker xxx prunez --filteropcją może być świetnym sposobem na ograniczenie przycinania ( dokerujące SDK API 1.28 minimum, więc dokerowane 17.04+ )

Aktualnie obsługiwane filtry to:

• until (<timestamp>) - usuwaj tylko pojemniki, obrazy i sieci utworzone przed określonym znacznikiem czasu
• label( label=<key>, label=<key>=<value>, label!=<key>, Lub label!=<key>=<value>) - tylko usunąć pojemniki, obrazów, sieci i woluminów z (lub bez , w przypadek label!=...jest używany) określonych etykiet.

Zobacz przykład „ Przycinaj obrazy ”.

Oryginalna odpowiedź (wrzesień 2016)

Zwyklę robię:

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

Mam alias do usuwania tych [wiszących obrazów] 13 :drmi

dangling=trueFiltr wyszukuje nieużywane obrazów

W ten sposób usuwany jest każdy obraz pośredni, do którego nie ma już obrazu z etykietą.

To samo robię najpierw dla zakończonych procesów (kontenerów)

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

Jak wskazuje haridsv w komentarzach :

Technicznie rzecz biorąc, najpierw należy wyczyścić pojemniki przed czyszczeniem obrazów, ponieważ spowoduje to złapanie większej liczby wiszących obrazów i mniej błędów .

Jess Frazelle (jfrazelle) ma funkcję 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
}

Aby usunąć stare obrazy, a nie tylko obrazy „wiszące bez odniesienia”, możesz rozważyć docker-gc:

Prosty skrypt Docker do kontenerów i usuwania śmieci.

• Pojemniki, które opuściły ponad godzinę temu, są usuwane.
• Obrazy, które nie należą do żadnego pozostałego pojemnika po tym, są usuwane.

Zaktualizuj drugi (2017-07-08):

Odwołaj się (ponownie) do VonC, korzystając z jeszcze nowszej wersji system prune. Niecierpliwy może pominąć monit z -f, --forceopcją:

docker system prune -f

Niecierpliwi i lekkomyślni mogą dodatkowo usunąć „nieużywane obrazy, nie tylko wiszące” z -a, --allopcją:

docker system prune -af

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

Aktualizacja:

Zobacz odpowiedź VonC, która korzysta z ostatnio dodanych prunepoleceń. Oto odpowiedni dogodny alias powłoki:

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

Stara odpowiedź:

Usuń zatrzymane (opuszczone) kontenery:

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

Usuń nieużywane (wiszące) obrazy:

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

Jeśli zachowałeś szczególną ostrożność w odniesieniu do nieodwołalnej utraty danych , możesz usunąć nieużywane (wiszące) woluminy (wer. 1.9 i nowsze):

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

Oto one w wygodnym aliasie powłoki:

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'

Bibliografia:

• docker ps -f
• docker rm
• docker images -f
• docker rmi
• Informacje o wersji Docker v1.9.0
• docker volume ls
• docker volume rm

Aby usunąć stare oznaczone zdjęcia, które mają więcej niż miesiąc:

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

Zauważ, że nie uda się usunąć obrazów używanych przez kontener, do których odwołuje się repozytorium, ma zależne obrazy potomne ... co prawdopodobnie jest tym, czego chcesz. W przeciwnym razie po prostu dodaj -fflagę.

Przykład /etc/cron.daily/docker-gcskryptu:

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

Inne odpowiedzi są świetne, w szczególności:

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

Ale potrzebowałem czegoś w środku dwóch poleceń, więc filterpotrzebowałem tej opcji:

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

Mam nadzieję, że to pomoże :)

W celach informacyjnych: https://docs.docker.com/config/pruning/#prune-images

Zakładając, że masz Docker 1.13 lub wyższy, możesz po prostu użyć poleceń przycinania. Na swoje pytanie dotyczące usuwania starych obrazów potrzebujesz pierwszego.

# 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

Polecam nie przyzwyczaić się do korzystania z docker system prunepolecenia. Sądzę, że użytkownicy przypadkowo usuną rzeczy, których nie zamierzają. Osobiście zamierzam używać głównie poleceń docker image prunei docker container prune.

Do tej pory (wersja Docker 1.12) używamy następującego polecenia, aby usunąć wszystkie działające kontenery. Ponadto, jeśli chcemy usunąć woluminy, możemy to zrobić ręcznie, używając odpowiedniego znacznika -v w następującym poleceniu.

Usuń wszystkie opuszczone kontenery

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

Usuń wszystkie zatrzymane pojemniki

docker rm $(docker ps -a -q)

Usuń wszystkie uruchomione i zatrzymane pojemniki

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

Usuń wszystkie pojemniki bez żadnych kryteriów

docker container rm $(docker container ps -aq)

Ale w wersji 1.13 i nowszych do pełnego systemu i czyszczenia możemy bezpośrednio użyć następującego polecenia:

docker system prune

Wszystkie nieużywane pojemniki, obrazy, sieci i woluminy zostaną usunięte. Możemy to również zrobić za pomocą następujących poleceń, które oczyszczają poszczególne komponenty:

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

To działało dla mnie:

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

Następujące polecenie usunie obrazy starsze niż 48 godzin.

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

Niedawno napisałem skrypt, aby rozwiązać ten problem na jednym z moich serwerów:

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

Oto skrypt do czyszczenia obrazów Docker i odzyskania przestrzeni.

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

Oryginalny skrypt

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

Zazwyczaj Docker przechowuje wszystkie pliki tymczasowe związane z budowaniem obrazu i warstwami

/ var / lib / docker

Ta ścieżka jest lokalna dla systemu, zwykle na partycji root „/” .

Możesz zamontować większą przestrzeń dyskową i przenieść zawartość /var/lib/dockerdo nowej lokalizacji montowania oraz utworzyć dowiązanie symboliczne.

W ten sposób, nawet jeśli obrazy Dockera zajmą miejsce, nie wpłynie to na twój system, ponieważ będzie on używał innej lokalizacji montowania.

Oryginalny post: Zarządzaj obrazami Dockera na dysku lokalnym

Używam tego polecenia:

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

Spowoduje to usunięcie wszystkich zdjęć, których czas tworzenia jest dłuższy niż 10 tygodni temu.

Jeśli chcesz usunąć obrazy wyciągnięte X miesięcy temu, możesz wypróbować poniższy przykład, który usuwa obrazy utworzone trzy miesiące temu:

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

Aby przyciąć również wszystkie obrazy i tomy
docker system prune -af --volumes

docker system prune -a

(Zostaniesz poproszony o potwierdzenie polecenia. Użyj, -faby wymusić bieg, jeśli wiesz, co robisz).

@VonC już udzielił bardzo ładnej odpowiedzi, ale dla kompletności tutaj jest mały skrypt, którego używałem --- i który również nukuje wszelkie polecenia Dockera, jeśli masz jakieś:

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

Aby usunąć oznaczone obrazy, które nie mają uruchomionego kontenera, będziesz musiał użyć małego skryptu:

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

Usuń stare pojemniki tygodnie temu.

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

Usuń stare zdjęcia kilka tygodni temu. Bądź ostrożny. Spowoduje to usunięcie podstawowych obrazów, które zostały utworzone tygodnie temu, ale z których mogą korzystać Twoje nowe obrazy.

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

Jak usunąć oznaczony obraz

1. docker najpierw rmi tag

2. doker rmi obraz.

   #, które można wykonać w jednym wywołaniu rmi dokera, np .: # doker rmi <repo: tag> <imageid>

(działa to w listopadzie 2016 r., wersja Docker 1.12.2)

na przykład

$ 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

np. Skrypty usuwają wszystko starsze niż 2 tygodnie.

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 siła

-wszystko

-q w trybie

docker rm `docker ps -aq`

lub

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

Czasami napotykałem problemy, w których Docker przydziela i nadal wykorzystuje miejsce na dysku, nawet gdy miejsce to nie jest przydzielone do żadnego konkretnego obrazu ani istniejącego kontenera. Ostatnim sposobem, w jaki przypadkowo wygenerowałem ten problem, było użycie kompilacji centos „docker-engine” zamiast „docker” w RHEL 7.1. Wydaje się, że czasami zdarza się, że czyszczenie kontenerów nie kończy się pomyślnie, a wtedy przestrzeń nigdy nie jest ponownie wykorzystywana. Kiedy dysk o pojemności 80 GB przydzielony jako / został wypełniony plikami / var / lib / docker, musiałem wymyślić kreatywny sposób rozwiązania problemu.

Oto, co wymyśliłem. Najpierw usuń błąd pełnego dysku:

1. Zatrzymaj okno dokowane: Systemctl zatrzymaj okno dokowane
2. Przydzielono nowy dysk zamontowany jako say / mnt / docker.
3. Przenieś wszystkie pliki z / var / lib / docker do / mnt / docker. Użyłem polecenia: rsync -aPHSx --remove-source-files / var / lib / docker / / mnt / docker /
4. Zamontuj nowy dysk w / var / lib / docker.

W tym momencie nie miałem już błędu pełnego dysku, ale wciąż marnowałem ogromną ilość miejsca. Następne kroki to załatwić.

1. Uruchom Docker: systemctl start docker

2. Zapisz wszystkie obrazy: doker zapisz $ (obrazy dokera | sed -e '/ ^ / d' -e '/ ^ REPOSITORY / d' -e 's, [] [] ,:, „-e' s, [ ]. ,, ')> /root/docker.img

3. Odinstaluj okno dokowane.

4. Usuń wszystko w / var / lib / docker: rm -rf / var / lib / docker / [cdintv] *

5. Ponownie zainstaluj okno dokowane

6. Włącz okno dokowane: systemctl włącz okno dokowane

7. Uruchom okno dokowane: systemctl uruchom okno dokowane

8. Przywróć obrazy: ładowanie dokera </root/docker.img

9. Uruchom dowolne trwałe kontenery, które potrzebujesz uruchomić.

To zmniejszyło użycie mojego dysku z 67 GB dla dokera do 6 GB dla dokera.

Nie polecam tego do codziennego użytku. Przydatne jest jednak uruchamianie, gdy wygląda na to, że doker stracił pamięć zajmowanego miejsca na dysku, powodując błędy oprogramowania lub nieoczekiwane ponowne uruchomienie.

Jeśli chcesz automatycznie / okresowo czyścić opuszczone kontenery i usuwać obrazy i woluminy, które nie są używane przez działający kontener, możesz pobrać obraz meltwater/docker-cleanup.

Po prostu biegnij:

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

Domyślnie działa co 30 minut. Możesz jednak ustawić czas opóźnienia za pomocą tej flagi w sekundach (opcja DELAY_TIME = 1800).

Więcej informacji: https://github.com/meltwater/docker-cleanup/blob/master/README.md

Jeśli tworzysz te przycięte obrazy samodzielnie (z niektórych innych, starszych obrazów podstawowych), uważaj na powyższe zaakceptowane rozwiązania docker image prune, ponieważ polecenie jest tępe i spróbuje usunąć również wszystkie zależności wymagane przez twoje najnowsze obrazy (polecenie powinno być prawdopodobnie zmieniono jego nazwę na docker image*s* prune).

Rozwiązanie, które wymyśliłem dla moich potoków kompilacji obrazu dokera (gdzie istnieją codzienne kompilacje i tagi = daty są w YYYYMMDDformacie), jest następujące:

# 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

Istnieje wróbel plugin docker-remove-dangling-images, którego można użyć do czyszczenia zatrzymanych pojemników i nieużywanych (zwisających) obrazów:

$ sparrow plg run docker-remove-dangling-images

Działa zarówno w systemie Linux, jak i Windows.

Najpierw biegnij, docker imagesaby zobaczyć listę obrazów i skopiuj IMAGE HASH ID do schowka.

Biegać docker rmi -f <Image>

Pamiętaj, że opcja -fwymusza usunięcie.