Um volume de dados é um diretório especial usado por contêineres, localizado dentro do contêiner. O diretório da máquina host pode ser montado no volume de dados, e a operação de modificação no volume de dados pode ser vista imediatamente, e a atualização dos dados não afetará a imagem, de modo a realizar a migração de dados entre a máquina host e o recipiente. O uso de volumes de dados é semelhante à operação de montagem em diretórios no Linux.

docker pull centos:7

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

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

1.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 volumes de dados para outros contêineres montarem e usarem.

#创建一个容器作为数据卷容器
docker run --name web2 -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 来挂载 web2 容器中的数据卷到新的容器
docker run -it --volumes-from web2 --name web3 centos:7 /bin/bash
cat /data1/abc.txt
cat /data2/ABC.txt

1.3 Mapeamento de portas

Ao iniciar o contêiner, se a porta correspondente não for especificada, o serviço dentro do contêiner não poderá ser acessado pela rede fora do contêiner. O mecanismo de mapeamento de porta fornece serviços no contêiner para acesso à rede externa. Em essência, ele mapeia a porta do host para o contêiner, para que a rede externa possa acessar os serviços no contêiner acessando a porta do host.

docker run -d --name test1 -P nginx					#随机映射端口（从32768开始）

docker run -d --name test2 -p 43000:80 nginx		#指定映射端口

docker ps -a
CONTAINER ID   IMAGE     COMMAND                  CREATED          STATUS          PORTS                   NAMES
9d3c04f57a68   nginx     "/docker-entrypoint.…"   4 seconds ago    Up 3 seconds    0.0.0.0:43000->80/tcp   test2
b04895f870e5   nginx     "/docker-entrypoint.…"   17 seconds ago   Up 15 seconds   0.0.0.0:49170->80/tcp   test1

1.4 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 de nomes de contêineres. Simplificando, um túnel será estabelecido entre o contêiner de origem e o contêiner de recebimento, e o contêiner de recebimento poderá 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

2. Criação de imagem Docker (três modos)

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

2.1 Criar com base em uma imagem existente

(1) Primeiro inicie um espelho e faça alterações no contêiner

docker create -it centos:7 /bin/bash

(2) Em seguida, envie o contêiner modificado como uma nova imagem e você precisará usar o número de ID do contêiner para criar uma nova imagem

docker commit -m "new" -a "centos" 000550eb36da centos:test

Opções comuns:

-m informações de descrição;

-uma informação do autor;

-p Interrompe a execução do contêiner durante a construção.

2.2 Criar 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

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.3 Criado com base no Dockerfile

2.3.1 Sistema de Arquivos Union (UnionFS)

UnionFS (Union File System): Union File System (UnionFS) é um sistema de arquivos em camadas, leve e de alto desempenho, que suporta a modificação do sistema de arquivos como um envio para sobrepor camada por camada, enquanto diferentes O diretório é montado sob o mesmo sistema de arquivos virtual. AUFS, OverlayFS e Devicemapper são todos tipos de UnionFS.

O sistema de arquivos Union é a base para 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 criadas.

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á os sistemas de arquivos de todas as camadas, de modo que o sistema de arquivos final conterá todos os arquivos e diretórios subjacentes.

2.3.2 Princípio de carregamento de imagem

A imagem do Docker é, na verdade, composta de sistemas de arquivos camada por camada , e essa camada de sistemas de arquivos é UnionFS.

Bootfs inclui principalmente bootloader e kernel. O bootloader é usado principalmente para guiar e carregar o kernel. Quando o Linux inicia, ele carrega o sistema de arquivos bootfs.

Na parte inferior da imagem do Docker está o bootfs, que é igual ao 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. Ele contém diretórios e arquivos padrão como /dev, /proc, /bin, /etc em um sistema Linux típico. Rootfs é uma variedade de distribuições de sistemas operacionais diferentes, como Ubuntu, Centos e assim por diante.

Podemos entender que não há nada no kernel no início, e um comando é usado para baixar o debian, e uma imagem base será adicionada ao kernel neste momento; e então um emacs será instalado, e uma imagem será sobreposta na imagem base; e então outra será instalada. O 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 a imagem do Docker, o sistema alocará uma camada de rootfs de leitura e gravação vazia em cima de uma ou mais camadas de rootfs somente leitura.

2.3.3 Arquivo Docker

A imagem Docker é um sistema de arquivos especial. Além de fornecer programas, bibliotecas, recursos, configuração e outros arquivos exigidos pelo tempo de execução do contêiner, ele também contém alguns parâmetros de configuração preparados para tempo de execução (como volumes anônimos, variáveis de ambiente, usuários, etc). As imagens não contêm dados dinâmicos e seu conteúdo não é alterado após serem construídas.

A customização da imagem consiste, na verdade, em customizar a configuração e os arquivos adicionados por cada camada. Se pudermos escrever os comandos de modificação, instalação, construção e operação de cada camada em um script, e usar esse script para construir e customizar 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 uma série de instruções (Instruction), cada instrução constrói uma camada, portanto o conteúdo de cada instrução é descrever 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, evitando o trabalho de digitar comandos.

Além de gerar imagens Docker manualmente, você pode usar o Dockerfile para gerar imagens automaticamente. Um Dockerfile é um arquivo composto por várias instruções, cada uma correspondendo a um comando no Linux, e o programa Docker lerá as instruções no Dockerfile para gerar uma 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 o uso de comentários começando com "#".

2.3.4 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 na parte superior da imagem, e quaisquer alterações de arquivo feitas no contêiner em execução serão gravadas nessa camada de leitura e gravação. Se o contêiner for excluído, sua camada superior de leitura e gravação também 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 legível e gravável.

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, o arquivo copiado muda 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 espelhado de uma determinada camada for inválido, o cache da camada espelhada posterior será inválido;

As camadas de imagem são imutáveis. Se você adicionar um arquivo em uma 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.

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

(1) DA imagem

Especifica a imagem base na qual a nova imagem se baseia. A primeira instrução deve ser uma instrução FROM, e uma instrução FROM é necessária para cada imagem criada

(2) Nome do MANUTENTOR

Indica as informações do mantenedor da nova imagem

(3) comando EXECUTAR

Execute o comando no espelho base e confirme com o novo espelho cd cp

(4) ENTRYPOINT ["programa a ser executado", "parâmetro 1", "parâmetro 2"]

Defina o comando e seus parâmetros para serem executados primeiro quando o contêiner for iniciado. O conteúdo da diretiva ENTRYPOINT na imagem pode ser substituído usando o comando docker run --entrypoint.

PONTO DE ENTRADA ["rm", "-rf", "/*"]

(5) CMD ["programa a ser executado", "parâmetro 1", "parâmetro 2"]

O acima é o formulário exec, formato shell: parâmetro de comando CMD 1 parâmetro 2 O comando ou script executado por padrão ao iniciar o contêiner, Dockerfile pode ter apenas 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 um ENTRYPOINT na imagem, o CMD será substituído. O CMD pode fornecer parâmetros padrão para o comando ENTRYPOINT.

(6) Número da porta EXPOSIÇÃO

Especifique a porta EXPOSE 8090 para abrir quando a nova imagem for carregada no Docker

(7) Variável de ambiente ENV

Valor da variável 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 o espelho, o arquivo de origem deve estar localizado no mesmo diretório do Dockerfile ou em uma URL com os seguintes cuidados:

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 este diretório. Se o caminho de destino não existir, ele será criado automaticamente. /home/ky26/zhaichen.txt /home/ky26/

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 de origem; se o arquivo de destino existir, ele será substituído pelo arquivo de origem, é claro, apenas o conteúdo é substituído e o nome do arquivo ainda é 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. AB /home/ky26 /home/ky26

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 este 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. Quaisquer arquivos compactados copiados por URL não serão descompactados 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) Caminho WORKDIR /home

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

(13) Comando ONBUILD

Especifica 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 uma imagem A). Mas ao escrever um novo Dockerfile para construir um espelho baseado no espelho A (como um espelho B), o comando ONBUILD no Dockerfile que constrói o espelho A terá efeito neste momento. No processo de construção do espelho B, ele será executado primeiro. As instruções especificadas pela instrução ONBUILD são executadas antes de outras instruções serem executadas.

OBuild rm -rf /*

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

(14) Exame de saúde HEALTHCHECK

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

A primeira linha deve utilizar o comando FROM para indicar o nome da imagem em que se baseia;

Em seguida, use o comando MAINTAINER para descrever as informações do usuário para manter a imagem;

Depois, há instruções relacionadas às operações de espelhamento, como a instrução RUN. Cada vez que uma instrução é executada, uma nova camada é adicionada à imagem base.

Por fim, use a diretiva CMD para especificar a ação do comando a ser executada quando o contêiner for iniciado.

3. Caso Dockerfile

#建立工作目录
mkdir  /opt/apache
cd  /opt/apache

vim Dockerfile
#基于的基础镜像
FROM centos:7
#维护镜像的用户信息
MAINTAINER this is apache image <hmj>
#镜像操作指令安装apache软件
RUN yum -y update
RUN yum -y install httpd
#开启 80 端口
EXPOSE 80
#复制网站首页文件
ADD index.html /var/www/html/index.html
//方法一：
#将执行脚本复制到镜像中
ADD run.sh /run.sh
RUN chmod 755 /run.sh
#启动容器时执行脚本
CMD ["/run.sh"]
//方法二：
ENTRYPOINT [ "/usr/sbin/apachectl" ]
CMD ["-D", "FOREGROUND"]


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

//准备网站页面
echo "this is test web" > index.html

//生成镜像
docker build -t httpd:centos .   		#注意别忘了末尾有"."

//新镜像运行容器
docker run -d -p 1216:80 httpd:centos

//测试
http://192.168.80.10:1216/


########如果有网络报错提示########
[Warning] IPv4 forwarding is disabled. Networking will not work.

解决方法：
vim /etc/sysctl.conf
net.ipv4.ip_forward=1

sysctl -p
systemctl restart network
systemctl restart docker

Por que o tamanho dos centos no Docker é de apenas 200 milhões?

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

Gerenciamento de dados Docker e Dockerfile

1. Gerenciamento de dados Docker

1.1 Volume de dados