Imagem: é um modelo de contêiner Docker somente leitura que contém toda a estrutura do sistema de arquivos e o conteúdo necessário para iniciar o contêiner.
Para simplificar, o espelhamento é um sistema de arquivos especial que fornece dados estáticos, como programas, bibliotecas de software, recursos, configuração, etc. exigidos pelo contêiner para ser executado. O espelhamento não contém dados dinâmicos e o conteúdo do espelhamento não será alterado após ser construído.
As operações de espelhamento comumente usadas são mostradas na figura: 
Espelho de puxar
Formato do comando: docker pull [Registry] / [Repository] / [Image]: [Tag]
Registro: Servidor de registro. O Docker puxará a imagem espelhada do docker.io por padrão. Se você tiver seu próprio armazém espelho, poderá substituir o Registro por seu próprio servidor de registro.
Repositório: repositório de espelho, geralmente um grupo de espelhos relacionados são classificados como um repositório de espelho e a biblioteca é o repositório de espelho padrão do Docker.
Imagem: o nome da imagem.
Tag: o rótulo da imagem. Se você não especificar o rótulo para extrair a imagem, o padrão é o mais recente.
Por exemplo: Obtenha um comando de espelhamento
denominado busybox: docker pull busybox
Este
comando pesquisará primeiro localmente. Se a imagem do busybox não puder ser encontrada localmente, ela será baixada do site do docker hup.
Espelho retrovisor
docker images
Este comando pode listar todos os espelhos locais

Use ls para visualizar a imagem especificada: docker image ls test_image
Use o grep para ver a imagem especificada: imagens docker | grep test_image
Renomear o espelho
Formato do comando: docker tag [SOURCE_IMAGE] [: TAG] [TARGET_IMAGE] [: TAG]
 O
significado deste comando é renomear o nome da
imagem para: test_image e marcar para: mais recente para: uma nova imagem do nome da imagem para: test_image_copy e marcar para: mais recente, que é equivalente a copiar, em vez de matar diretamente a imagem original .
Use o comando docker images para visualizar a imagem que acabou de ser renomeada para: test_image_copy.
Você pode ver que o nome da imagem é: test_image e test_image_copy. O ID da IMAGEM e o TAMANHO são exatamente os mesmos. É porque eles apontam para o mesmo arquivo de imagem, mas os apelidos são diferentes.
Isso também confirma que a tag docker mencionada tem uma função semelhante à cópia.

Apagar espelho
comando docker rmi ou docker image rm

use o comando: docker rmi test_image_copy remove um espelho chamado: Depois de test_image_copy, reutiliza imagens docker para ver todos os espelhos locais, espelho test_image_copy encontrado não na lista, indicando excluído com sucesso
Construir imagem
(1) Use o comando docker commit para enviar para a imagem do contêiner em execução
Por exemplo: Enviar de um contêiner em execução como uma imagem
Crie um contêiner chamado test_image e digite o comando test_image container
: docker run --rm --name = test_image -it test_image sh

Crie um arquivo no contêiner test_image e escreva o comando de conteúdo
: touch hello_world.txt && echo "Eu gosto do mundo do docker."> Hello_world.txt
Nesta
ocasião, um arquivo chamado hello_world.txt foi criado no diretório raiz do contêiner e escrito: Eu gosto do mundo do docker.
Abra uma nova janela de linha de comando, execute o seguinte comando para enviar o comando de imagem
: docker commit test_image test_image: hello_world
O
conteúdo retornado por este comando é o ID do contêiner
Use o comando docker image ls para ver a imagem
Você 
pode ver que a lista de espelhos locais tem um novo nome: test_image, TAG é: hello_world e o ID da IMAGEM é diferente do ID da IMAGEM do espelho com o mesmo nome.
(2) Use o comando docker build para construir um espelho a partir de um Dockerfile [a maneira mais importante e comum de construir um espelho]
O uso do Dockerfile para construir uma imagem tem as seguintes características:
1) Cada linha de comando do Dockerfile gerará uma camada de imagem independente e possui um ID exclusivo
2) Os comandos do Dockerfile são completamente transparentes.Vendo o conteúdo do Dockerfile, você pode saber como a imagem é construída passo a passo.
3) O Dockerfile é um texto simples, que é conveniente para armazenar no armazém de código junto com o código e fazer o gerenciamento de versão.
A seguir estão as instruções de operação comuns para Dockerfile

seguindo estas instruções para se familiarizar com um exemplo, o seguinte fragmento de código é um Dockerfile:
FROM centos:7
COPY nginx.repo /etc/yum.repos.d/nginx.repo
RUN yum install -y nginx
EXPOSE 80
ENV HOST=mynginx
CMD ["nginx","-g","daemon off;"]
Análise detalhada das instruções do Dockerfile:
[1] A primeira linha: FROM centos: 7
significa: é baseado em centos: 7 para construir uma imagem personalizada. Deve-se observar aqui que a primeira linha de cada Dockerfile deve começar com FROM, exceto para comentários.
[2], a segunda linha: COPY nginx.repo /etc/yum.repos.d/nginx.repo
significa: copie o arquivo local nginx.repo para o diretório /etc/yum.repos.d no contêiner. O arquivo nginx.repo é copiado aqui para adicionar a fonte de instalação do nginx.
[3]. A terceira linha: RUN yum install -y nginx
significa: execute o comando yum install -y nginx no contêiner para instalar o serviço nginx no contêiner. Depois de executar a terceira linha de comandos, o nginx no contêiner tem foi instalado.
[4] A quarta linha: EXPOSE 80
significa: declarar que o negócio no contêiner (nginx) usa a porta 80 para prestar serviços ao mundo exterior.
[5]. A quinta linha: ENV HOST = mynginx
significa: defina a variável de ambiente HOST = mynginx quando o contêiner for iniciado. Depois que o contêiner for iniciado, o valor da variável de ambiente HOST pode ser obtido como mynginx.
[6]. A sexta linha: CMD ["nginx", "- g", "daemon off;"]
significa: defina o comando de inicialização do contêiner, o formato do comando é um array json. O comando de inicialização do contêiner é definido como nginx e o parâmetro de inicialização -g'daemon off; 'de nginx é adicionado para fazer o nginx iniciar em primeiro plano.
O princípio de realização do espelhamento
Na verdade, uma imagem Docker é composta de uma série de camadas de imagem (camadas), cada uma das quais representa um envio durante o processo de construção da imagem. A seguir está um Dockerfile criado por uma imagem para ilustrar como a imagem é dividida em camadas.
FROM test_image
COPY test /tmp/test
RUN mkdir /tmp/testdir
O Dockerfile acima consiste em três etapas:
A primeira linha: crie uma camada de espelho baseada em test_image;
A segunda linha: copie o arquivo de teste da máquina para o espelho;
A terceira linha: Crie um diretório testdir na pasta / tmp.
Para verificar a estrutura de armazenamento da imagem, usamos o comando docker build para construir uma imagem no diretório onde o Dockerfile acima está localizado:
$ docker build -t test_image .
Aqui, o Docker usa o driver de arquivo overlay2, digite o diretório / var / lib / docker / overlay2 e use o comando tree. Para visualizar o arquivo de imagem gerado:
$ tree .
# 以下为 tree . 命令输出内容
|-- 3e89b959f921227acab94f5ab4524252ae0a829ff8a3687178e3aca56d605679
| |-- diff # 这一层为基础层，对应上述 Dockerfile 第一行，包含 busybox 镜像所有文件内容，例如 /etc,/bin,/var 等目录
... 此次省略部分原始镜像文件内容
| `-- link
|-- 6591d4e47eb2488e6297a0a07a2439f550cdb22845b6d2ddb1be2466ae7a9391
| |-- diff # 这一层对应上述 Dockerfile 第二行，拷贝 test 文件到 /tmp 文件夹下，因此 diff 文件夹下有了 /tmp/test 文件
| | `-- tmp
| | `-- test
| |-- link
| |-- lower
| `-- work
|-- backingFsBlockDev
|-- bec6a018080f7b808565728dee8447b9e86b3093b16ad5e6a1ac3976528a8bb1
| |-- diff # 这一层对应上述 Dockerfile 第三行，在 /tmp 文件夹下创建 testdir 文件夹，因此 diff 文件夹下有了 /tmp/testdir 文件夹
| | `-- tmp
| | `-- testdir
| |-- link
| |-- lower
| `-- work
...
Na estrutura de diretório acima, você pode ver que cada linha de comandos no Dockerfile gera uma camada de espelhamento e apenas dados incrementais são armazenados na pasta diff de cada camada, conforme mostrado na figura a seguir.

A estrutura em camadas torna a imagem do Docker muito leve. Cada camada tem um valor de ID exclusivo de acordo com o conteúdo da imagem. Quando a mesma camada de imagem está entre imagens diferentes, a camada de imagem pode ser compartilhada entre imagens diferentes. Efeito.
Resumindo:
A imagem do Docker é uma combinação de arquivo estático de gerenciamento hierárquico e a implementação da camada inferior da imagem depende do Union File System (UnionFS). Uma compreensão total do princípio de espelhamento pode nos ajudar a construir o melhor espelhamento na prática futura e também pode nos ajudar a entender melhor a relação entre contêineres e espelhamento.
Bem-vindo a prestar atenção na conta pública [The Way of Infinite Testing], responder a [receber recursos],
recursos de aprendizagem de programação Python
, automação de IU do APP da estrutura Python + Appium, Automação
da IU da Web da estrutura Python + Selenium,
API da estrutura Python + Unittest automação,
Recursos e códigos são enviados gratuitamente ~
Há um código QR da conta oficial no final do artigo, você pode digitalizá-lo no WeChat e segui-lo.
Observações: Minha conta pública pessoal foi oficialmente aberta, dedicada ao compartilhamento de tecnologia de teste, incluindo: teste de big data, teste funcional, desenvolvimento de teste, automação de interface de API, operação e manutenção de teste, teste de automação de IU, etc., público de pesquisa do WeChat conta: "Wuliang The Way of Testing" ou digitalize o código QR abaixo:
Dê atenção e vamos crescer juntos!