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


164

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



2
Exclua por tag do mais recente para o mais antigo. Se eles residem em um repositório, eles serão puxados se algum Dockerfile exigir.
rafaelbattesti

você deve aceitar a resposta (muito boa) fornecida por Nguyen
jpw 14/06

Respostas:


119

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

13
Não há imagens pendentes ... imagens do docker -f dangling = true -> Nothing
Roman

39
Esta resposta está respondendo a uma pergunta diferente "Como faço para remover imagens pendentes?" A pergunta do OP é "Como faço para remover imagens dependentes?"
tu-Restabelece Monica-dor duh

6
Para remover balançando as imagens, basta usarprune
Deqing

17
esse comando não funciona mais:> "docker rmi" requires at least 1 argument.
samayo 11/09/18

2
@samayo se você receber esse erro, tente alterar a parte de filtro para: --filter=dangling=true. Se você ainda receber esse erro, isso significa que você não tem imagens pendentes e, portanto, o comando in-set é avaliado como uma sequência vazia.
precisa saber é o seguinte

100

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.


11
docker rmi <repo:tag>trabalhou para mim. Sua solução é bastante simples entre essas respostas, obrigado.
Shihe Zhang 13/06

este é deve ser o caminho corret a fazê-lo para o meu caso para imagens golang remoto mais velhos
templo

Este foi o bilhete para mim, obrigado. Untagged: drud/ddev-webserver:20200301_leymannx_apache-junk-built
rfay 29/03

Se alguém instalou as amostras do eShopOnContainers da Microsoft, é absolutamente necessário removê- repo:taglas dessa maneira, pois cria oito imagens marcadas, compartilhando apenas duas IDs de imagem. Mesmo o Visual Studio não os excluirá em sua janela de gerenciamento de contêiner ...
mdisibio

O comando docker rmi <repo:tag>apenas desmarca , não necessariamente exclui uma imagem. Se houver mais de uma etiqueta referenciando esta imagem, ou se houver outro problema como, por exemplo, o declarado pelo OP, a imagem ainda estará lá. Você pode verificar que a imagem ainda existe com o comando docker images ls --all.
twan163 16/06

50

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

insira a descrição da imagem aqui


1
Isso funcionou para mim; Eu só queria explodir todas as minhas imagens locais. Observe que eu tive que atualizar para trabalhar com a minha versão do docker (18.09.7): docker image rm $(docker image ls -a -q) -f
akagixxer em

40

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


É bom excluir imagens intermediárias de uma imagem específica. Obrigado!!
A.Villegas 14/03/19

flag desconhecido --filter: /
SamuraiJack

Esta parece ser a solução real para a questão!
Paolo

28

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

De fato. Alguma explicação para esse comportamento estranho?
RodrigoM

1
Isso funcionou para mim também. No meu caso, eu tinha uma imagem desatualizada do Ubuntu, que não era referenciada em nenhuma outra imagem como pai, mas ainda assim não foi possível removê-lo. docker rmi 93fd78260bd1falhou, mas docker tag 93fd78260bd1 ubuntu:temp && docker rmi ubuntu:tempfoi bem sucedido.
Thomas Lobker 19/02/19

trabalhar para mim, também estava atualizando uma imagem desatualizada. alguém sabe por que ele falha w id?
Strider

3
Isso realmente não exclui a imagem. Apenas remove uma tag duplicada para essa imagem (daí a mensagem Untagged: ubuntu:18.04v1). Se você o fizer docker images -a, provavelmente verá 3f66bec2c6bfainda listado. Se a imagem fosse realmente excluída, você receberia a mensagem #Deleted: 3f66bec2c6bf
wisbucky 23/10/19

17

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


1
Eu deixei o sudo nos dois lugares e funcionou muito bem para mim
user2217751 25/02


6

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

6
# docker rm $(docker ps -aq)

Depois disso, use o comando como Nguyen sugeriu.


4

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


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


3

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


1

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


1

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.


1

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

1

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

0

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


-1

você pode fazer isso:

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


-1

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
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.