Impossible de supprimer l'image Docker avec des images enfants dépendantes

j'essaie

docker rmi c565603bc87f

Erreur:

Réponse d'erreur du démon: conflit: impossible de supprimer c565603bc87f (ne peut pas être forcé) - l'image a des images enfants dépendantes

Donc je ne peux pas supprimer l'image même avec l'option -f. Comment supprimer l'image alors et tous ses enfants?

Version Linux et docker:

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

version docker Client: Version: 1.11.2 Version API: 1.23 Version Go: go1.5.4 Git commit: b9f10c9 Construit: mer 1 juin 22:00:43 2016 OS / Arch: linux / amd64

Serveur: Version: 1.11.2 Version API: 1.23 Version Go: go1.5.4 Git commit: b9f10c9 Construit: Wed Jun 1 22:00:43 2016 OS / Arch: linux / amd64

Vous devriez essayer de supprimer les images inutiles avant de supprimer l'image:

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

Après cela, exécutez:

docker rmi c565603bc87f

Dans certains cas (comme dans mon cas), vous essayez peut-être de supprimer une image en spécifiant l'identifiant de l'image qui a plusieurs balises dont vous ne réalisez pas l'existence, dont certaines peuvent être utilisées par d'autres images. Dans ce cas, vous ne souhaiterez peut-être pas supprimer l'image .

Si vous avez un cas de balises redondantes comme décrit ici, au lieu de les docker rmi <image_id>utiliser docker rmi <repo:tag>sur la balise redondante que vous souhaitez supprimer.

toutes les réponses précédentes sont correctes mais voici une solution qui consiste simplement à supprimer toutes vos images de force ( utilisez cette commande à vos risques et périls, elle supprimera toutes vos images )

docker rmi $(docker images -q) -f

recherchez l'ID d'image et l'ID parent pour toutes les images créées après l'image en question avec les éléments suivants:

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

Ensuite, vous appelez la commande:

docker rmi {sub_image_id} 

"sub_image_id" est l'ID de l'image dépendante

Ce qui a fonctionné pour moi, c'est d'utiliser la combinaison REPOSITORY: TAG plutôt que IMAGE ID.

Lorsque j'ai essayé de supprimer une image docker avec la commande docker rmi <IMAGE ID>sans conteneur associé à cette image, j'ai eu le message:

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

Je pourrais supprimer avec succès lorsque j'ai utilisé la commande docker rmi RPOSITORY:TAG

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

CETTE COMMANDE SUPPRIME TOUTES LES IMAGES (À UTILISER AVEC PRÉCAUTION)

Avez-vous essayé d'utiliser --force

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

Ce code ci-dessus fonctionne comme un charme même si j'ai eu le même problème

La réponse ici est de trouver tous les enfants descendants, qui a une réponse ici:

docker comment puis-je obtenir la liste des images enfants dépendantes?

Ensuite, utilisez-le pour supprimer les images enfants dans l'ordre.

Voici un script pour supprimer une image et toutes les images qui en dépendent.

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

Après cela, utilisez la commande comme Nguyen l'a suggéré.

En vous basant sur la méthode de force brute de Simon Brady ici , si vous n'avez pas une tonne d'images, vous pouvez utiliser cette fonction 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}
}

puis appelez-le en utilisant 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

Lorsque je veux supprimer une image inutilisée avec un nom "<none>"dans le docker, je suis confronté au problème.Pour unable to delete a354bbc7c9b7 (cannot be forced) - image has dependent child imagesrésoudre ce problème:

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

vous pouvez voir que j'ai plusieurs images avec le nom javaapp: nom de conteneur le plus récent et différent. Donc, j'ai tué et supprimé tous les conteneurs du conteneur "javaapp: latest" avec:

sudo docker stop "containerName"

sudo docker rm "containrName"

ensuite

sudo docker rmi -f "imageId"

Donc je peux supprimer toutes les images avec le nom "<none>"

bonne chance

J'ai également eu ce problème, je pourrais résoudre le problème avec les commandes ci-dessous. cela peut être dû au fait que le conteneur de l'image est en cours d'exécution ou se ferme donc avant de supprimer l'image, vous devez supprimer le conteneur

docker ps -a -f status = exited: cette commande affiche tous les conteneurs sortis, copiez alors l'ID du conteneur, puis exécutez les commandes ci-dessous pour supprimer le conteneur

docker rm #containerId: cette commande supprime le conteneur cela peut être un problème qui mentionne "l'image a des images enfants dépendantes"

Ensuite, essayez de supprimer l'image avec la commande ci-dessous

docker rmi #ImageId

J'ai eu ce problème et aucune des réponses courtes ici n'a fonctionné, même dans la page mentionnée par @tudor ci-dessus. J'ai pensé partager ici comment je me suis débarrassé des images. J'ai eu l'idée que les images dépendantes doivent être> = la taille de l'image parente, ce qui permet de l'identifier afin que nous puissions la supprimer.

J'ai répertorié les images par taille pour voir si je pouvais repérer des corrélations:

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

Ce que cela fait, c'est utiliser une mise en forme spéciale du menu fixe pour positionner d'abord la colonne de taille de l'image, puis exécuter un tri lisible par l'homme dans l'ordre inverse. Ensuite, je restaure les colonnes faciles à lire.

Ensuite, j'ai regardé les <none>conteneurs et j'ai fait correspondre le premier de la liste avec une taille similaire. J'ai effectué un simple docker rmi <image:tag>sur cette image et toutes les <none>images d'enfants sont allées avec.

L'image problématique avec toutes les images enfants était en fait la foutue myrepo/getstarted-lab image que j'ai utilisée lorsque j'ai commencé à jouer avec docker. C'était parce que j'avais créé une nouvelle image à partir de la première image de test qui a créé la chaîne.

Espérons que cela aide quelqu'un d'autre à un moment donné.

Supposons que nous ayons un Dockerfile

FROM ubuntu:trusty
CMD ping localhost

Nous construisons une image à partir de cela sans TAG ni dénomination

docker build .

Maintenant, nous avons un rapport de réussite "Construit avec succès 57ca5ce94d04" Si nous voyons les images du docker

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

Nous devons d'abord supprimer le docker rmi 57ca5ce94d04

Suivi par

docker rmi 8789038981bc

Par cette image sera supprimée!

Un éloignement forcé de tout comme suggéré par quelqu'un

docker rmi $(docker images -q) -f

Extension de la réponse fournie par @Nguyen - cette fonction peut être ajoutée à votre .bashrcetc, puis appelée à partir de la ligne de commande pour aider à nettoyer les image has dependent child imageserreurs ...

Vous pouvez exécuter la fonction comme vous-même, et si un docker pséchoue, il exécutera la dockercommande avec sudoet vous demandera votre mot de passe.

Ne supprime PAS les images pour les conteneurs en cours d'exécution!

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

J'ai aussi ceci dans mon .bashrcdossier ...

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  
}

Marche avec:

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

Forcer la suppression d'une liste d'images (exclure la version 10, par exemple)

images de docker | version grep | grep -v version10> images.txt && pour img dans $ (awk -F "" '{print $ 3}' /root/images.txt); faire docker rmi -f $ img; terminé

vous pouvez simplement faire ceci:

➜ ~ sudo docker rmi 4ed13257bb55 -f Deleted: SHA256: 4ed13257bb5512b975b316ef482592482ca54018a7728ea1fc387e873a68c358 Deleted: SHA256: 4a478ca02e8d2336595dcbed9c4ce034cd15f01229733e7d93a83fbb3a9026d3 Deleted: SHA256: 96df41d1ce6065cf75d05873fb1f9ea9fed0ca86addcfcec7722200ed3484c69 Deleted: SHA256: d95efe864c7096c38757b80fddad12819fffd68ac3cc73333ebffaa42385fded

Couche d'image: les référentiels sont souvent appelés images ou images de conteneur, mais en réalité, ils sont constitués d'une ou plusieurs couches. Les couches d'image d'un référentiel sont connectées ensemble dans une relation parent-enfant. Chaque calque d'image représente les changements entre lui-même et le calque parent.

Le modèle de construction du docker utilise l' héritage . Cela signifie que la version idépend de la version i-1. Il faut donc supprimer la version i+1pour pouvoir supprimer la version i. C'est une simple dépendance.

Si vous souhaitez supprimer toutes les images sauf la dernière (la plus mise à jour) et la première (de base), nous pouvons exporter la dernière (la plus mise à jour) en utilisant la docker savecommande ci-dessous.

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

Ensuite, maintenant, supprimez toutes les images en utilisant image-id comme ci - dessous.

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

Maintenant, chargez votre image tgz enregistrée comme ci-dessous.

gzip -c <output_file.tgz> | docker load

voir l'id-image de votre image chargée à l'aide de docker ps -q. Il n'a ni étiquette ni nom. Vous pouvez simplement mettre à jour la balise et le nom comme indiqué ci-dessous.

docker tag <image_id> group_name/name:tag