Docker Dockerfile

O que é Dockerfile?

O Dockerfile é um arquivo de texto usado para construir espelhos, que contém uma série de instruções e descrições necessárias para construir espelhos.

Personalizar espelho com Dockerfile

Aqui apenas explicamos como executar o arquivo Dockerfile para personalizar um espelho, a explicação detalhada das instruções no arquivo Dockerfile será introduzida na próxima seção, aqui você só precisa saber o fluxo de construção.

1E aqui está um exemplo de como personalizar um espelho nginx (o espelho construído conterá um /usr/share/nginx/html/index.html arquivo

Em um diretório vazio, crie um arquivo chamado Dockerfile e adicione o seguinte conteúdo ao arquivo:

FROM nginx
RUN echo 'Este é um espelho nginx construído localmente' >　/usr/share/nginx/html/index.html

2Função das instruções FROM e RUN

FROM:Todos os espelhos personalizados são baseados no espelho FROM, aqui o nginx é o espelho base para a personalização necessária. As operações subsequentes são baseadas no nginx.

RUN:Usado para executar os comandos de linha que seguem. Existem dois formatos:

Formato shell:

RUN <comando de linha>
# <comando de linha> é equivalente ao comando shell operado no terminal.

Formato exec:

RUN ["arquivo executável", "parâmetro1", "parâmetro2"]
# Exemplo:
# RUN ["./test.php", "dev", "offline"] equivalente a RUN ./test.php dev offline

Atenção:Cada instrução do Dockerfile executada uma vez criará uma camada nova no docker. Portanto, camadas sem significado em excesso podem causar o espelho se expandir muito. Por exemplo:

FROM centos
RUN yum install wget
RUN wget　-O redis.tar.gz "http://download.redis.io/releases/redis-5.0.3.tar.gz"
RUN tar　-xvf redis.tar.gz
A execução acima criará　3　Camada de espelho. Pode ser simplificada para o seguinte formato:
FROM centos
RUN yum install wget \\
　　　　&& wget　-O redis.tar.gz "http://download.redis.io/releases/redis-5.0.3.tar.gz" \\
　　　　&& tar　-xvf redis.tar.gz

Como acima, conecte os comandos com o símbolo &&, assim, após a execução, só será criado 1 Camada de espelho.

Iniciar a construção do espelho.

Execute a ação de construção no diretório onde o arquivo Dockerfile está armazenado.

A seguir, um exemplo de construção de um nginx:v3(Nome do espelho: etiqueta do espelho).

Nota: O último ponto '.' representa o caminho de contexto da execução atual, que será介绍的 na próxima seção.

$　docker　build　-t　nginx:v3　.

Como mostrado acima, isso indica que a construção foi bem-sucedida.

Caminho de contexto

Na seção anterior, mencionamos que o último ponto '.' do comando é o caminho de contexto, então o que é o caminho de contexto?

$　docker　build　-t　nginx:v3　.

: O caminho de contexto é o caminho que o Docker usa para construir imagens. Às vezes, queremos usar arquivos da nossa máquina (por exemplo, copiar), quando o comando docker build obter essa rota, ele empacotará todo o conteúdo dessa rota.

Análise: Devido ao modo de execução do Docker ser C/S. Nossa máquina é C, o motor Docker é S. O processo de construção real é concluído no motor Docker, então neste momento, não podemos usar os arquivos da nossa máquina. Isso requer que os arquivos do diretório especificado na nossa máquina sejam empacotados e fornecidos ao motor Docker para uso.

Se o último parâmetro não for especificado, o caminho de contexto padrão é o local do Dockerfile.

Atenção: Não coloque arquivos inúteis no caminho de contexto, pois esses arquivos serão enviados ao motor Docker junto com o pacote, e um grande número de arquivos pode causar a lentidão do processo.

Explicação detalhada

COPY

Comando de cópia, copia arquivos ou diretórios do diretório de contexto para o caminho especificado no container.

Formato：

COPY　[--chown=<user>:<group>]　<caminho de origem1>...　　<caminho de destino>
COPY　[--chown=<user>:<group>]　["<caminho de origem1>",...　　"<caminho de destino>"]

[--chown=<user>:<group>]: Parâmetro opcional, permite que o usuário altere o proprietário e o grupo do arquivo copiado para dentro do container.

<caminho de origem>: O arquivo de origem ou diretório de origem, aqui pode ser uma expressão de coringa, as regras de coringa devem atender às regras do Go filepath.Match. Por exemplo:

COPY　hom*　/mydir/
COPY　hom?.txt　/mydir/

<caminho de destino>: O caminho especificado dentro do container, este caminho não precisa ser criado previamente, se o caminho não existir, ele será criado automaticamente.

ADD

A forma de uso do comando ADD é idêntica à do COPY (oficialmente recomendado usar COPY). As funcionalidades também são semelhantes, mas existem diferenças conforme abaixo:

• As vantagens do ADD: Quando o arquivo <arquivo de origem> é um arquivo comprimido tar, o formato de compressão é gzip, bzip.2 E no caso do xz, ele copiará e descompactará automaticamente para <caminho de destino>.

• As desvantagens do ADD: Sem descompactar, não é possível copiar arquivos comprimidos tar. Pode invalidar o cache de construção de imagens, tornando a construção de imagens mais lenta. A decisão de usá-lo pode ser baseada na necessidade de descompactação automática.

CMD

Semelhante à instrução RUN, usada para executar programas, mas os dois são executados em diferentes momentos:

• CMD é executado no docker run.

• RUN é executado no docker build.

Função：Especifica o programa padrão a ser executado pelo container ao iniciar. Quando o programa especificado pelo comando CMD termina, o container também termina. O programa especificado pelo comando CMD pode ser coberto pelo programa especificado nos parâmetros da linha de comando do docker run.

Atenção：Se houver várias instruções CMD no Dockerfile, apenas a última será válida.

Formato：

CMD <comando shell>　
CMD ["<arquivo ou comando executável>","<param1>","<param2>,...]　
CMD ["<param1>","<param2>",...] # Esse formato é para fornecer parâmetros padrão para o programa especificado pela instrução ENTRYPOINT

Recomenda-se usar o segundo formato, que é mais claro no processo de execução. O primeiro formato também será automaticamente convertido para o segundo formato durante a execução e o arquivo executável padrão é sh.

ENTRYPOINT

semelhante ao comando CMD, mas não será coberto pelos parâmetros da linha de comando do docker run especificados e esses parâmetros serão passados como argumentos para o comando especificado pelo ENTRYPOINT.

Mas, se você usar docker run com --A opção entrypoint substitui o comando CMD especificado.

Vantagens：Ao executar docker run, você pode especificar os parâmetros necessários para o ENTRYPOINT.

Atenção：Se houver várias instruções ENTRYPOINT no Dockerfile, apenas a última será válida.

Formato：

ENTRYPOINT ["<executável>","<param1>","<param2>,...]

Pode ser usado em conjunto com o comando CMD: geralmente o CMD é usado para parâmetros variáveis, aqui o CMD está equivalendo a passar parâmetros para o ENTRYPOINT, que será mencionado a seguir.

Exemplo:

Pressupondo-se que o Dockerfile já tenha construído o ícone nginx:test:

FROM nginx
ENTRYPOINT ["nginx", "-c"] # parâmetros fixos
CMD ["/etc/nginx/nginx.conf"] # parâmetros variáveis

1、não passando parâmetros

$ docker run nginx:test

O container executará os seguintes comandos por padrão, iniciando o processo principal.

nginx　-c　/etc/nginx/nginx.conf

2、passando parâmetros

$ docker run nginx:test　-c　/etc/nginx/new.conf

O container executará os seguintes comandos por padrão, iniciando o processo principal (/etc/nginx/new.conf: pressupondo-se que o arquivo já existe dentro do container)

nginx　-c　/etc/nginx/new.conf

ENV

Configurar variáveis de ambiente, após definir as variáveis de ambiente, você pode usar essa variável de ambiente em instruções posteriores.

Formato：

ENV　<key>　<value>
ENV　<key1>=<value1>　<key2>=<value2>...

O exemplo a seguir define NODE_VERSION = 7.2.0 ， que pode ser referenciado em instruções posteriores:

ENV　NODE_VERSION　7.2.0
RUN　curl　-SLO "https://nodejs.org/dist/v$NODE_VERSION/node-v$NODE_VERSION-linux-x64.tar.xz"　\
　　&&　curl　-SLO "https://nodejs.org/dist/v$NODE_VERSION/SHASUMS256.txt.asc"

ARG

Parâmetros de construção, com a mesma função que ENV. No entanto, o escopo é diferente. O ambiente variável configurado por ARG é válido apenas dentro do Dockerfile, ou seja, apenas durante o processo de construção do docker build, não existe esse ambiente variável na imagem construída.

O comando de construção docker build pode usar --build-arg <nome do parâmetro>=<valor> para substituir.

Formato：

ARG <nome do parâmetro>[=<valor padrão>]

VOLUME

Definir volume de dados anônimo. Se esquecer de montar o volume de dados ao inicializar o container, será montado automaticamente no volume anônimo.

Função:

• Evitar que dados importantes sejam perdidos devido ao reinício do container, o que é mortal.

• Evitar que o container continue a crescer.

Formato：

VOLUME ["<caminho1>",　"<caminho2>"...]
VOLUME <caminho>

No momento da inicialização do container docker run, podemos usar -v parâmetro para modificar o ponto de montagem.

EXPOSE

Apenas declara a porta.

Função:

• Ajudar o usuário da imagem a entender o porto de serviço do守护进程 para facilitar a configuração do mapeamento.

• Ao usar a mapeamento de porta aleatória durante a execução, ou seja, docker run -Ao usar a mapeamento de porta aleatória ao executar, é automaticamente mapeado o porta exposto.

Formato：

EXPOSE <porta1>　[<porta2>...]

WORKDIR

Especificar o diretório de trabalho. O diretório de trabalho especificado por WORKDIR existirá em cada camada da construção da imagem. (O diretório de trabalho especificado por WORKDIR deve ser criado previamente).

Em cada RUN comando no processo de construção de imagens do docker, uma nova camada é criada. Apenas o diretório criado por WORKDIR continuará a existir.

Formato：

WORKDIR <caminho do diretório de trabalho>

USER

Usado para especificar o usuário e o grupo de usuários que executarão os comandos subsequentes, neste caso, apenas alternar o usuário que executará os comandos subsequentes (o usuário e o grupo de usuários devem existir previamente).

Formato：

USER　<Nome do Usuário>[:<Grupo do Usuário>]

HEALTHCHECK

Usado para especificar um programa ou comando para monitorar o estado de execução do serviço de container docker.

Formato：

HEALTHCHECK　[Opções]　CMD　<Comando>：Define o comando para verificar o estado de saúde do container
HEALTHCHECK　NONE：Se o ímagem base tiver instruções de verificação de saúde, esta linha pode desativar essas instruções de verificação de saúde
HEALTHCHECK　[Opções]　CMD　<Comando>　:　Os comandos seguidos por CMD podem ser usados, consulte o uso de CMD.

ONBUILD

Usado para atrasar a execução de comandos de construção. Em termos simples, os comandos especificados por ONBUILD no Dockerfile não serão executados na construção dessa imagem (supondo que a imagem seja test-build). Quando um novo Dockerfile usar a imagem construída anteriormente FROM test-build, isso é executado quando o Dockerfile é construído para um novo ímagem, o test será executado-Os comandos ONBUILD especificados no Dockerfile de build.

Formato：

ONBUILD　<Outras Instrução>