Não é possível excluir a imagem do Docker com imagens filho dependentes

eu estou tentando

docker rmi c565603bc87f

Erro:

Resposta de erro do daemon: conflito: não é possível excluir c565603bc87f (não pode ser forçado) - a imagem possui imagens filho dependentes

Portanto, não consigo excluir a imagem nem com o sinalizador -f. Como excluir a imagem então e todos os seus filhos?

Versão do Linux e docker:

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

versão do docker Cliente: Versão: 1.11.2 Versão da API: 1.23 Versão Go: go1.5.4 Git commit: b9f10c9 Criada: Wed 1 de junho 22:00:43 2016 OS / Arch: linux / amd64

Servidor: Versão: 1.11.2 Versão da API: 1.23 Versão Go: go1.5.4 Git commit: b9f10c9 Criado: Wed Jun 1 22:00:43 2016 OS / Arch: linux / amd64

Você deve tentar remover imagens desnecessárias antes de remover a imagem:

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

Depois disso, execute:

docker rmi c565603bc87f

Em alguns casos (como no meu caso), você pode tentar excluir uma imagem , especificando o ID da imagem que possui várias tags que você nem imagina existir, algumas das quais podem ser usadas por outras imagens. Nesse caso, você pode não querer remover a imagem .

Se você tiver um caso de tags redundantes, conforme descrito aqui, em vez de docker rmi <image_id>usar docker rmi <repo:tag>a tag redundante que deseja remover.

todas as respostas anteriores estão corretas, mas aqui está uma solução que está apenas excluindo todas as suas imagens com força ( use este comando por seu próprio risco, pois todas as imagens serão excluídas )

docker rmi $(docker images -q) -f

encontre o ID da imagem e o ID pai de todas as imagens criadas após a imagem em questão com o seguinte:

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

Então você chama o comando:

docker rmi {sub_image_id} 

"sub_image_id" é o ID da imagem dependente

O que funcionou para mim foi usar a combinação REPOSITORY: TAG em vez de IMAGE ID.

Quando tentei excluir uma imagem do Docker com o comando docker rmi <IMAGE ID>sem contêineres associados a esta imagem, recebi a mensagem:

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

Eu poderia excluir com sucesso quando usei o comando docker rmi RPOSITORY:TAG

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

Este comando remove todas as imagens (use com cuidado)

Você já tentou usar --force

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

Este código acima funciona como um encanto, mesmo que eu tenha o mesmo problema

A resposta aqui é encontrar todos os filhos descendentes, que tem uma resposta aqui:

janela de encaixe, como posso obter a lista de imagens filho dependentes?

Em seguida, use isso para remover as imagens filho em ordem.

Aqui está um script para remover uma imagem e todas as imagens que dependem dela.

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

Depois disso, use o comando como Nguyen sugeriu.

Com base no método de força bruta de Simon Brady aqui , se você não tiver uma tonelada de imagens, poderá usar esta função 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}
}

e depois chame 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 eu quero remover alguma imagem não utilizada com o nome "<none>"na janela de encaixe, enfrento o problema unable to delete a354bbc7c9b7 (cannot be forced) - image has dependent child images. Então, para resolver esse 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

você pode ver que eu tenho várias imagens com o nome javaapp: nome do contêiner mais recente e diferente. Então, eu matei e remova todo o contêiner "javaapp: latest" com:

sudo docker stop "containerName"

sudo docker rm "containsrName"

Então

sudo docker rmi -f "ID da imagem"

Para remover todas as imagens com o nome "<none>"

boa sorte

Eu também tive esse problema, eu poderia resolver o problema com os comandos abaixo. isso pode ser porque o contêiner da imagem está em execução ou sai. Portanto, antes de remover a imagem, é necessário remover o contêiner

docker ps -a -f status = encerrado: este comando mostra todos os contêineres encerrados; portanto, copie o ID do contêiner e execute os comandos abaixo para remover o contêiner

docker rm #containerId: esse comando remover contêiner pode ser um problema que mencione "a imagem possui imagens filho dependentes"

Em seguida, tente remover a imagem com o comando abaixo

docker rmi #ImageId

Eu tive esse problema e nenhuma das respostas curtas aqui funcionou, mesmo na página mencionada por @tudor acima. Pensei em compartilhar aqui como me livrei das imagens. Eu tive a ideia de que as imagens dependentes devem ter> = o tamanho da imagem pai, o que ajuda a identificá-la para que possamos removê-la.

Listei as imagens em tamanho para ver se consegui identificar alguma correlação:

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

O que isso faz é usar alguma formatação especial da janela de encaixe para posicionar a coluna de tamanho da imagem primeiro e depois executar uma classificação legível por humanos na ordem inversa. Em seguida, restauro as colunas de fácil leitura.

Então olhei para os <none>contêineres e combinei com o primeiro da lista com um tamanho semelhante. Eu fiz um simples docker rmi <image:tag>nessa imagem e todas as <none>imagens da criança foram com ela.

A imagem do problema com todas as imagens filho era na verdade a myrepo/getstarted-lab imagem maldita que eu usei quando comecei a brincar com o docker. Foi porque eu criei uma nova imagem a partir da primeira imagem de teste que criou a cadeia.

Espero que ajude alguém em algum momento.

Suponha que tenhamos um Dockerfile

FROM ubuntu:trusty
CMD ping localhost

Construímos imagem a partir disso sem TAG ou nomeação

docker build .

Agora, temos um relatório de sucesso "57ca5ce94d04 compilado com êxito". Se virmos as imagens do docker

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

Primeiro precisamos remover o docker rmi 57ca5ce94d04

Seguido por

docker rmi 8789038981bc

Por essa imagem será removida!

Uma remoção forçada de tudo, como sugerido por alguém

docker rmi $(docker images -q) -f

Expandindo a resposta fornecida por @Nguyen - esta função pode ser adicionada ao seu .bashrcetc e depois chamada da linha de comando para ajudar a limpar os image has dependent child imageserros ...

Você pode executar a função como você mesmo e, se ocorrer uma docker psfalha, ele executará o dockercomando sudoe solicitará sua senha.

Será que não apagar imagens por quaisquer recipientes que funcionam!

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

Eu também tenho isso no meu .bashrcarquivo ...

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 com:

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

Forçar a exclusão de uma lista de imagens (exclua a versão 10, por exemplo)

imagens do docker | versão grep | grep -v versão10> images.txt && para img em $ (awk -F "" '{print $ 3}' /root/images.txt); docker rmi -f $ img; feito

você pode fazer isso:

➜ ~ sudo janela de encaixe rmi 4ed13257bb55 -f Deleted: sha256: 4ed13257bb5512b975b316ef482592482ca54018a7728ea1fc387e873a68c358 Deleted: sha256: 4a478ca02e8d2336595dcbed9c4ce034cd15f01229733e7d93a83fbb3a9026d3 Deleted: sha256: 96df41d1ce6065cf75d05873fb1f9ea9fed0ca86addcfcec7722200ed3484c69 Deleted: sha256: d95efe864c7096c38757b80fddad12819fffd68ac3cc73333ebffaa42385fded

Camada de imagem: os repositórios geralmente são chamados de imagens ou imagens de contêiner, mas na verdade são compostos de uma ou mais camadas. As camadas de imagem em um repositório são conectadas juntas em um relacionamento pai-filho. Cada camada da imagem representa alterações entre ela e a camada pai.

O padrão de construção da janela de encaixe usa herança . Isso significa que a versão idepende da versão i-1. Portanto, devemos excluir a versão i+1para poder excluir a versão i. Esta é uma dependência simples.

Se você deseja excluir todas as imagens, exceto a última (a mais atualizada) e a primeira (base), podemos exportar a última (a mais atualizada) usando o docker savecomando abaixo.

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

Agora, exclua todas as imagens usando o ID da imagem, como abaixo.

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

Agora, carregue sua imagem tgz salva como abaixo.

gzip -c <output_file.tgz> | docker load

veja o ID da imagem carregada usando o docker ps -q. Não possui tag e nome. Você pode simplesmente atualizar a tag e o nome, conforme feito abaixo.

docker tag <image_id> group_name/name:tag