Docker-Image mit abhängigen untergeordneten Bildern kann nicht gelöscht werden

ich versuche

docker rmi c565603bc87f

Error:

Fehlerantwort vom Dämon: Konflikt: c565603bc87f kann nicht gelöscht werden (kann nicht erzwungen werden) - Bild hat abhängige untergeordnete Bilder

Daher kann ich das Bild auch mit dem Flag -f nicht löschen. Wie lösche ich dann das Bild und alle seine Kinder?

Linux- und Docker-Version:

uname -a Linux goracio-pc 4.4.0-24-generic # 43-Ubuntu SMP Mi 8. Juni 19:27:37 UTC 2016 x86_64 x86_64 x86_64 GNU / Linux

Docker-Version Client: Version: 1.11.2 API-Version: 1.23 Go-Version: go1.5.4 Git-Commit: b9f10c9 Erstellt: Mi Jun 1 22:00:43 2016 OS / Arch: linux / amd64

Server: Version: 1.11.2 API-Version: 1.23 Go-Version: go1.5.4 Git-Commit: b9f10c9 Erstellt: Mi Jun 1 22:00:43 2016 OS / Arch: linux / amd64

Sie sollten versuchen, unnötige Bilder zu entfernen, bevor Sie das Bild entfernen:

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

Führen Sie danach Folgendes aus:

docker rmi c565603bc87f

In einigen Fällen (wie in meinem Fall) versuchen Sie möglicherweise, ein Bild zu löschen, indem Sie die Bild-ID angeben, die mehrere Tags enthält , von denen Sie nicht wissen, dass sie existieren. Einige davon können von anderen Bildern verwendet werden. In diesem Fall möchten Sie das Bild möglicherweise nicht entfernen .

Wenn Sie einen Fall von redundanten Tags , wie hier beschrieben, statt docker rmi <image_id>Verwendung docker rmi <repo:tag>auf dem redundanten Tag , das Sie entfernen möchten.

Alle vorherigen Antworten sind korrekt, aber hier ist eine Lösung, bei der nur alle Ihre Bilder gewaltsam gelöscht werden ( verwenden Sie diesen Befehl auf eigenes Risiko, um alle Ihre Bilder zu löschen ).

docker rmi $(docker images -q) -f

Suchen Sie die Bild-ID und die übergeordnete ID für alle Bilder, die nach dem betreffenden Bild erstellt wurden, wie folgt:

docker inspect --format='{{.Id}} {{.Parent}}' $(docker images --filter since=<image_id> -q)

Dann rufen Sie den Befehl auf:

docker rmi {sub_image_id} 

"sub_image_id" ist die ID des abhängigen Bildes

Was für mich funktioniert hat, war die Verwendung der Kombination REPOSITORY: TAG anstelle der IMAGE ID.

Als ich versuchte, ein Docker-Image mit dem Befehl zu löschen, docker rmi <IMAGE ID>ohne dass diesem Image Container zugeordnet waren, hatte ich die folgende Meldung:

$ docker rmi 3f66bec2c6bf
Error response from daemon: conflict: unable to delete 3f66bec2c6bf (cannot be forced) - image has dependent child images

Ich konnte mit Erfolg löschen, wenn ich den Befehl verwendete docker rmi RPOSITORY:TAG

$ docker rmi ubuntu:18.04v1
Untagged: ubuntu:18.04v1

DIESER BEFEHL ENTFERNT ALLE BILDER (MIT VORSICHT VERWENDEN)

Haben Sie versucht, --force zu verwenden?

sudo docker rmi $(sudo docker images -aq) --force

Dieser obige Code läuft wie ein Zauber, selbst wenn ich das gleiche Problem hatte

Die Antwort hier ist, alle Nachkommen zu finden, die hier eine Antwort haben:

Docker Wie kann ich die Liste der abhängigen untergeordneten Bilder erhalten?

Verwenden Sie dies dann, um die untergeordneten Bilder der Reihe nach zu entfernen.

Hier ist ein Skript zum Entfernen eines Bildes und aller davon abhängigen Bilder.

#!/bin/bash

if [[ $# -lt 1 ]]; then
    echo must supply image to remove;
    exit 1;
fi;

get_image_children ()
{
    ret=()
    for i in $(docker image ls -a --no-trunc -q); do
        #>&2 echo processing image "$i";
        #>&2 echo parent is $(docker image inspect --format '{{.Parent}}' "$i")
        if [[ "$(docker image inspect --format '{{.Parent}}' "$i")" == "$1" ]]; then
            ret+=("$i");
        fi;
    done;
    echo "${ret[@]}";
}

realid=$(docker image inspect --format '{{.Id}}' "$1")
if [[ -z "$realid" ]]; then
    echo "$1 is not a valid image.";
    exit 2;
fi;
images_to_remove=("$realid");
images_to_process=("$realid");
while [[ "${#images_to_process[@]}" -gt 0 ]]; do
    children_to_process=();
    for i in "${!images_to_process[@]}"; do
        children=$(get_image_children "${images_to_process[$i]}");
        if [[ ! -z "$children" ]]; then
            # allow word splitting on the children.
            children_to_process+=($children);
        fi;
    done;
    if [[ "${#children_to_process[@]}" -gt 0 ]]; then
        images_to_process=("${children_to_process[@]}");
        images_to_remove+=("${children_to_process[@]}");
    else
        #no images have any children. We're done creating the graph.
        break;
    fi;
done;
echo images_to_remove = "$(printf %s\n "${images_to_remove[@]}")";
indices=(${!images_to_remove[@]});
for ((i="${#indices[@]}" - 1; i >= 0; --i)) ; do
    image_to_remove="${images_to_remove[indices[i]]}"
    if [[ "${image_to_remove:0:7}" == "sha256:" ]]; then
        image_to_remove="${image_to_remove:7}";
    fi
    echo removing image "$image_to_remove";
    docker rmi "$image_to_remove";
done

# docker rm $(docker ps -aq)

Verwenden Sie danach den Befehl, wie von Nguyen vorgeschlagen.

Aufbauend auf Simon Brady Brute - Force - Methode hier , wenn Sie Sie diese Shell - Funktion verwenden können , nicht eine Tonne Bilder haben:

recursive_remove_image() {
  for image in $(docker images --quiet --filter "since=${1}")
  do
    if [ $(docker history --quiet ${image} | grep ${1}) ]
    then
      recursive_remove_image "${image}"
    fi
  done
  echo "Removing: ${1}"
  docker rmi -f ${1}
}

und nenne es dann mit recursive_remove_image <image-id>.

docker rmi <rep:tag>

Ex:

REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
python              3.6            60f85556d5d2        4 days ago          174MB

Docker RMI Python: 3.6

Wenn ich ein nicht verwendetes Bild mit Namen "<none>"im Docker entfernen möchte, habe ich das Problem. unable to delete a354bbc7c9b7 (cannot be forced) - image has dependent child imagesSo lösen Sie dieses Problem:

sudo docker ps -a

CONTAINER ID        IMAGE                       COMMAND                  CREATED             STATUS                         PORTS                                              NAMES
01ee1276bbe0        lizard:1                    "/bin/sh -c 'java ..."   About an hour ago   Exited (1) About an hour ago                                                      objective_lewin
49d73d8fb023        javaapp:latest              "/usr/bin/java -ja..."   19 hours ago        Up 19 hours                    0.0.0.0:8091->8091/tcp                             pedantic_bell
405fd452c788        javaapp:latest              "/usr/bin/java -ja..."   19 hours ago        Created                                                                           infallible_varahamihira
532257a8b705        javaapp:latest              "/usr/bin/java -ja..."   19 hours ago        Created                                                                           demo-default
9807158b3fd5        javaapp:latest              "/usr/bin/java -ja..."   19 hours ago        Created                                                                           xenodochial_kilby
474930241afa        jenkins                     "/bin/tini -- /usr..."   13 days ago         Up 4 days                      0.0.0.0:8080->8080/tcp, 0.0.0.0:50000->50000/tcp   myjenkins
563d8c34682f        mysql/mysql-server:latest   "/entrypoint.sh my..."   3 weeks ago         Up 4 days (healthy)            0.0.0.0:3306->3306/tcp, 33060/tcp                  mymysql
b4ca73d45d20        phpmyadmin/phpmyadmin       "/run.sh phpmyadmin"     4 weeks ago         Exited (0) 3 weeks ago                                                            phpmyadmin

Sie können sehen, dass ich mehrere Bilder mit dem Namen JavaApp habe: neuesten und anderen Containernamen. Also habe ich alle Container von "javaapp: latest" Container getötet und entfernt mit:

sudo docker stop "containerName"

sudo docker rm "ContainrName"

Dann

sudo docker rmi -f "imageId"

So kann ich alle Bilder mit Namen entfernen "<none>"

Viel Glück

Ich habe auch dieses Problem, ich konnte das Problem mit den folgenden Befehlen beheben. Dies kann daran liegen, dass der Container des Bildes ausgeführt wird oder beendet wird. Bevor Sie das Bild entfernen, müssen Sie den Container entfernen

Docker ps -a -f status = beendet: Dieser Befehl zeigt alle verlassenen Container an. Kopieren Sie dann die Container-ID und führen Sie die folgenden Befehle aus, um den Container zu entfernen

docker rm #containerId: Dieser Befehl Container entfernen Dies kann ein Problem sein, das erwähnt, dass "Bild abhängige untergeordnete Bilder hat"

Versuchen Sie dann, das Bild mit dem folgenden Befehl zu entfernen

Docker rmi #ImageId

Ich hatte dieses Problem und keine der kurzen Antworten hier funktionierte, selbst auf der von @tudor oben erwähnten Seite. Ich dachte, ich würde hier erzählen, wie ich die Bilder losgeworden bin. Ich kam auf die Idee, dass abhängige Bilder> = die Größe des übergeordneten Bildes haben müssen, was hilft, es zu identifizieren, damit wir es entfernen können.

Ich habe die Bilder in der Reihenfolge ihrer Größe aufgelistet, um festzustellen, ob ich Korrelationen feststellen konnte:

docker images --format '{{.Size}}\t{{.Repository}}\t{{.Tag}}\t{{.ID}}' | sort -h -r | column -t

Verwenden Sie dazu eine spezielle Formatierung vom Docker, um zuerst die Bildgrößenspalte zu positionieren, und führen Sie dann eine für Menschen lesbare Sortierung in umgekehrter Reihenfolge aus. Dann stelle ich die einfach zu lesenden Spalten wieder her.

Dann schaute ich mir die <none>Container an und passte den ersten in der Liste mit einer ähnlichen Größe an. Ich habe ein einfaches docker rmi <image:tag>Bild erstellt und alle <none>Kinderbilder waren damit verbunden.

Das Problembild mit allen Kinderbildern war eigentlich das verdammte myrepo/getstarted-lab Bild, das ich verwendet habe, als ich anfing, mit Docker zu spielen. Das lag daran, dass ich aus dem ersten Testbild, mit dem die Kette erstellt wurde, ein neues Bild erstellt hatte.

Hoffentlich hilft das irgendwann jemand anderem.

Angenommen, wir haben eine Docker-Datei

FROM ubuntu:trusty
CMD ping localhost

Wir bauen daraus ein Bild ohne TAG oder Benennung

docker build .

Jetzt haben wir einen Erfolgsbericht "Erfolgreich erstellt 57ca5ce94d04" Wenn wir die Docker-Bilder sehen

REPOSITORY          TAG                 IMAGE ID            CREATED             SIZE
<none>              <none>              57ca5ce94d04        18 seconds ago      188MB
ubuntu              trusty              8789038981bc        11 days ago         188MB

Wir müssen zuerst die entfernen docker rmi 57ca5ce94d04

gefolgt von

docker rmi 8789038981bc

Dadurch wird das Bild entfernt!

Eine erzwungene Entfernung aller, wie von jemandem vorgeschlagen

docker rmi $(docker images -q) -f

Erweitern Sie die Antwort von @Nguyen - diese Funktion kann zu Ihrem .bashrcusw. hinzugefügt und dann über die Befehlszeile aufgerufen werden, um image has dependent child imagesFehler zu beseitigen ...

Sie können die Funktion als Sie selbst ausführen. Wenn a docker psfehlschlägt, wird der dockerBefehl mit ausgeführt sudound Sie werden zur Eingabe Ihres Kennworts aufgefordert.

Hat NICHT löschen Bilder für alle laufenden Container!

docker_rmi_dependants ()                                                                                                                                                         
{ 
  DOCKER=docker
  [ docker ps >/dev/null 2>&1 ] || DOCKER="sudo docker"

  echo "Docker: ${DOCKER}"

  for n in $(${DOCKER} images | awk '$2 == "<none>" {print $3}');
  do  
    echo "ImageID: $n";
    ${DOCKER} inspect --format='{{.Id}} {{.Parent}}' $(${DOCKER} images --filter since=$n -q);
  done;

  ${DOCKER} rmi $(${DOCKER} images | awk '$2 == "<none>" {print $3}')
}

Ich habe das auch in meiner .bashrcAkte ...

docker_rm_dangling ()  
{ 
  DOCKER=docker
  [ docker ps >/dev/null 2>&1 ] || DOCKER="sudo docker"

  echo "Docker: ${DOCKER}"

  ${DOCKER} images -f dangling=true 2>&1 > /dev/null && YES=$?;                                                                                                                  
  if [ $YES -eq 1 ]; then
    read -t 30 -p "Press ENTER to remove, or CTRL-C to quit.";
    ${DOCKER} rmi $(${DOCKER} images -f dangling=true -q);
  else
    echo "Nothing to do... all groovy!";
  fi  
}

Arbeitet mit:

$ docker --version 
Docker version 17.05.0-ce, build 89658be

Löschen einer Bildliste erzwingen (z. B. Version 10 ausschließen)

Docker-Bilder | grep version | grep -v version10> images.txt && für img in $ (awk -F "" '{print $ 3}' /root/images.txt); docker rmi -f $ img; getan

Sie können dies einfach tun:

➜ ~ sudo Docker rmi 4ed13257bb55 -f Deleted: sha256: 4ed13257bb5512b975b316ef482592482ca54018a7728ea1fc387e873a68c358 Deleted: sha256: 4a478ca02e8d2336595dcbed9c4ce034cd15f01229733e7d93a83fbb3a9026d3 Deleted: sha256: 96df41d1ce6065cf75d05873fb1f9ea9fed0ca86addcfcec7722200ed3484c69 Deleted: sha256: d95efe864c7096c38757b80fddad12819fffd68ac3cc73333ebffaa42385fded

Bildebene: Repositorys werden häufig als Bilder oder Containerbilder bezeichnet, bestehen jedoch aus einer oder mehreren Ebenen. Bildebenen in einem Repository sind in einer Eltern-Kind-Beziehung miteinander verbunden. Jede Bildebene repräsentiert Änderungen zwischen sich und der übergeordneten Ebene.

Das Docker-Gebäudemuster verwendet die Vererbung . Dies bedeutet, dass die Version ivon der Version abhängt i-1. Wir müssen also die Version löschen, um die Version löschen i+1zu können i. Dies ist eine einfache Abhängigkeit.

Wenn Sie alle Bilder außer dem letzten (das aktuellste) und dem ersten (Basis) löschen möchten, können Sie das letzte (das aktuellste) mit dem folgenden docker saveBefehl exportieren .

docker save -o <output_file> <your_image-id> | gzip <output_file>.tgz

Löschen Sie dann jetzt alle Bilder mit der unten angegebenen Bild-ID .

docker rm -f <image-id i> | docker rm -f <image i-1> | docker rm -f <image-id i-2> ... <docker rm -f <image-id i-k> # where i-k = 1

Laden Sie nun Ihr gespeichertes TGZ-Bild wie folgt.

gzip -c <output_file.tgz> | docker load

Zeigen Sie die Image-ID Ihres geladenen Images mit Docker ps -q an. Es hat kein Tag und keinen Namen. Sie können Tag und Name einfach wie unten beschrieben aktualisieren.

docker tag <image_id> group_name/name:tag