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

164

estoy intentando

docker rmi c565603bc87f

Error:

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

Por lo tanto, 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

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

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

romano
fuente
tal vez este podría ayudar: gist.github.com/Siva-Charan/db7bd84ad2ca2b0779d87a75e6bb4176
Gujarat Santana
2
Eliminar por etiqueta de la más nueva a la más antigua. Si viven en un repositorio, serán retirados si algún Dockerfile lo requiere.
rafaelbattesti
deberías aceptar la (muy buena) respuesta que Nguyen proporcionó
jpw

Respuestas:

119

Debe intentar eliminar 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
Nguyen Sy Thanh Hijo
fuente
13
No hay imágenes colgantes ... imágenes acoplables -f colgando = verdadero -> Nada
Roman
39
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
66
Para eliminar imágenes colgantes, solo useprune
Deqing
17
ese comando ya no funciona:> "docker rmi" requires at least 1 argument.
samayo
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, y que el comando en el conjunto se evalúa como una cadena vacía.
HammerN'Songs
100

En algunos casos (como en mi caso) puede estar tratando de eliminar una imagen especificando la identificación de la imagen que tiene varias etiquetas que no se dan cuenta de que existen, algunas de las cuales pueden ser utilizadas por otras imágenes. En ese 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>usar docker rmi <repo:tag>en la etiqueta redundante que desea eliminar.

bbarker
fuente
11
docker rmi <repo:tag>funcionó para mí. Su solución es bastante simple entre esas respuestas, gracias.
Shihe Zhang
esta debería ser la forma correcta de hacerlo para mi caso a imágenes de golang más antiguas remotas
templo
Este fue el boleto para mí, gracias. Untagged: drud/ddev-webserver:20200301_leymannx_apache-junk-built
rfay
Si alguien ha instalado las muestras de eShopOnContainers de Microsoft, absolutamente tiene que eliminar cada una de esta manera repo:tagporque crea ocho imágenes etiquetadas que comparten solo dos ID de imágenes. Incluso Visual Studio no los eliminará en su ventana de administración de contenedores ...
mdisibio
El comando docker rmi <repo:tag>solo desenchufa , 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 verificar que la imagen todavía existe con el comando docker images ls --all.
twan163
50

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í

grepit
fuente
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) -f
akagixxer
40

encuentre 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 la ID de la imagen dependiente

Nguyen Vu Quang
fuente
Muy bueno para eliminar imágenes intermedias de una imagen específica. ¡¡Gracias!!
A.Villegas
bandera desconocida --filtro: /
SamuraiJack
¡Esta parece ser la solución real a la pregunta!
Paolo
28

Lo que me funcionó fue usar la combinación REPOSITORY: TAG en lugar de la ID DE IMAGEN.

Cuando intenté eliminar una imagen acoplable con el comando docker rmi <IMAGE ID>sin contenedores asociados con esta imagen, recibí el mensaje:

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

Pude eliminar con éxito cuando utilicé el comando docker rmi RPOSITORY:TAG

$ docker rmi ubuntu:18.04v1
Untagged: ubuntu:18.04v1
Edu Costa
fuente
En efecto. ¿Alguna explicación de por qué este comportamiento extraño?
RodrigoM
1
Esto funcionó para mí también. En mi caso, tenía una imagen de Ubuntu desactualizada, no se hacía referencia 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
trabajo para mí, también estaba actualizando una imagen desactualizada. Alguien sabe por qué falla w id?
Strider
3
Esto realmente no elimina 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ías el mensajeDeleted: 3f66bec2c6bf
wisbucky el
17

ESTE COMANDO QUITA TODAS LAS IMÁGENES (USAR CON PRECAUCIÓN)

¿Has intentado usar --force

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

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

Dapter20
fuente
1
Dejé sudo en ambos lugares y funcionó muy bien para mí
usuario2217751
6

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
Expiación limitada
fuente
6
# docker rm $(docker ps -aq)

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

camino
fuente
4

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ámalo usando recursive_remove_image <image-id>.

sentimentaloide
fuente
4
docker rmi <rep:tag>

Ex:

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

docker rmi python: 3.6

CamXiMuoi
fuente
3

Cuando quiero eliminar alguna imagen no utilizada con nombre "<none>"en la ventana acoplable, me enfrento con el 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

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

sudo docker stop "containerName"

sudo docker rm "contenerrName"

Luego

sudo docker rmi -f "imageId"

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

buena suerte

Saman Salehi
fuente
1

También recibí este problema, pude resolver el problema con los siguientes comandos. esto puede ser causa, el contenedor de la imagen se está ejecutando o salir, 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, así que copie el ID del contenedor y luego ejecute los siguientes comandos para eliminar el contenedor

docker rm #containerId: este comando eliminar contenedor 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

Damith Asanka
fuente
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 ser> = 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 esto hace es usar un formato especial de la ventana acoplable para colocar primero la columna de tamaño de imagen, 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 del niño fueron con ella.

La imagen del problema con todas las imágenes secundarias era 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.

Esperemos que eso ayude a alguien más en algún momento.

Chris Gillatt
fuente
1

Supongamos que tenemos un Dockerfile

FROM ubuntu:trusty
CMD ping localhost

Creamos una imagen a partir de eso sin TAG ni nombres

docker build .

Ahora tenemos un informe de éxito "Construido con éxito 57ca5ce94d04" 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 debemos eliminar el docker rmi 57ca5ce94d04

Seguido por

docker rmi 8789038981bc

Por esa imagen se eliminará!

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

docker rmi $(docker images -q) -f
vimal krishna
fuente
1

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 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
Control de Android
fuente
0

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

imágenes del acoplador | versión grep | grep -v versión10> images.txt && para img en $ (awk -F "" '{print $ 3}' /root/images.txt); docker rmi -f $ img; hecho

Nekhla karim
fuente
-1

puedes hacer esto:

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

toro sin nombre
fuente
-1

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

El patrón de construcción del acoplador utiliza herencia . Significa que la versión idepende de la versión i-1. Por lo tanto, debemos eliminar la versión i+1para poder eliminarla i. Esta es una dependencia simple.

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

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

Entonces, 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 la imagen-id de su imagen cargada usando docker ps -q. No tiene etiqueta y nombre. Simplemente puede actualizar la etiqueta y el nombre como se hace a continuación.

docker tag <image_id> group_name/name:tag
Uddhav Gautam
fuente