Wenn Docker längere Zeit ausgeführt wird, befinden sich viele Images im System. Wie kann ich alle nicht verwendeten Docker-Images auf einmal entfernen, um den Speicherplatz freizugeben?

Außerdem möchte ich vor Monaten gezogene Bilder entfernen, die die richtigen haben TAG.

Ich möchte also nicht nur Bilder ohne Tags entfernen. Ich suche nach einer Möglichkeit, allgemeine nicht verwendete Bilder zu entfernen, die sowohl nicht getaggte als auch andere Bilder, wie sie vor Monaten gezogen wurden, korrekt enthalten TAG.

Update Sept. 2016: Docker 1.13: PR 26108 und Commit 86de7c0 führen einige neue Befehle ein, um die Visualisierung des Speicherplatzes der Docker-Daemon-Daten auf der Festplatte zu vereinfachen und das "Bereinigen" nicht benötigter "Überschüsse zu vereinfachen.

docker system prunelöscht ALLE baumelnden Daten (dh In der Reihenfolge: Container gestoppt, Volumes ohne Container und Bilder ohne Container). Auch unbenutzte Daten mit -aOption.

Sie haben auch:

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

Für nicht verwendete Bilder, Verwendung docker image prune -a(für baumelnden Entfernen und ununsed Bilder).
Warnung: " nicht verwendet " bedeutet "Bilder, auf die von keinem Container verwiesen wird": Seien Sie vorsichtig, bevor Sie sie verwenden -a.

Wie in der Antwort von AL dargestellt , werden alle nicht verwendeten Bilder entfernt, nicht nur baumelnde ... was etwas zu viel sein kann.docker system prune --all

Die Kombination docker xxx prunemit der --filterOption kann eine gute Möglichkeit sein, das Bereinigen einzuschränken ( Docker SDK API 1.28 Minimum, also Docker 17.04+ ).

Die derzeit unterstützten Filter sind:

• until (<timestamp>) - Entfernen Sie nur Container, Bilder und Netzwerke, die vor dem angegebenen Zeitstempel erstellt wurden
• label( label=<key>, label=<key>=<value>, label!=<key>, Oder label!=<key>=<value>) - nur entfernen , Container, Bilder, Netzwerke und Volumen mit (oder ohne , falls label!=...verwendet) die angegebenen Etiketten.

Ein Beispiel finden Sie unter " Bilder beschneiden ".

Ursprüngliche Antwort (Sep. 2016)

Normalerweise mache ich:

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

Ich habe einen Alias ​​zum Entfernen dieser [baumelnden Bilder] 13 :drmi

Der dangling=trueFilter findet nicht verwendete Bilder

Auf diese Weise wird jedes Zwischenbild entfernt, auf das nicht mehr durch ein beschriftetes Bild verwiesen wird.

Ich mache das gleiche zuerst für verlassene Prozesse (Container)

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

Wie haridsv weist darauf hin , in den Kommentaren :

Technisch gesehen sollten Sie zuerst Container bereinigen, bevor Sie Bilder bereinigen, da dadurch mehr baumelnde Bilder und weniger Fehler erfasst werden .

Jess Frazelle (jfrazelle) hat die bashrc-Funktion :

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
}

Um alte Bilder und nicht nur "nicht referenzierte" baumelnde Bilder zu entfernen, können Sie Folgendes berücksichtigen docker-gc:

Ein einfaches Docker-Container- und Image-Garbage-Collection-Skript.

• Container, die vor mehr als einer Stunde beendet wurden, werden entfernt.
• Bilder, die danach nicht mehr zu einem verbleibenden Container gehören, werden entfernt.

Aktualisieren Sie die zweite (2017-07-08):

Beziehen Sie sich (erneut) auf VonC, indem Sie das noch neuere verwenden system prune. Der Ungeduldige kann die Eingabeaufforderung mit der folgenden -f, --forceOption überspringen :

docker system prune -f

Der Ungeduldige und Rücksichtslose kann zusätzlich "unbenutzte Bilder nicht nur die baumelnden" mit der -a, --allOption entfernen :

docker system prune -af

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

Aktualisieren:

Lesen Sie die Antwort von VonC, in der die kürzlich hinzugefügten pruneBefehle verwendet werden. Hier ist der entsprechende Shell-Alias:

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

Alte Antwort:

Gestoppte (verlassene) Container löschen:

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

Nicht verwendete (baumelnde) Bilder löschen:

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

Wenn Sie in Bezug auf unwiderruflichen Datenverlust äußerste Vorsicht walten lassen, können Sie nicht verwendete (baumelnde) Volumes (Version 1.1 und höher) löschen:

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

Hier befinden sie sich in einem praktischen Shell-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'

Verweise:

• docker ps -f
• docker rm
• docker images -f
• docker rmi
• Versionshinweise zu Docker v1.9.0
• docker volume ls
• docker volume rm

So entfernen Sie alte Bilder mit Tags , die älter als ein Monat sind:

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

Beachten Sie, dass es wird scheitern Bilder zu entfernen , die von einem Behälter verwendet werden, in einem Repository referenziert, hat unterhaltsberechtigte Kind Bilder ... was wahrscheinlich ist , was Sie wollen. Andernfalls fügen Sie einfach die -fFlagge hinzu.

Beispiel eines /etc/cron.daily/docker-gcSkripts:

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

Die anderen Antworten sind großartig, insbesondere:

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

Aber ich brauchte etwas in der Mitte der beiden Befehle, also war die filterOption genau das, was ich brauchte:

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

Ich hoffe, das hilft :)

Als Referenz: https://docs.docker.com/config/pruning/#prune-images

Angenommen, Sie haben Docker 1.13 oder höher, können Sie einfach die Bereinigungsbefehle verwenden. Für Ihre Frage speziell zum Entfernen alter Bilder möchten Sie das erste.

# 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

Ich würde empfehlen, sich nicht an den docker system pruneBefehl zu gewöhnen . Ich gehe davon aus, dass Benutzer versehentlich Dinge entfernen, die sie nicht wollen. Persönlich werde ich hauptsächlich die Befehle docker image pruneund verwenden docker container prune.

Bis jetzt (Docker Version 1.12) verwenden wir den folgenden Befehl, um alle laufenden Container zu löschen. Wenn wir die Volumes löschen möchten, können wir dies auch manuell mit dem entsprechenden Tag -v im folgenden Befehl tun.

Löschen Sie alle verlassenen Container

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

Löschen Sie alle gestoppten Container

docker rm $(docker ps -a -q)

Löschen Sie alle laufenden und gestoppten Container

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

Entfernen Sie alle Behälter ohne Kriterien

docker container rm $(docker container ps -aq)

In Version 1.13 und höher können wir jedoch für eine vollständige System- und Bereinigung den folgenden Befehl direkt verwenden:

docker system prune

Alle nicht verwendeten Container, Bilder, Netzwerke und Volumes werden gelöscht. Wir können dies auch mit den folgenden Befehlen tun, die die einzelnen Komponenten bereinigen:

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

Das hat bei mir funktioniert:

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

Mit dem folgenden Befehl werden Bilder gelöscht, die älter als 48 Stunden sind.

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

Ich habe kürzlich ein Skript geschrieben, um dies auf einem meiner Server zu lösen:

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

Hier ist ein Skript zum Bereinigen von Docker-Images und zum Wiederherstellen des Speicherplatzes.

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

Originalschrift

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

Normalerweise speichert Docker alle temporären Dateien, die sich auf das Erstellen von Bildern und Ebenen beziehen, unter

/ var / lib / docker

Dieser Pfad ist lokal für das System, normalerweise auf der Root-Partition "/" .

Sie können einen größeren Speicherplatz bereitstellen und den Inhalt /var/lib/dockeran den neuen Speicherort verschieben und einen symbolischen Link erstellen.

Selbst wenn Docker-Images Speicherplatz belegen, hat dies keine Auswirkungen auf Ihr System, da es einen anderen Mount-Speicherort verwendet.

Ursprünglicher Beitrag: Verwalten von Docker-Images auf der lokalen Festplatte

Ich benutze diesen Befehl:

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

Dadurch werden alle Bilder entfernt, deren Erstellungszeit länger als 10 Wochen ist.

Wenn Sie Bilder entfernen möchten, die vor X Monaten gezogen wurden, können Sie das folgende Beispiel ausprobieren, in dem vor drei Monaten erstellte Bilder entfernt werden:

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

Zum Beschneiden aller Bilder und Volumes
docker system prune -af --volumes

docker system prune -a

(Sie werden aufgefordert, den Befehl zu bestätigen. Verwenden Sie diese Option, um die -fAusführung zu erzwingen, wenn Sie wissen, was Sie tun.)

@VonC hat bereits eine sehr nette Antwort gegeben, aber der Vollständigkeit halber hier ein kleines Skript, das ich verwendet habe --- und das auch alle Docker-Prozesse erledigt, falls Sie welche haben:

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

Um markierte Bilder zu entfernen, auf denen kein Container ausgeführt wird, müssen Sie ein kleines Skript verwenden:

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

Alte Behälter vor Wochen entfernen.

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

Alte Bilder vor Wochen entfernen. Achtung. Dadurch werden Basisbilder entfernt, die vor Wochen erstellt wurden, aber möglicherweise von Ihren neuen Bildern verwendet werden.

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

So entfernen Sie ein getaggtes Bild

1. Docker rmi das Tag zuerst

2. Docker rmi das Bild.

   # Dies kann in einem Docker-Rmi-Aufruf erfolgen, z. B.: # Docker-Rmi <Repo: Tag> <Bild-ID>

(Dies funktioniert im November 2016, Docker Version 1.12.2)

z.B

$ 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

zB Skript entfernt alles, was älter als 2 Wochen ist.

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 Kraft

-a alle

-q im Modus

docker rm `docker ps -aq`

oder

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

Gelegentlich sind Probleme aufgetreten, bei denen Docker Speicherplatz zuweist und weiterhin verwendet, auch wenn der Speicherplatz keinem bestimmten Image oder vorhandenen Container zugewiesen ist. Die letzte Art, wie ich dieses Problem versehentlich generiert habe, war die Verwendung von "Docker-Engine" -Centos anstelle von "Docker" in RHEL 7.1. Was zu passieren scheint, ist manchmal, dass die Containerbereinigungen nicht erfolgreich abgeschlossen werden und der Speicherplatz dann nie wieder verwendet wird. Als das 80-GB-Laufwerk, das ich als / zugewiesen hatte, mit / var / lib / docker-Dateien gefüllt war, musste ich einen kreativen Weg finden, um das Problem zu beheben.

Folgendes habe ich mir ausgedacht. Beheben Sie zuerst den Fehler "Festplatte voll":

1. Docker stoppen: systemctl Docker stoppen
2. Zuweisung eines neuen Laufwerks, das als say / mnt / docker bereitgestellt wurde.
3. Verschieben Sie alle Dateien in / var / lib / docker nach / mnt / docker. Ich habe den Befehl verwendet: rsync -aPHSx - Quelldateien entfernen / var / lib / docker / / mnt / docker /
4. Hängen Sie das neue Laufwerk in / var / lib / docker ein.

Zu diesem Zeitpunkt hatte ich keinen Fehler mehr auf der Festplatte, aber ich verschwendete immer noch viel Speicherplatz. Die nächsten Schritte sind, sich darum zu kümmern.

1. Docker starten: systemctl start docker

2. Speichern Sie alle Bilder: Docker speichern $ (Docker-Bilder | sed -e '/ ^ / d' -e '/ ^ REPOSITORY / d' -e 's, [] [] ,:,' -e 's, [ ]. ,, ')> /root/docker.img

3. Docker deinstallieren.

4. Löschen Sie alles in / var / lib / docker: rm -rf / var / lib / docker / [cdintv] *

5. Installieren Sie den Docker neu

6. Docker aktivieren: systemctl Docker aktivieren

7. Docker starten: systemctl Docker starten

8. Bilder wiederherstellen: Docker laden </root/docker.img

9. Starten Sie alle persistenten Container, die Sie ausführen müssen.

Dadurch wurde meine Festplattennutzung von 67 GB für Docker auf 6 GB für Docker gesenkt.

Ich empfehle dies nicht für den täglichen Gebrauch. Es ist jedoch nützlich, es auszuführen, wenn Docker aufgrund von Softwarefehlern oder unerwarteten Neustarts den Überblick über den verwendeten Speicherplatz verloren hat.

Wenn Sie verlassene Container automatisch / regelmäßig bereinigen und Images und Volumes entfernen möchten, die nicht von einem laufenden Container verwendet werden, können Sie das Image herunterladen meltwater/docker-cleanup.

Renn einfach:

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

Es wird standardmäßig alle 30 Minuten ausgeführt. Sie können die Verzögerungszeit jedoch mithilfe dieses Flags in Sekunden einstellen (Option DELAY_TIME = 1800).

Weitere Details: https://github.com/meltwater/docker-cleanup/blob/master/README.md

Wenn Sie diese beschnittenen Bilder selbst erstellen (von einigen anderen, älteren Basisbildern), gehen Sie bitte vorsichtig mit den oben akzeptierten Lösungen um docker image prune, da der Befehl stumpf ist und versucht, auch alle Abhängigkeiten zu entfernen, die für Ihre neuesten Bilder erforderlich sind (der Befehl sollte es sein) wahrscheinlich umbenannt in docker image*s* prune).

Die Lösung, die ich für meine Docker-Image-Build-Pipelines gefunden habe (wo es tägliche Builds gibt und Tags = Datumsangaben im YYYYMMDDFormat vorliegen), lautet wie folgt:

# 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

Es gibt Sparrow Plugin Docker-Remove-Dangling-Bilder, mit denen Sie gestoppte Container und nicht verwendete (baumelnde) Bilder bereinigen können:

$ sparrow plg run docker-remove-dangling-images

Es funktioniert sowohl für Linux als auch für Windows.

Führen Sie docker imageszunächst eine Liste der Bilder aus und kopieren Sie die IMAGE HASH ID in die Zwischenablage.

Lauf docker rmi -f <Image>

Denken Sie daran, dass die Option -fdas Löschen erzwingen ist.