No se puede eliminar la imagen de la ventana acoplable con imágenes secundarias dependientes

216

estoy intentando

docker rmi c565603bc87f

Error:

Error response from daemon: conflict: unable to delete c565603bc87f (cannot be forced) - image has dependent child images

Entonces no puedo eliminar la imagen incluso con la bandera -f. ¿Cómo eliminar la imagen entonces y todos sus elementos secundarios?

Versión de Linux y Docker:

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

docker versión Cliente: Versión: 1.11.2 Versión de API: 1.23 Versión de Go: go1.5.4 Confirmación de Git: b9f10c9 Construido: Mié 1 de junio 22:00:43 2016 OS / Arch: linux / amd64

Servidor: Versión: 1.11.2 Versión de API: 1.23 Versión de Go: go1.5.4 Confirmación de Git: b9f10c9 Construido: Mié 1 de junio 22:00:43 2016 OS / Arch: linux / amd64

3
158

Debe intentar eliminar las imágenes innecesarias antes de eliminar la imagen:

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

Después de eso, ejecuta:

docker rmi c565603bc87f
9
  • dieciséis
    No hay imágenes colgantes ... imágenes de la ventana acoplable -f colgando = verdadero -> NadaYakovlevRoman 30 de junio de 2016 a las 14:09
  • 57
    Esta respuesta responde a una pregunta diferente "¿Cómo elimino las imágenes colgantes?" La pregunta del OP es "¿Cómo elimino las imágenes dependientes?" tu-Reinstate Monica-dor duh 9 de diciembre de 2016 a las 4:10
  • 10
    Para eliminar imágenes colgantes, simplemente usepruneDeqing 18 de mayo de 2017 a las 7:26
  • 26
    ese comando ya no funciona:> "docker rmi" requires at least 1 argument.samayo 11/09/18 a las 18:37
  • 2
    @samayo si le da ese error, intente cambiar la parte de filtro a: --filter=dangling=true. Si aún recibe ese error, eso solo significa que no tiene imágenes colgantes, por lo que el comando in-set se evalúa como una cadena vacía. HammerN'Songs 8 oct 2018 a las 21:29
152

En algunos casos (como en mi caso), es posible que intente eliminar una imagen especificando la identificación de la imagen que tiene varias etiquetas que no se da cuenta de que existen, algunas de las cuales pueden ser utilizadas por otras imágenes. En cuyo caso, es posible que no desee eliminar la imagen .

Si tiene un caso de etiquetas redundantes como se describe aquí, en lugar de docker rmi <image_id>utilizarlas docker rmi <repo:tag>en la etiqueta redundante que desea eliminar.

5
  • 19
    docker rmi <repo:tag>funcionó para mí Su solución es bastante simple entre esas respuestas, gracias. Shihe Zhang 13/06/2018 a las 7:45
  • esta debería ser la forma correcta de hacerlo para mi caso a imágenes remotas de golang más antiguastemple 29/10/19 a las 1:19
  • Este fue el boleto para mí, gracias. Untagged: drud/ddev-webserver:20200301_leymannx_apache-junk-builtrfay 29/03/20 a las 16:02
  • Si alguien ha instalado muestras de eShopOnContainers de Microsoft, es absolutamente necesario eliminar cada una de esta manera repo:tagporque crea ocho imágenes etiquetadas que comparten solo dos identificaciones de imagen. Incluso Visual Studio no los eliminará en su ventana de administración de contenedores ...mdisibio 13 de mayo de 2020 a las 18:42
  • El comando docker rmi <repo:tag>solo quita la etiqueta , no necesariamente elimina una imagen. Si hay más de una etiqueta que hace referencia a esta imagen, o si hay otro problema como, por ejemplo, el indicado por el OP, la imagen seguirá ahí. Puede comprobar que la imagen todavía existe con el comando docker images ls --all. twan163 16/06/20 a las 13:45
63

busque la identificación de la imagen y la identificación principal para todas las imágenes creadas después de la imagen en cuestión con lo siguiente:

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

Entonces llamas al comando:

docker rmi {sub_image_id} 

"sub_image_id" es el ID de la imagen dependiente

4
  • Muy bueno borrar imágenes intermedias de una imagen específica. ¡¡Gracias!! A.Villegas 14/03/19 a las 11:36
  • 1
    bandera desconocida --filtro: /SamuraiJack 29/03/20 a las 16:40
  • 4
    ¡Esta parece ser la solución real a la pregunta! Paolo 13/04/20 a las 17:19
  • 2
    Así es como puede hacer esto en una línea: docker inspect --format='{{.Id}} {{.Parent}}' $(docker images --filter since=65f9b4839725 -q) | cut -d' ' -f1 | cut -d: -f2 | xargs docker rmiMatt Friedman 24 mar a la 1:00
63

todas las respuestas anteriores son correctas, pero aquí hay una solución que es simplemente eliminar todas sus imágenes a la fuerza ( use este comando bajo su propio riesgo, eliminará todas sus imágenes )

docker rmi $(docker images -q) -f

ingrese la descripción de la imagen aquí

1
  • 1
    Esto funcionó para mí; Solo quería volar todas mis imágenes locales. Tenga en cuenta que tuve que actualizar para trabajar con mi versión de Docker (18.09.7): docker image rm $(docker image ls -a -q) -fakagixxer 3 de ene. De 2020 a las 22:14
31

Lo que funcionó para mí fue usar la combinación REPOSITORY: TAG en lugar de IMAGE ID.

Cuando intenté eliminar una imagen de la ventana acoplable con el comando docker rmi <IMAGE ID>sin contenedores asociados con esta imagen, tuve el mensaje:

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

Podría eliminar con éxito cuando usé el comando docker rmi RPOSITORY:TAG

$ docker rmi ubuntu:18.04v1
Untagged: ubuntu:18.04v1
4
  • En efecto. ¿Alguna explicación de por qué este comportamiento extraño? RodrigoM 11/01/19 a las 16:41
  • 1
    Esto funcionó para mí también. En mi caso, tenía una imagen de Ubuntu desactualizada, no se hizo referencia a ella en ninguna otra imagen como padre, pero aún así no se pudo eliminar. docker rmi 93fd78260bd1falló, pero luego docker tag 93fd78260bd1 ubuntu:temp && docker rmi ubuntu:temptuvo éxito. Thomas Lobker 19/02/19 a las 12:32
  • trabajo para mí, también estaba actualizando una imagen desactualizada. ¿Alguien sabe por qué falla w id? strider 4/06/19 a las 17:59
  • 4
    Esto realmente no borra la imagen. Simplemente elimina una etiqueta duplicada para esa imagen (de ahí el mensaje Untagged: ubuntu:18.04v1). Si lo hace docker images -a, probablemente verá 3f66bec2c6bftodavía en la lista. Si la imagen fuera realmente eliminada, recibiría el mensajeDeleted: 3f66bec2c6bfwisbucky 23/10/19 a las 23:15
23

ESTE COMANDO ELIMINA TODAS LAS IMÁGENES (UTILICE CON PRECAUCIÓN)

¿Ha intentado utilizar --force

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

Este código anterior se ejecuta como un encanto, incluso si tuve el mismo problema

3
  • 2
    Dejé sudo en ambos lugares y funcionó muy bien para míuser2217751 25 feb.20 a las 20:15
  • Finalmente funcionó, pero ¿hay algo más "quirúrgico" que obtenga los mismos resultados? readyready15728 13 de febrero a las 23:43
  • 1
    Creo que más quirúrgico no es crear imágenes de Docker usando sudo :)Dapter20 1 de abril a las 10:36
12

Si quieres Untag Docker Images

docker rmi <rep:tag>

Si quieres Removing Docker Images

docker image rm <image_id>

Ej .: Escriba docker image lspara mostrar la información de las imágenes

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

docker rmi python:3.6

docker image rm 60f85556d5d2

1
  • ¿No sería eso simplemente desetiquetar en lugar de eliminar en este escenario? manojlds 29/12/20 a las 8:38
9

Aquí hay un script para eliminar una imagen y todas las imágenes que dependen de ella.

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

La respuesta aquí es encontrar todos los hijos descendientes, que tiene una respuesta aquí:

docker ¿cómo puedo obtener la lista de imágenes secundarias dependientes?

Luego utilícelo para eliminar las imágenes secundarias en orden.

2
  • 9
    ¿Ya has desarrollado este guión? TT. 8/10/2017 a las 19:17
  • 1
    Seguí adelante y lo desarrollé en mi guión a continuación. lmat - Reinstate Monica 20/04/18 a las 21:26
6
# docker rm $(docker ps -aq)

Después de eso, use el comando como sugirió Nguyen.

1
  • Esto no funciona. Este comando elimina todos los contenedores. Pero la imagen aún puede tener imágenes secundarias dependientes: por ejemplo, si la imagen que se elimina es una imagen intermedia de una compilación de Docker. GolDDranks 5/10/20 a las 5:37
5

Sobre la base del método de fuerza bruta de Simon Brady aquí , si no tiene un montón de imágenes, puede usar esta función de 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}
}

y luego llámelo usando recursive_remove_image <image-id>.

3

Cuando quiero eliminar alguna imagen no utilizada con el nombre "<none>"en la ventana acoplable, me enfrento al problema unable to delete a354bbc7c9b7 (cannot be forced) - image has dependent child images. Entonces, para resolver este 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

puede ver que tengo varias imágenes con el nombre javaapp: el nombre del contenedor más reciente y diferente. Entonces, maté y eliminé todos los contenedores del contenedor "javaapp: latest" con:

sudo docker stop "containerName"

sudo docker rm "containrName"

Luego

sudo docker rmi -f "imageId"

Entonces puedo eliminar todas las imágenes con nombre "<none>"

buena suerte

2

Ampliando la respuesta proporcionada por @Nguyen: esta función se puede agregar a su, .bashrcetc. y luego se puede llamar desde la línea de comandos para ayudar a limpiar cualquier image has dependent child imageserror ...

Puede ejecutar la función como usted mismo, y si docker psfalla, ejecutará el dockercomando con sudoy le pedirá su contraseña.

¡ NO elimina imágenes de ningún contenedor en ejecución!

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

También tengo esto en mi .bashrcarchivo ...

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  
}

Funciona con:

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

Ejecute este comando de la ventana acoplable

  1. docker image rm -f $(docker image ls --filter dangling=true -q)

y luego corre

  1. docker image rm -f $(docker image ls -a -q)

Encontré los comandos anteriores muy útiles después de trabajar durante muchas horas.

  1. De lo contrario, puede ejecutar prune script. https://gist.github.com/sethbergman/cb0f1f700b1f6474b9738191055c9fb7
1

También tuve este problema, podría resolver el problema con los siguientes comandos. Esto puede deberse a que el contenedor de la imagen se está ejecutando o se está cerrando, por lo que antes de eliminar la imagen, debe eliminar el contenedor.

docker ps -a -f status = exited: este comando muestra todos los contenedores salidos, entonces copie el ID del contenedor y luego ejecute los siguientes comandos para eliminar el contenedor

docker rm #containerId: este comando elimina el contenedor, esto puede ser un problema que menciona "la imagen tiene imágenes secundarias dependientes"

Luego intente eliminar la imagen con el siguiente comando

docker rmi #ImageId

1

Tuve este problema y ninguna de las respuestas cortas aquí funcionó, incluso en la página mencionada por @tudor anteriormente. Pensé en compartir aquí cómo me deshice de las imágenes. Se me ocurrió la idea de que las imágenes dependientes deben tener> = el tamaño de la imagen principal, lo que ayuda a identificarla para que podamos eliminarla.

Enumeré las imágenes en orden de tamaño para ver si podía detectar alguna correlación:

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

Lo que hace esto es usar un formato especial de la ventana acoplable para colocar primero la columna de tamaño de la imagen y luego ejecutar una ordenación legible por humanos en orden inverso. Luego restauro las columnas fáciles de leer.

Luego miré los <none>contenedores y emparejé el primero de la lista con un tamaño similar. Realicé un simple docker rmi <image:tag>en esa imagen y todas las <none>imágenes de los niños fueron con él.

La imagen problemática con todas las imágenes secundarias fue en realidad la maldita myrepo/getstarted-lab imagen que usé cuando comencé a jugar con Docker. Fue porque había creado una nueva imagen a partir de la primera imagen de prueba que creó la cadena.

Con suerte, eso ayudará a alguien más en algún momento.

1

Intentando eliminar la identificación de la imagen: b721d1cdaac7

docker rmi b721d1cdaac7 -f

Respuesta: Respuesta de error del demonio: conflicto: no se puede eliminar b721d1cdaac7 (no se puede forzar) - la imagen tiene imágenes secundarias dependientes

Para eliminar todas las imágenes de los niños, el comando:

  docker image rm $(docker images --filter since=b721d1cdaac7 -q) -f

Primero desmarcará y eliminará todas las imágenes secundarias.

0

Supongamos que tenemos un Dockerfile

FROM ubuntu:trusty
CMD ping localhost

Construimos una imagen a partir de eso sin TAG o naming.

docker build .

Ahora tenemos un informe de éxito "57ca5ce94d04 construido con éxito" Si vemos las imágenes de la ventana acoplable

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

Primero tenemos que quitar el docker rmi 57ca5ce94d04

Seguido por

docker rmi 8789038981bc

¡Por esa imagen se eliminará!

Una remoción forzada de todo según lo sugerido por alguien.

docker rmi $(docker images -q) -f
1
  • Obtengo cannot be forcedpor cada imagen de este tipovladkras 19 de agosto de 2020 a las 4:46
0

Forzar la eliminación de una lista de imágenes (excluir la versión 10, por ejemplo)

docker images | grep version | grep -v version10 > images.txt && for img in $( awk -F" " '{print $3}' /root/images.txt ) ; do docker rmi -f $img; done

0

Intentando eliminar la identificación de la imagen: b721d1cdaac7 docker rmi b721d1cdaac7 -f Respuesta: Respuesta de error del demonio: conflicto: no se puede eliminar b721d1cdaac7 (no se puede forzar) - la imagen tiene imágenes secundarias dependientes

Para eliminar todas las imágenes secundarias, la imagen de la ventana acoplable rm $ (imágenes de la ventana acoplable --filter since = b721d1cdaac7 -q) -f

-1

Capa de imagen: los repositorios a menudo se denominan imágenes o imágenes de contenedor, pero en realidad están formados por una o más capas. Las capas de imágenes de un repositorio están conectadas entre sí en una relación padre-hijo. Cada capa de imagen representa cambios entre ella misma y la capa principal.

El patrón de construcción de Docker usa herencia . Significa que la versión idepende de la versión i-1. Entonces, debemos eliminar la versión i+1para poder eliminar la versión i. Esta es una dependencia simple.

Si desea eliminar todas las imágenes excepto la última (la más actualizada) y la primera (base), podemos exportar la última (la más actualizada) usando el docker savecomando que se muestra a continuación.

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

Luego, ahora, elimine todas las imágenes usando image-id como se muestra a continuación.

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

Ahora, cargue su imagen tgz guardada como se muestra a continuación.

gzip -c <output_file.tgz> | docker load

vea el ID de imagen de su imagen cargada usando docker ps -q. No tiene etiqueta ni nombre. Simplemente puede actualizar la etiqueta y el nombre como se hace a continuación.

docker tag <image_id> group_name/name:tag
-1

Simplemente use:

docker rmi <image:tag> -f

por ejemplo:

docker rmi ubuntu:latest -f 

eliminará el nombre de la imagen ubuntucon el nombre de la etiqueta latesty -fse eliminará por la fuerza.

funcionó para mi

-2

puedes hacer esto:

➜ ~ sudo ventana acoplable RMI 4ed13257bb55 -f Eliminado: sha256: 4ed13257bb5512b975b316ef482592482ca54018a7728ea1fc387e873a68c358 Eliminado: sha256: 4a478ca02e8d2336595dcbed9c4ce034cd15f01229733e7d93a83fbb3a9026d3 Eliminado: sha256: 96df41d1ce6065cf75d05873fb1f9ea9fed0ca86addcfcec7722200ed3484c69 Eliminado: sha256: d95efe864c7096c38757b80fddad12819fffd68ac3cc73333ebffaa42385fded