Impossibile eliminare l'immagine docker con immagini figlio dipendenti

sto provando

docker rmi c565603bc87f

Errore:

Risposta di errore dal demone: conflitto: impossibile eliminare c565603bc87f (impossibile forzare) - l'immagine ha immagini secondarie dipendenti

Quindi non posso cancellare l'immagine anche con -f flag. Come eliminare l'immagine allora e tutti i suoi figli?

Versione Linux e docker:

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

versione docker Client: Versione: 1.11.2 Versione API: 1.23 Vai versione: go1.5.4 Git commit: b9f10c9 Costruito: mer 1 giu 22:00:43 2016 OS / Arch: linux / amd64

Server: Versione: 1.11.2 Versione API: 1.23 Vai versione: go1.5.4 Git commit: b9f10c9 Costruito: mer 1 giu 22:00:43 2016 OS / Arch: linux / amd64

Dovresti provare a rimuovere le immagini non necessarie prima di rimuovere l'immagine:

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

Successivamente, esegui:

docker rmi c565603bc87f

In alcuni casi (come nel mio caso) potresti provare a eliminare un'immagine specificando l'id dell'immagine che ha più tag che non ritieni esistano, alcuni dei quali potrebbero essere utilizzati da altre immagini. In tal caso, potresti non voler rimuovere l'immagine .

Se hai un caso di tag ridondanti come descritto qui, invece di docker rmi <image_id>utilizzare docker rmi <repo:tag>il tag ridondante che desideri rimuovere.

tutte le risposte precedenti sono corrette ma ecco una soluzione che sta eliminando tutte le tue immagini con forza ( usa questo comando a tuo rischio e pericolo eliminerà tutte le tue immagini )

docker rmi $(docker images -q) -f

trova l'id dell'immagine e l'id principale per tutte le immagini create dopo l'immagine in questione con quanto segue:

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

Quindi si chiama comando:

docker rmi {sub_image_id} 

"sub_image_id" è l'ID dell'immagine dipendente

Quello che mi ha funzionato è stato usare la combinazione REPOSITORY: TAG anziché l'ID IMMAGINE.

Quando ho provato a eliminare un'immagine docker con il comando docker rmi <IMAGE ID>senza contenitori associati a questa immagine ho ricevuto il messaggio:

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

Potrei cancellare con successo quando ho usato il comando docker rmi RPOSITORY:TAG

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

QUESTO COMANDO RIMUOVE TUTTE LE IMMAGINI (UTILIZZARE CON ATTENZIONE)

Hai provato a usare --force

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

Questo codice sopra funziona come un incanto, anche se ho avuto lo stesso problema

La risposta qui è di trovare tutti i bambini discendenti, che ha una risposta qui:

finestra mobile come posso ottenere l'elenco delle immagini secondarie dipendenti?

Quindi usalo per rimuovere le immagini secondarie in ordine.

Ecco uno script per rimuovere un'immagine e tutte le immagini che dipendono da essa.

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

Dopodiché usa il comando come suggerito da Nguyen.

Basandosi sul metodo della forza bruta di Simon Brady qui , se non hai un sacco di immagini puoi usare questa funzione di shell:

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

e poi chiamalo usando 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

Quando voglio rimuovere alcune immagini inutilizzate con il nome "<none>"nella finestra mobile, devo affrontare il problema unable to delete a354bbc7c9b7 (cannot be forced) - image has dependent child images. Quindi, per risolvere questo problema:

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

puoi vedere che ho diverse immagini con il nome javaapp: nome contenitore più recente e diverso. Quindi, ho ucciso e rimosso tutti i contenitori del contenitore "javaapp: latest" con:

sudo docker stop "containerName"

sudo docker rm "contenererName"

Poi

sudo docker rmi -f "imageId"

Quindi posso rimuovere tutte le immagini con il nome "<none>"

in bocca al lupo

Ho anche avuto questo problema, ho potuto risolvere il problema con i comandi seguenti. ciò può essere causa, il contenitore dell'immagine è in esecuzione o esce quindi prima di rimuovere l'immagine è necessario rimuovere il contenitore

docker ps -a -f status = uscito: questo comando mostra tutti i contenitori usciti, quindi copia l'ID contenitore e quindi esegui sotto i comandi per rimuovere il contenitore

docker rm #containerId: questo comando rimuove il contenitore questo potrebbe essere un problema che menziona "l'immagine ha immagini secondarie dipendenti"

Quindi prova a rimuovere l'immagine con il comando seguente

docker rmi #ImageId

Ho avuto questo problema e nessuna delle brevi risposte qui ha funzionato, anche nella pagina menzionata da @tudor sopra. Ho pensato di condividere qui come mi sono liberato delle immagini. Mi è venuta l'idea che le immagini dipendenti devono essere> = la dimensione dell'immagine principale, che aiuta a identificarla in modo che possiamo rimuoverla.

Ho elencato le immagini in ordine di dimensione per vedere se potevo individuare eventuali correlazioni:

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

Ciò consente di utilizzare una formattazione speciale dalla finestra mobile per posizionare prima la colonna delle dimensioni dell'immagine, quindi eseguire un ordinamento leggibile dall'uomo in ordine inverso. Quindi ripristino le colonne di facile lettura.

Poi ho guardato i <none>contenitori e ho abbinato il primo nell'elenco con dimensioni simili. Ho eseguito un semplice docker rmi <image:tag>su quell'immagine e tutte le <none>immagini del bambino sono andate con esso.

L'immagine problematica con tutte le immagini secondarie era in realtà la dannata myrepo/getstarted-lab immagine che ho usato quando ho iniziato a giocare con la finestra mobile. È perché avevo creato una nuova immagine dalla prima immagine di prova che ha creato la catena.

Spero che questo aiuti qualcun altro a un certo punto.

Supponiamo di avere un file Docker

FROM ubuntu:trusty
CMD ping localhost

Costruiamo l'immagine da quella senza TAG o denominazione

docker build .

Ora abbiamo un rapporto di successo "57ca5ce94d04 costruito con successo" Se vediamo le immagini della finestra mobile

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

Dobbiamo prima rimuovere il docker rmi 57ca5ce94d04

Seguito da

docker rmi 8789038981bc

Da quell'immagine verrà rimosso!

Una rimozione forzata di tutto come suggerito da qualcuno

docker rmi $(docker images -q) -f

Espandendo la risposta fornita da @Nguyen - questa funzione può essere aggiunta al tuo .bashrcetc e quindi chiamata dalla riga di comando per aiutare a ripulire eventuali image has dependent child imageserrori ...

Puoi eseguire la funzione come te stesso e, se docker psfallisce, eseguirà il dockercomando con sudoe ti chiederà la password.

Does NON eliminare le immagini per qualsiasi contenitore in esecuzione!

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

Ho anche questo nel mio .bashrcfile ...

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  
}

Lavora con:

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

Forza l'eliminazione di un elenco di immagini (esclude la versione 10, ad esempio)

immagini docker | versione grep | grep -v versione10> images.txt && per img in $ (awk -F "" '{print $ 3}' /root/images.txt); fare docker rmi -f $ img; fatto

puoi semplicemente fare questo:

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

Livello immagine: i repository sono spesso indicati come immagini o immagini contenitore, ma in realtà sono costituiti da uno o più livelli. I livelli di immagine in un repository sono collegati insieme in una relazione padre-figlio. Ogni livello dell'immagine rappresenta le modifiche tra se stesso e il livello principale.

Il modello di costruzione della finestra mobile utilizza l' ereditarietà . Significa che la versione idipende dalla versione i-1. Quindi, dobbiamo eliminare la versione i+1per poter eliminare la versione i. Questa è una dipendenza semplice.

Se vuoi eliminare tutte le immagini tranne l'ultima (la più aggiornata) e la prima (base), allora possiamo esportare l'ultima (la più aggiornata) usando il docker savecomando come sotto.

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

Quindi, ora, elimina tutte le immagini usando id-immagine come di seguito.

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

Ora carica l'immagine tgz salvata come di seguito.

gzip -c <output_file.tgz> | docker load

vedere l'id-immagine dell'immagine caricata usando la finestra mobile ps -q. Non ha tag e nome. Puoi semplicemente aggiornare tag e nome come di seguito.

docker tag <image_id> group_name/name:tag