Um volume de dados é um diretório especial usado por contêineres e está localizado dentro do contêiner. O diretório do host pode ser montado no volume de dados. As modificações no volume de dados são imediatamente visíveis e os dados atualizados não afetarão o espelho, permitindo assim a migração de dados entre o host e o contêiner. O uso de volumes de dados é semelhante à operação de montagem de diretórios no Linux.

docker pull centos:7

#宿主机目录/var/www 挂载到容器中的/data1。
注意：宿主机本地目录的路径必须是使用绝对路径。如果路径不存在，Docker会自动创建相应的路径。
docker run -v /var/www:/data1 --name c1 -it centos:7 /bin/bash			#-v 选项可以在容器内创建数据卷
ls
echo "HELLO" > /data1/abc.txt
exit

#返回宿主机进行查看
cat  /var/www/abc.txt

#在宿主机写入数据
echo "world" > 123.txt
#进入容器查看挂载目录
docker exec -it c1 bash
cd /data1/
cat 123.txt

#宿主机共享目录可被多个容器挂载
docker run -it -v /var/www:/data2 --name c2 nginx:latest bash
cd /data2 
cat 123.txt
cat abc.txt

docker run -it -v /var/www:/data2:ro --name c3 nginx:latest bash
cd /data2
echo 123 > qwe.txt
bash: qwe.txt: Read-only file system

2. Contêiner de volume de dados

Se você precisar compartilhar alguns dados entre contêineres, a maneira mais fácil é usar um contêiner de volume de dados. O contêiner de volume de dados é um contêiner comum que fornece especificamente volumes de dados para outros contêineres montarem e usarem.

#创建一个容器作为数据卷容器
docker run --name c1 -v /data1 -v /data2 -it centos:7 /bin/bash
echo "this is web2" > /data1/abc.txt
echo "THIS IS WEB2" > /data2/ABC.txt

#使用 --volumes-from 来挂载 c1 容器中的数据卷到新的容器
docker run -it --volumes-from c1 --name c2 centos:7 /bin/bash
cat /data1/abc.txt
cat /data2/ABC.txt

2. Interconexão de contêineres (usando imagem centos)

A interconexão de contêineres consiste em estabelecer um túnel de comunicação de rede dedicado entre contêineres por meio do nome do contêiner. Simplificando, um túnel é estabelecido entre o contêiner de origem e o contêiner de recebimento, e o contêiner de recebimento pode ver as informações especificadas pelo contêiner de origem.

#创建并运行源容器取名web1
docker run -itd -P --name web1 centos:7 /bin/bash	
	
#创建并运行接收容器取名web2，使用--link选项指定连接容器以实现容器互联
docker run -itd -P --name web2 --link web1:web1 centos:7 /bin/bash			#--link 容器名:连接的别名

#进web2 容器， ping web1
docker exec -it web2 bash
ping web1

3. Criação de imagem Docker

Existem três maneiras de criar uma imagem: criar com base em uma imagem existente, criar com base em um modelo local e criar com base em um Dockerfile.

1. Crie com base na imagem existente

1.1 Primeiro inicie uma imagem e modifique-a no contêiner

docker create -it centos:7 /bin/bash
docker ps -a
#进入容器，安装apache服务
yum -y install httpd
#容器中没有root权限，无法使用systemctl管理服务
apachectl -D FOREGROUND   #使用apache前台启动命令启动服务
或
apachectl  #直接启动

1.2 Para enviar o container modificado como uma nova imagem, você precisa usar o número de ID do container para criar uma nova imagem.

docker commit -m "new" -a "centos-apache" 891853a88a38 centos7:httpd
#常用选项：
-m 说明信息；
-a 作者信息；
-p 生成过程中停止容器的运行。

docker images

docker run -itd --name c2 centos7:httpd apachectl -D FOREGROUND
rpm -qa httpd

2. Crie com base no modelo local

A imagem pode ser gerada importando o arquivo de modelo do sistema operacional. O modelo pode ser baixado do projeto de código aberto OPENVZ. O endereço de download é http://openvz.org/Download/template/precreated

2.1 Baixe o arquivo de modelo para gerar a imagem

wget http://download.openvz.org/template/precreated/debian-7.0-x86-minimal.tar.gz

#导入为镜像
cat debian-7.0-x86-minimal.tar.gz | docker import - debian:test

2.2 Exporte o contêiner local como um arquivo de modelo e importe-o para gerar uma imagem

docker export -o apache.tar 891853a88a38

docker import apache.tar -- apache:centos

3. Crie com base no Dockerfile

3.1 Sistema de arquivos de união (UnionFS)

UnionFS (Union File System): Union File System (UnionFS) é um sistema de arquivos hierárquico, leve e de alto desempenho. Ele suporta modificações no sistema de arquivos para serem sobrepostas camada por camada como um único envio, e também pode combinar diferentes diretórios são montados para o mesmo sistema de arquivos virtual. AUFS, OverlayFS e Devicemapper são todos tipos de UnionFS.
O sistema de arquivos Union é a base das imagens Docker. As imagens podem ser herdadas por meio de camadas. Com base na imagem base (sem imagem pai), várias imagens de aplicativos específicos podem ser produzidas.
Características: Carregue vários sistemas de arquivos ao mesmo tempo, mas do lado de fora, apenas um sistema de arquivos pode ser visto. O carregamento conjunto sobreporá cada camada de sistemas de arquivos, de modo que o sistema de arquivos final conterá todos os arquivos e diretórios subjacentes.
As camadas que vemos durante o download são os sistemas de arquivos conjuntos.

3.2 Princípio de carregamento de imagem

A imagem do Docker consiste, na verdade, em um sistema de arquivos camada por camada, e essa camada do sistema de arquivos é UnionFS.

bootfs inclui principalmente bootloader e kernel. O bootloader carrega principalmente o kernel. O sistema de arquivos bootfs será carregado quando o Linux for iniciado pela primeira vez.

A camada inferior da imagem Docker é bootfs.Esta camada é a mesma do nosso sistema Linux/Unix típico, incluindo o carregador de boot e o kernel. Quando o carregamento da inicialização for concluído, todo o kernel estará na memória. Neste momento, o direito de usar a memória foi transferido do bootfs para o kernel. Neste momento, o sistema também desinstalará o bootfs.

rootfs, em cima do bootfs. Contém diretórios e arquivos padrão como /dev, /proc, /bin, /etc, etc. em um sistema Linux típico. Rootfs refere-se a várias distribuições de sistemas operacionais, como Ubuntu, Centos, etc.

Podemos entender que não há nada no kernel no início. Se você executar um comando para baixar o debian, uma imagem base será adicionada ao kernel; então instale um emacs, e uma camada de imagem será sobreposta na imagem base ; e então instalar outro Apache irá sobrepor outra camada de imagem sobre as imagens. No final, eles se parecem com um sistema de arquivos, ou seja, o rootfs do contêiner. No sistema Docker, esses rootfs são chamados de imagens Docker. No entanto, neste momento, cada camada de rootfs é somente leitura e não podemos operá-la neste momento. Quando criamos um contêiner, ou seja, instanciamos uma imagem Docker, o sistema alocará uma camada vazia de rootfs de leitura e gravação em cima de uma ou mais camadas de rootfs somente leitura.

3.3 Por que o tamanho dos centos no Docker é de apenas 200M?

Porque para um sistema operacional simplificado, o rootfs pode ser muito pequeno e só precisa conter os comandos, ferramentas e bibliotecas mais básicos. Como a camada inferior usa diretamente o kernel do host, você só precisa fornecer o rootfs você mesmo. Pode-se ver que para diferentes distribuições Linux, bootfs é basicamente o mesmo, mas rootfs serão diferentes, então distribuições diferentes podem compartilhar bootfs.

3.4 Arquivo Docker

A imagem Docker é um sistema de arquivos especial, além de fornecer programas, bibliotecas, recursos, configuração e outros arquivos necessários para o tempo de execução do contêiner, ele também contém alguns parâmetros de configuração preparados para o tempo de execução (como volumes anônimos, variáveis de ambiente, usuários, etc.). . A imagem não contém dados dinâmicos e seu conteúdo não será alterado após ser construída.
A personalização do espelho é, na verdade, personalizar a configuração e os arquivos adicionados a cada camada. Se pudermos escrever os comandos para modificar, instalar, construir e operar cada camada em um script, e usar esse script para construir e personalizar a imagem, então os problemas de transparência e volume de construção da imagem serão resolvidos. Este script é o Dockerfile.
Dockerfile é um arquivo de texto que contém instruções (Instruções).Cada instrução constrói uma camada, portanto o conteúdo de cada instrução descreve como a camada deve ser construída. Com o Dockerfile, quando precisamos personalizar nossos próprios requisitos adicionais, precisamos apenas adicionar ou modificar instruções no Dockerfile e regenerar a imagem, eliminando o problema de digitar comandos.
Além de gerar imagens Docker manualmente, você pode usar o Dockerfile para gerar imagens automaticamente. Dockerfile é um arquivo composto por múltiplas instruções, cada uma correspondendo a um comando no Linux. O programa Docker lerá as instruções no Dockerfile para gerar a imagem especificada.
A estrutura do Dockerfile é dividida em quatro partes: informações básicas da imagem, informações do mantenedor, instruções de operação da imagem e instruções de execução quando o contêiner é iniciado. Dockerfile suporta uma instrução por linha, cada instrução pode carregar vários parâmetros e suporta comentários começando com "#".

3.4.1 Camadas da estrutura da imagem Docker

Uma imagem não é um único arquivo, mas consiste em múltiplas camadas. Na verdade, o contêiner adiciona uma camada de leitura e gravação no topo da imagem. Quaisquer alterações de arquivo feitas no contêiner em execução serão gravadas nessa camada de leitura e gravação. Se você excluir um contêiner, sua camada superior de leitura e gravação será excluída e as alterações no arquivo serão perdidas. Docker usa drivers de armazenamento para gerenciar o conteúdo de cada camada da imagem e a camada contêiner da camada de leitura e gravação.

Cada instrução no Dockerfile cria uma nova camada de imagem;
A camada de imagem será armazenada em cache e reutilizada;
Quando as instruções do Dockerfile são modificadas, os arquivos copiados mudam ou as variáveis especificadas ao construir a imagem são diferentes, o cache da camada de imagem correspondente se tornará inválido;
Se o cache de imagem de uma determinada camada se tornar inválido, o cache das camadas de imagem posteriores se tornará inválido;
As camadas de imagem são imutáveis. Se você adicionar um arquivo a uma determinada camada e excluí-lo na próxima camada, o arquivo ainda será incluído na imagem, mas não ficará visível no contêiner do Docker.

3.4.2Instruções comumente usadas para operações Dockerfile

1. DA imagem

Especifique a imagem base na qual a nova imagem se baseia. A primeira instrução deve ser uma instrução FROM. Cada imagem criada requer uma instrução FROM.

2. Nome do MANTENEDOR

Descreva as informações do mantenedor da nova imagem

3. Comando EXECUTAR

Execute o comando na imagem baseada e envie-o para a nova imagem

4.ENTRYPOINT ["Programa a ser executado", "Parâmetro 1", "Parâmetro 2"]

Defina o primeiro comando a ser executado quando o contêiner for iniciado e seus parâmetros.
Você pode substituir o conteúdo da instrução ENTRYPOINT na imagem usando o comando docker run --entrypoint.

5. CMD ["Programa a ser executado", "Parâmetro 1", "Parâmetro 2"]

O acima está no formato exec, formato shell: parâmetro de comando CMD 1 parâmetro 2 é
o comando ou script que é executado por padrão ao iniciar o contêiner. Dockerfile só pode ter um comando CMD. Se vários comandos forem especificados, apenas o último comando será executado.
Se um comando for especificado durante a execução do docker ou se houver ENTRYPOINT na imagem, o CMD será substituído.
O CMD pode fornecer parâmetros padrão para a instrução ENTRYPOINT.

6. Número da porta EXPOSIÇÃO

Especifique a porta a ser aberta quando a nova imagem for carregada no Docker

7. Valor da variável da variável de ambiente ENV

Defina o valor de uma variável de ambiente, que será usada por RUN subsequente

linxu PATH=$PATH:/opt
CAMINHO ENV $PATH:/opt

8. ADICIONAR arquivo de origem/diretório arquivo/diretório de destino

Copie o arquivo de origem para a imagem. O arquivo de origem deve estar no mesmo diretório que o Dockerfile ou deve ser uma URL.

Existem as seguintes precauções:
1. Se o caminho de origem for um arquivo e o caminho de destino terminar com /, o docker tratará o caminho de destino como um diretório e copiará o arquivo de origem para o diretório.
Se o caminho de destino não existir, ele será criado automaticamente.

2. Se o caminho de origem for um arquivo e o caminho de destino não terminar com /, o docker tratará o caminho de destino como um arquivo.
Se o caminho de destino não existir, um arquivo será criado com o nome do caminho de destino e o conteúdo será o mesmo do arquivo.
Se o arquivo de destino for um arquivo existente, ele será substituído pelo arquivo de origem. claro, apenas o conteúdo será substituído e o nome do arquivo ainda será o nome do arquivo de destino.
Se o arquivo de destino for realmente um diretório existente, o arquivo de origem será copiado para esse diretório. Observe que neste caso é melhor encerrar a exibição com / para evitar confusão.

3. Se o caminho de origem for um diretório e o caminho de destino não existir, o docker criará automaticamente um diretório com o caminho de destino e copiará os arquivos no diretório do caminho de origem.
Se o caminho de destino for um diretório existente, o docker copiará os arquivos do diretório do caminho de origem para o diretório.

4. Se o arquivo de origem for um arquivo compactado (arquivo compactado), o docker o descompactará automaticamente.
Os recursos de download e descompactação de URL não podem ser usados juntos. Qualquer arquivo compactado copiado via URL não será descompactado automaticamente.

9.COPIAR arquivo de origem/diretório arquivo/diretório de destino

Copie apenas os arquivos/diretórios no host local para o local de destino. Os arquivos/diretórios de origem devem estar no mesmo diretório que o Dockerfile.

10. VOLUME ["Diretório"]

Crie um ponto de montagem no contêiner

11. Nome de usuário/UID do USUÁRIO

Especifique o usuário ao executar o contêiner

12.CaminhoWORKDIR

Especifique o diretório de trabalho para RUN, CMD, ENTRYPOINT subsequentes

13. Comando ONBUILD

Especifique o comando a ser executado quando a imagem gerada for usada como imagem base.
Quando a instrução ONBUILD é adicionada a um Dockerfile, a instrução não terá um impacto substancial no uso do Dockerfile para construir uma imagem (como a imagem A).
Mas ao escrever um novo Dockerfile para construir uma imagem baseada na imagem A (por exemplo, a imagem B), a instrução ONBUILD no Dockerfile que constrói a imagem A terá efeito. No processo de construção da imagem B, ela irá serão executadas primeiro. Somente as instruções especificadas pela instrução ONBUILD serão executadas antes de outras instruções.

Nota: Se você tiver outros dockerfiles em produção, estude-os e leia-os você mesmo, caso contrário, você terá que pagar pelas consequências.

14.AGR

Defina os parâmetros adicionados ao compilar a imagem

Variáveis de ambiente definidas usando a diretiva ENV sempre substituirão a diretiva ARG com o mesmo nome, independentemente da ordem.

15. VERIFICAÇÃO DE SAÚDE

Exame de saúde

Ao escrever um Dockerfile, há um formato estrito a seguir :

A primeira linha deve utilizar a instrução FROM para indicar o nome da imagem em que se baseia;
Em seguida, use a instrução MAINTAINER para descrever as informações do usuário que mantêm a imagem;
Depois, há instruções relacionadas às operações de espelhamento, como a instrução RUN. Cada vez que um comando é executado, uma nova camada é adicionada à imagem base.
Finalmente, use a instrução CMD para especificar a operação de comando a ser executada ao iniciar o contêiner.

3.5 Caso Dockerfile

3.5.1 Estabelecer um diretório de trabalho

mkdir  /opt/apache
cd  /opt/apache

vim Dockerfile
#基于的基础镜像
FROM centos:7
#维护镜像的用户信息
MAINTAINER this is apache image 
#镜像操作指令安装apache软件
RUN yum -y install httpd
#开启 80 端口
EXPOSE 80
#复制配置文件到容器
COPY httpd.conf /etc/httpd/conf/httpd.conf

##启动apache服务
CMD ["/usr/sbin/apachectl",""-D", "FOREGROUND"]

##方法二：
#将执行脚本复制到镜像中
ADD run.sh /run.sh
RUN chmod 755 /run.sh
#启动容器时执行脚本
CMD ["/run.sh"]


准备执行脚本
vim run.sh
#!/bin/bash
rm -rf /run/httpd/*							#清理httpd的缓存
/usr/sbin/apachectl -D FOREGROUND			#指定为前台运行
#因为Docker容器仅在它的1号进程（PID为1）运行时，会保持运行。如果1号进程退出了，Docker容器也就退出了。

3.5.2 Gerar imagem

docker build -t httpd:centos .   		#注意别忘了末尾有"."

3.5.3 Preparar páginas do site

mkdir /opt/apache/html
cd /opt/apache/html
echo "this is test web" > index.html

3.5.4 Novo contêiner em execução de imagem

#将容器/var/www/html与宿主机/opt/apache/html目录共享
docker run -d -P -v /opt/apache/html:/var/www/html httpd:centos

#验证
curl http://192.168.88.60:32769

Gerenciamento de dados do Docker, interconexão de contêineres e criação de imagens

1. Gerenciamento de dados

1. Volume de dados