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

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

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

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.

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

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

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

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

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

docker, ¿cómo puedo obtener la lista de imágenes de niños dependientes?

Luego, use eso para eliminar las imágenes secundarias en orden.

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

# docker rm $(docker ps -aq)

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

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

docker rmi <rep:tag>

Ex:

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

docker rmi python: 3.6

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

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

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.

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

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

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

puedes hacer esto:

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

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