Encontrar as camadas e os tamanhos das camadas para cada imagem Docker

Para fins de pesquisa, estou tentando rastrear o registro público do Docker ( https://registry.hub.docker.com/ ) e descobrir 1) quantas camadas uma imagem média tem e 2) os tamanhos dessas camadas para obter um ideia da distribuição.

No entanto, estudei a API e as bibliotecas públicas, bem como os detalhes no github, mas não consigo encontrar nenhum método para:

• recuperar todos os repositórios / imagens públicos (mesmo que sejam milhares, ainda preciso de uma lista inicial para iterar)
• encontre todas as camadas de uma imagem
• encontre o tamanho de uma camada (portanto, não de uma imagem, mas de uma camada individual).

Alguém pode me ajudar a encontrar uma maneira de recuperar essas informações?

Obrigado!

EDITAR: alguém é capaz de verificar se a pesquisa de '*' no registro do Docker está retornando todos os repositórios e não apenas qualquer coisa que mencione '*' em qualquer lugar? https://registry.hub.docker.com/search?q=*

Você pode encontrar as camadas das imagens na pasta / var / lib / docker / aufs / layers; forneça se você configurou para driver de armazenamento como aufs (opção padrão)

Exemplo:

 docker ps -a
 CONTAINER ID        IMAGE               COMMAND             CREATED             STATUS                      PORTS               NAMES
 0ca502fa6aae        ubuntu              "/bin/bash"         44 minutes ago      Exited (0) 44 seconds ago                       DockerTest

Agora para visualizar as camadas dos containers que foram criadas com a imagem "Ubuntu"; vá para o diretório / var / lib / docker / aufs / layers e cat o arquivo começa com o ID do contêiner (aqui é 0ca502fa6aae *)

 root@viswesn-vm2:/var/lib/docker/aufs/layers# cat    0ca502fa6aaefc89f690736609b54b2f0fdebfe8452902ca383020e3b0d266f9-init 
 d2a0ecffe6fa4ef3de9646a75cc629bbd9da7eead7f767cb810f9808d6b3ecb6
 29460ac934423a55802fcad24856827050697b4a9f33550bd93c82762fb6db8f
 b670fb0c7ecd3d2c401fbfd1fa4d7a872fbada0a4b8c2516d0be18911c6b25d6
 83e4dde6b9cfddf46b75a07ec8d65ad87a748b98cf27de7d5b3298c1f3455ae4

Isso mostrará o resultado do mesmo executando

root@viswesn-vm2:/var/lib/docker/aufs/layers# docker history ubuntu
IMAGE               CREATED             CREATED BY                                         SIZE                COMMENT
d2a0ecffe6fa        13 days ago         /bin/sh -c #(nop) CMD ["/bin/bash"]             0 B                 
29460ac93442        13 days ago         /bin/sh -c sed -i 's/^#\s*\   (deb.*universe\)$/   1.895 kB            
b670fb0c7ecd        13 days ago         /bin/sh -c echo '#!/bin/sh' > /usr/sbin/polic   194.5 kB            
83e4dde6b9cf        13 days ago         /bin/sh -c #(nop) ADD file:c8f078961a543cdefa   188.2 MB 

Para visualizar o ID completo da camada; executado com a opção --no-trunc como parte do comando de histórico.

docker history --no-trunc ubuntu

Você pode primeiro encontrar o ID da imagem usando:

$ docker images -a

Em seguida, encontre as camadas da imagem e seus tamanhos:

$ docker history --no-trunc <Image ID>

Observação: estou usando o Docker versão 1.13.1

$ docker -v
Docker version 1.13.1, build 092cba3

Confira mergulho escrito em golang.

Ferramenta incrível!

Na minha opinião, docker history <image>é suficiente. Isso retorna o tamanho de cada camada:

$ docker history jenkinsci-jnlp-slave:2019-1-9c
IMAGE        CREATED    CREATED BY                                    SIZE  COMMENT
93f48953d298 42 min ago /bin/sh -c #(nop)  USER jenkins               0B
6305b07d4650 42 min ago /bin/sh -c chown jenkins:jenkins -R /home/je… 1.45GB

Eles têm uma resposta muito boa aqui: https://stackoverflow.com/a/32455275/165865

Basta executar as imagens abaixo:

docker run --rm -v /var/run/docker.sock:/var/run/docker.sock nate/dockviz images -t

Isso inspecionará a imagem do docker e imprimirá as camadas:

$ docker image inspect nginx -f '{{.RootFS.Layers}}'
[sha256:d626a8ad97a1f9c1f2c4db3814751ada64f60aed927764a3f994fcd88363b659 sha256:82b81d779f8352b20e52295afc6d0eab7e61c0ec7af96d85b8cda7800285d97d sha256:7ab428981537aa7d0c79bc1acbf208c71e57d9678f7deca4267cc03fba26b9c8]

mais uma ferramenta: https://github.com/CenturyLinkLabs/dockerfile-from-image

GUI usando ImageLayers.io

1. https://hub.docker.com/search?q=* mostra todas as imagens em todo o hub Docker, não é possível obter isso por meio do comando de pesquisa, pois ele não aceita curingas.

2. A partir da v1.10, você pode encontrar todas as camadas de uma imagem puxando-a e usando estes comandos:

   docker pull ubuntu
   ID=$(sudo docker inspect -f {{.Id}} ubuntu)
   jq .rootfs.diff_ids /var/lib/docker/image/aufs/imagedb/content/$(echo $ID|tr ':' '/')
   

3) O tamanho pode ser encontrado em, /var/lib/docker/image/aufs/layerdb/sha256/{LAYERID}/sizeembora LAYERID! = Os diff_ids encontrados com o comando anterior. Para isso, você precisa olhar /var/lib/docker/image/aufs/layerdb/sha256/{LAYERID}/diffe comparar com a saída do comando anterior para corresponder adequadamente ao diff_id e ao tamanho corretos.

De fato, é possível consultar as informações de manifesto ou blob do servidor de registro do docker sem puxar a imagem para o disco local.

Você pode consultar a API Registry v2 para buscar o manifesto da imagem.

GET /v2/<name>/manifests/<reference>

Observe, você deve lidar com diferentes versões do manifesto. Para v2, você pode obter diretamente o tamanho da camada e o resumo do blob. Para o manifesto v1 , você pode HEAD o URL de download do blob para obter o tamanho real da camada.

Existe um script simples para lidar com os casos acima que serão mantidos continuamente.

Não exatamente a questão original, mas para encontrar a soma total de todas as imagens sem contagem dupla de camadas compartilhadas, o seguinte é útil (ubuntu 18):

sudo du -h -d1  /var/lib/docker/overlay2 | sort -h

Resolvi esse problema usando a função de pesquisa no site do Docker, onde '*' é uma pesquisa válida que retorna 200k repositórios e, em seguida, rastreei cada página individual. A análise de HTML me permite extrair todos os nomes das imagens em cada página.