Nie można usunąć obrazu Dockera z zależnymi obrazami podrzędnymi

próbuję

docker rmi c565603bc87f

Błąd:

Odpowiedź na błąd od demona: konflikt: nie można usunąć c565603bc87f (nie można wymusić) - obraz ma zależne obrazy podrzędne

Więc nie mogę usunąć obrazu nawet z flagą -f. Jak wtedy usunąć obraz i wszystkie jego dzieci?

Wersja Linux i Docker:

uname -a Linux goracio-pc 4.4.0-24-generic # 43-Ubuntu SMP środa 8 czerwca 19:27:37 UTC 2016 x86_64 x86_64 x86_64 GNU / Linux

wersja docker Klient: Wersja: 1.11.2 Wersja API: 1.23 Go Wersja: go1.5.4 Git zatwierdzenie: b9f10c9 Utworzono: środa 1 czerwca 22:00:43 2016 System operacyjny / Arch: linux / amd64

Serwer: Wersja: 1.11.2 Wersja API: 1.23 Go Wersja: go1.5.4 Git Commit: b9f10c9 Rok budowy: środa 1 czerwca 22:00:43 2016 System operacyjny / Arch: linux / amd64

Przed usunięciem obrazu należy spróbować usunąć niepotrzebne obrazy:

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

Następnie uruchom:

docker rmi c565603bc87f

W niektórych przypadkach (jak w moim przypadku) możesz próbować usunąć obraz , określając identyfikator obrazu, który ma wiele tagów , o których istnieniu nie zdajesz sobie sprawy, a niektóre z nich mogą być używane przez inne obrazy. W takim przypadku możesz nie chcieć usuwać obrazu .

Jeśli masz przypadek nadmiarowych tagów, jak opisano tutaj, zamiast docker rmi <image_id>używać docker rmi <repo:tag>na zbędnym tagu, który chcesz usunąć.

wszystkie poprzednie odpowiedzi są poprawne, ale oto jedno rozwiązanie, które po prostu wymusza usunięcie wszystkich twoich obrazów ( użyj tego polecenia na własne ryzyko, spowoduje to usunięcie wszystkich twoich obrazów )

docker rmi $(docker images -q) -f

znajdź identyfikator obrazu i identyfikator nadrzędny dla wszystkich obrazów utworzonych po obrazie, o którym mowa, za pomocą następujących elementów:

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

Następnie wywołujesz polecenie:

docker rmi {sub_image_id} 

„sub_image_id” to identyfikator zależnego obrazu

Pomogło mi użycie kombinacji REPOSITORY: TAG zamiast IMAGE ID.

Kiedy próbowałem usunąć obraz dockera za pomocą polecenia docker rmi <IMAGE ID>bez kontenerów skojarzonych z tym obrazem, otrzymałem komunikat:

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

Mogłem usunąć z powodzeniem, gdy użyłem polecenia docker rmi RPOSITORY:TAG

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

TO POLECENIE USUWA WSZYSTKIE OBRAZY (UŻYWAJ OSTRZEŻENIE)

Czy próbowałeś użyć --force

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

Powyższy kod działa jak urok, nawet ja miałem ten sam problem

Tutaj odpowiedzią jest znalezienie wszystkich potomków, na co odpowiedź ma tutaj:

docker jak mogę uzyskać listę zależnych obrazów podrzędnych?

Następnie użyj tego, aby usunąć kolejno obrazy podrzędne.

Oto skrypt służący do usuwania obrazu i wszystkich obrazów, które od niego zależą.

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

Następnie użyj polecenia zgodnie z sugestią Nguyena.

Opierając się na metodzie brute force Simon Brady tutaj , jeśli nie mają mnóstwo zdjęć, które można używać tej funkcji powłoki:

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}
}

a następnie nazwij to używając recursive_remove_image <image-id>.

docker rmi <rep:tag>

Dawny:

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

docker rmi python: 3.6.0

Kiedy chcę usunąć nieużywany obraz z nazwą "<none>"w dockerze, napotykam problem unable to delete a354bbc7c9b7 (cannot be forced) - image has dependent child images. Aby rozwiązać ten 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

widać, że mam kilka obrazów o nazwie javaapp: najnowsza i inna nazwa kontenera. Dlatego zabiłem i usunąłem cały kontener „javaapp: latest” z:

sudo docker stop „containerName”

sudo docker rm "ContainrName"

Następnie

sudo docker rmi -f "imageId"

Więc mogę usunąć wszystkie obrazy z nazwą "<none>"

powodzenia

Mam również ten problem, mogłem rozwiązać problem za pomocą poniższych poleceń. może to być przyczyną, że kontener obrazu działa lub kończy pracę, więc przed usunięciem obrazu należy usunąć kontener

docker ps -a -f status = exited: to polecenie pokazuje wszystkie opuszczone kontenery, więc skopiuj identyfikator kontenera, a następnie uruchom poniższe polecenia, aby usunąć kontener

docker rm #containerId: to polecenie usuwa kontener, może to być problem ze wzmianką o „obrazie ma zależne obrazy podrzędne”

Następnie spróbuj usunąć obraz za pomocą poniższego polecenia

docker rmi #ImageId

Miałem ten problem i żadna z krótkich odpowiedzi nie zadziałała, nawet na stronie wspomnianej powyżej przez @tudor. Pomyślałem, że podzielę się tutaj, jak pozbyłem się obrazów. Wpadłem na pomysł, że obrazy zależne muszą mieć> = rozmiar obrazu nadrzędnego, co pomaga go zidentyfikować, abyśmy mogli go usunąć.

Podałem obrazy według rozmiaru, aby zobaczyć, czy mogę dostrzec jakieś korelacje:

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

Oznacza to użycie specjalnego formatowania z okna dokowanego, aby najpierw ustawić kolumnę rozmiaru obrazu, a następnie przeprowadzić sortowanie czytelne dla człowieka w odwrotnej kolejności. Następnie przywracam łatwe do odczytania kolumny.

Następnie spojrzałem na <none>pojemniki i dopasowałem pierwszy na liście o podobnym rozmiarze. Wykonałem prostą operację docker rmi <image:tag>na tym obrazie i wszystkich<none> obrazy dzieci poszły z nim.

Problem ze wszystkimi obrazami podrzędnymi był w rzeczywistości tym cholernym myrepo/getstarted-lab obrazem, którego użyłem gdy po raz pierwszy zacząłem bawić się dockerem. To dlatego, że stworzyłem nowy obraz z pierwszego obrazu testowego, który utworzył łańcuch.

Mam nadzieję, że w pewnym momencie pomoże to komuś innemu.

Załóżmy, że mamy plik Dockerfile

FROM ubuntu:trusty
CMD ping localhost

Z tego budujemy obraz bez TAG-a czy nazewnictwa

docker build .

Teraz mamy raport o sukcesie „Zbudowano pomyślnie 57ca5ce94d04” Jeśli widzimy obrazy dockera

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

Musimy najpierw usunąć docker rmi 57ca5ce94d04

Śledzony przez

docker rmi 8789038981bc

Ten obraz zostanie usunięty!

Wymuszone usunięcie wszystkiego, zgodnie z sugestią kogoś

docker rmi $(docker images -q) -f

Rozszerzanie odpowiedzi udzielonej przez @Nguyen - tę funkcję można dodać do swojego .bashrcitp., A następnie wywołać z wiersza poleceń, aby pomóc wyczyścićimage has dependent child images błędy ...

Możesz uruchomić tę funkcję samodzielnie, a jeśli się docker psnie powiedzie, uruchomi dockerpolecenie sudoi poprosi o podanie hasła.

Czy nie kasować obrazy za systemem pojemników!

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}')
}

Mam to też w swoich .bashrcaktach ...

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  
}

Pracuje z:

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

Wymuś usunięcie listy obrazów (na przykład wyklucz wersję 10)

obrazy docker | wersja grep | grep -v wersja10> images.txt && dla img w $ (awk -F "" '{print $ 3}' /root/images.txt); zrobić docker rmi -f $ img; Gotowe

możesz po prostu to zrobić:

➜ ~ sudo doker RMI 4ed13257bb55 -f Deleted: sha256: 4ed13257bb5512b975b316ef482592482ca54018a7728ea1fc387e873a68c358 Deleted: sha256: 4a478ca02e8d2336595dcbed9c4ce034cd15f01229733e7d93a83fbb3a9026d3 Deleted: sha256: 96df41d1ce6065cf75d05873fb1f9ea9fed0ca86addcfcec7722200ed3484c69 Deleted: sha256: d95efe864c7096c38757b80fddad12819fffd68ac3cc73333ebffaa42385fded

Warstwa obrazu: repozytoria są często nazywane obrazami lub obrazami kontenerów, ale w rzeczywistości składają się z jednej lub więcej warstw. Warstwy obrazów w repozytorium są połączone ze sobą w relacji rodzic-dziecko. Każda warstwa obrazu reprezentuje zmiany między nią a warstwą macierzystą.

Wzorzec budowania Dockera korzysta z dziedziczenia . Oznacza to, że wersja izależy od wersji i-1. Musimy więc usunąć wersję, i+1aby móc usunąć wersję i. To jest prosta zależność.

Jeśli chcesz usunąć wszystkie obrazy z wyjątkiem ostatniego (najbardziej zaktualizowanego) i pierwszego (podstawowego), możemy wyeksportować ostatni (najbardziej zaktualizowany) za pomocą docker savepolecenia jak poniżej.

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

Następnie usuń wszystkie obrazy, używając identyfikatora obrazu, jak poniżej.

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

Teraz załaduj zapisany obraz tgz, jak poniżej.

gzip -c <output_file.tgz> | docker load

zobacz identyfikator obrazu załadowanego obrazu za pomocą docker ps -q. Nie ma tagu ani nazwy. Możesz po prostu zaktualizować tag i nazwę, jak pokazano poniżej.

docker tag <image_id> group_name/name:tag