Zaktualizuj drugi (2017-07-08):

Odwołaj się (ponownie)do VonC, używając jeszcze nowszego system prune. Niecierpliwy może pominąć znak zachęty za pomocą opcji -f, --force:

docker system prune -f

Niecierpliwi i lekkomyślni mogą dodatkowo usunąć "nieużywane obrazy nie tylko zwisające" za pomocą opcji -a, --all:

docker system prune -af

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

Aktualizacja:

Zobacz odpowiedź VonC która wykorzystuje Ostatnio dodane polecenia prune. Oto odpowiedni 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 (zakończone) kontenery:

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

Usuń nieużywane (zwisające) zdjęcia:

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

Jeśli pacjent ekstremalna ostrożność w odniesieniu do nieodwołalna utrata danych, następnie możesz usunąć nieużywane (zwisające) woluminy (v1. 9 i nowsze):

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

Tutaj są w wygodnej skorupie alias:

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
• Docker v1.9.0 uwagi do wydania
• docker volume ls
• docker volume rm

Aby usunąć Stare otagowane obrazy, 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ż, żenie uda się usunąć obrazy, które są używane przez kontener, do którego odwołuje się repozytorium, z zależnymi obrazami potomnymi... pewnie tego chcesz. Else just add -f flag.

Przykład skryptu /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

Zakładając, że masz Docker 1.13 lub wyższy, możesz po prostu użyć poleceń prune. Na twoje pytanie dotyczące usuwania starych obrazów, chcesz 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

Zalecałbym , a nie przyzwyczajanie się do używania komendy docker system prune. Myślę, że użytkownicy przypadkowo usuną rzeczy, których nie chcą. Osobiście będę głównie używał komend docker image prune i docker container prune.

To mi pomogło:

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

Inne odpowiedzi są świetne, konkretnie:

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 komend, więc opcja filter Była tym, czego potrzebowałem:

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

Dla odniesienia: https://docs.docker.com/config/pruning/#prune-images

Ostatnio napisałem skrypt do rozwiązania tego 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

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

Usuń wszystkie zamknięte kontenery

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

Usuń wszystkie zatrzymane kontenery

docker rm $(docker ps -a -q)

Usuń wszystkie uruchomione i zatrzymane kontenery

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

Usunąć wszystkie pojemniki, bez żadnych kryteria

docker container rm $(docker container ps -aq)

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

docker system prune

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

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

Oto skrypt do czyszczenia obrazów dokerów i odzyskiwania 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 obrazów i warstw w

/var / lib / Docker

Ta ścieżka jest lokalna do systemu, zwykle na partycji głównej, "/".

Można zamontować większą przestrzeń dyskową i przenieść zawartość /var/lib/docker do nowego montowania lokalizacja i zrobić dowiązanie symboliczne.

W ten sposób, nawet jeśli obrazy dokera zajmują przestrzeń, nie wpłynie to na system, ponieważ będzie używał innej lokalizacji montowania.

Original post: zarządzanie obrazami Dokerów na dysku lokalnym

Jeśli chcesz usunąć obrazy wyciągnięte X miesiące 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

docker rm `docker ps -aq`

Lub

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

Aby usunąć oznaczone obrazy, które nie mają uruchomionego kontenera, musisz 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

Jak usunąć otagowany obraz

1. Docker RMI the tag first

2. Docker rmi obraz.

   # można to zrobić jednym wywołaniem docker rmi np.: # docker rmi

(działa w listopadzie 2016, Docker version 1.12.2)

Np.

$ 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. Scripted Usuń 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 system prune -a

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

@VonC już dał bardzo ładną odpowiedź, ale dla kompletności tutaj jest mały skrypt, którego używałem- - - i który również niszczy wszelkie procesy dokowania zleceń, 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

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 obrazów, których czas tworzenia jest większy niż 10 tygodni temu.

Usuń stare pojemniki kilka tygodni temu.

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

Usuń stare obrazy tygodnie temu. Bądź ostrożny. Spowoduje to usunięcie podstawowych obrazów, które zostały utworzone kilka tygodni temu, ale które mogą być używane przez nowe obrazy.

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

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

Just run:

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żna jednak ustawić czas opóźnienia, używając tego znacznika w sekundach(opcja DELAY_TIME=1800).

Więcej Szczegółów: https://github.com/meltwater/docker-cleanup/blob/master/README.md

Czasami napotykam problemy, w których Docker przydziela i nadal używa miejsca na dysku, nawet jeśli miejsce nie jest przydzielone do żadnego konkretnego obrazu lub istniejącego kontenera. Najnowszym sposobem, w jaki przypadkowo wygenerowałem ten problem, było użycie" Docker-engine "CentOS build zamiast "Docker" w RHEL 7.1. Wydaje się, że czasami oczyszczanie kontenerów nie jest zakończone pomyślnie, a następnie przestrzeń nigdy nie jest ponownie wykorzystywana. Gdy dysk 80GB przydzieliłem jako / był wypełniony pliki / var / lib / Docker musiałem wymyślić kreatywny sposób rozwiązania problemu.

Oto, co wymyśliłem. Pierwsze rozwiązanie błędu pełnego dysku:

1. Stop Docker: systemctl stop Docker
2. przydzielono nowy napęd 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 do /var / lib / docker.

At w tym punkcie nie miałem już błędu pełnego dysku, ale nadal marnowałem ogromną ilość miejsca. Kolejne kroki to zająć się tym.

1. Start Docker: systemctl start Docker

2. Zapisz wszystkie obrazy: docker save $(Docker images / sed-e '/^ / d ' - e '/ ^ repozytorium / d '- e ' s,[ ][ ],:,' -e ' s, [ ].,,') > /root/docker.img

3. Odinstaluj docker.

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

5. Reinstall Docker

6. Enable docker: systemctl enable Docker

7. Start docker: systemctl start Docker

8. Przywracanie obrazów: Docker load

9. Uruchom wszystkie trwałe kontenery, których potrzebujesz.

To zmniejszyło zużycie dysku z 67 GB dla Dockera do 6 GB dla Dockera.

Nie polecam tego do codziennego użytku. Ale jest to przydatne, aby uruchomić, gdy to wygląda na to, że docker stracił ślad zużytego miejsca na dysku do błędów oprogramowania lub nieoczekiwanych restartów.

Istnieje wtyczka sparrow docker-remove-dangling-images możesz użyć do czyszczenia zatrzymanych kontenerów i nieużywanych (zwisających) obrazów:

$ sparrow plg run docker-remove-dangling-images

Działa zarówno dla systemu operacyjnego Linux, jak i Windows.