Para ter uma compreensão preliminar do Dockerfile, vamos primeiro examinar um exemplo simples
Primeiro, extraímos uma imagem mysql: 5.7 do warehouse espelho, iniciamos o contêiner e entramos no contêiner, mas quando queremos pingar um determinado ip nele, descobrimos que não há comando ping
Se por acaso tivermos essa necessidade, seria muito constrangedor. O que pode ser feito para resolvê-la?
Podemos reconstruir uma nova imagem com base no mysql: 5.7 e adicionar o que quisermos; vamos dar uma olhada no conteúdo do seguinte Dockerfile
FROM mysql:5.7
RUN apt-get update \
&& apt install iputils-ping -y
RUN apt-get install vim -y
Aqui nós instalamos as ferramentas ping e vim (observe que você precisa ver as informações de lançamento através de cat / etc / issue, e os comandos para as ferramentas de instalação são diferentes para versões diferentes)
Vamos começar a construir com este Dockerfile :docker build -t mysql:mumu .
Podemos ver que o processo de compilação é dividido em três etapas, que correspondem aos três comandos de nosso Dockerfile.
Depois que a compilação for concluída, podemos ver que ele é 53 MB maior que mysql: 5,7
Depois que a imagem é reproduzida, podemos iniciar o contêiner:
docker run -p 3306:3306 --name mysql -v /data/mysql/data:/var/lib/mysql -e MYSQL_ROOT_PASSWORD=123456 -d mysql:mumu
Depois de iniciar, podemos fazer ping em www.baidu.com, e podemos ver que nossas ferramentas estão normalmente disponíveis
Por meio do caso acima, temos uma compreensão preliminar do
Dockerfile : Dockerfile é um Dockerfile usado para construir um espelho.
Uma instrução corresponde a uma etapa.
Por meio do Dockerfile e do espelho básico, podemos construir um espelho que esteja mais de acordo com nossos requisitos.
Usamos outro Dockerfile para entender o conceito de camadas de imagem:
FROM debian
RUN apt-get update && apt-get -y -f install emacs
RUN apt-get update && apt-get -y -f install apache2
Cada instrução no Dockerfile é uma nova camada, camada por camada e, finalmente, constitui a imagem que queremos
Por exemplo, o comando acima criará três camadas, cada camada registra apenas as alterações feitas nesta camada, e estas são somente leitura. Quando um contêiner é iniciado, o Docker adiciona uma camada de leitura e gravação na parte superior, que geralmente é chamada de camada de contêiner.
Cada container possui sua própria camada de container independente, então a modificação terá apenas sua própria camada de container, e não haverá impacto entre os containers.Assim, diferentes containers podem compartilhar uma camada de espelhamento.
Por que usar uma estrutura hierárquica?
A maior vantagem é compartilhar recursos. Por exemplo, muitos espelhos são construídos a partir de espelhos de base. Depois de salvar uma cópia no disco, ela pode ser compartilhada por todos os espelhos.
Mas, por exemplo, algumas pessoas têm dúvidas: Se este contêiner derivado de imagem alterar os arquivos nele, por exemplo, se um arquivo em / opt for modificado, o / opt de outros contêineres também será modificado?
Mencionamos acima que a camada de contêiner é independente de cada contêiner. Os dados modificados serão armazenados diretamente na camada de contêiner, e a camada de imagem permanecerá inalterada.
Introdução às instruções do Dockerfile
FROM: Especifique a imagem base, deve ser o primeiro comando
FROM:
FROM @
Exemplo:
FROM elasticsearch: 7.6.0
Nota: tag e resumo são opcionais, se estiverem vazios, a última versão da imagem base será usada automaticamente
MAINTAINER: Mantenedor informações
MAINTAINER
exemplo:
MAINTAINER mumu
MAINTAINER [email protected]
MAINTAINER [email protected]
RUN: O comando executado ao construir a imagem
RUN
RUN ["executável", "param1", "param2"]
Exemplo:
RUN atualização do apk
RUN ["./test", "dev", "offline"]
Nota: Criado pelo Instrução RUN A imagem intermediária será armazenada em cache e usada na próxima compilação. Se não quiser usar essas imagens de cache, você pode usar o parâmetro –no-cache ao construir a compilação, como: docker build --no-cache
ADD: Adicionar arquivos locais para o recipiente, arquivos tar será descompactado automaticamente (recursos comprimido de rede não será descomprimido), você pode acessar recursos de rede, similar ao wget
ADD
exemplo:
ADD mumu.txt / mydir /
Nota: COPY: em semelhante função ADD, mas não descompacta automaticamente o arquivo, nem pode acessar recursos de rede
CMD: Chamado após a construção do contêiner, ou seja, é chamado quando o contêiner é iniciado.
CMD ["executável", "param1", "param2"]
CMD ["param1", "param2"]
Comando CMD param1 param2 (comando interno do shell)
Exemplo:
CMD ["java", "-jar", "/ opt / server / product.jar "]
Nota: CMD é diferente de RUN. CMD é usado para especificar o comando a ser executado quando o contêiner é iniciado e RUN é usado para especificar o comando a ser executado quando a imagem é construída; cada Dockerfile pode ter apenas um comando CMD Se mais de um for especificado, apenas o último será executado.Se o usuário especificar um comando de execução ao iniciar o contêiner, o comando especificado pelo CMD será sobrescrito.
ENTRYPOINT: Configure o container para torná-lo executável.Com CMD, a aplicação pode ser omitida e apenas parâmetros são usados.
ENTRYPOINT ["executável", "param1", "param2"]
Comando ENTRYPOINT param1 param2 (comando interno do shell)
Exemplo:
ENTRYPOINT ["/ bin / echo", "hello"]
Nota: ENTRYPOINT é muito semelhante ao CMD, mas o docker roda execução O comando não substituirá ENTRYPOINT, mas se docker run usar a opção -entrypoint, o parâmetro desta opção pode ser usado como o programa a ser executado para substituir o programa especificado pela instrução ENTYPPOINT e quaisquer parâmetros especificados na docker run O comando será tratado como parâmetro Passe para ENTRYPOINT novamente; apenas um comando ENTRYPOINT é permitido no DockerFile e se mais de um for especificado, o anterior será substituído e apenas o último será executado.
Quando ENTRYPOINT é especificado, o significado do CMD muda, não é mais um comando de execução direta, mas o conteúdo do CMD é passado como parâmetro para a instrução ENTRYPOINT, ou seja, se tornará "" quando for realmente executado.
Não é um pouco confuso aqui, qual é a conexão entre CMD e ENTRYPOINT?
No Dockerfile, pelo menos um CMD e ENTRYPOINT deve ser especificado;
quando Docker é usado como um programa executável, ENTRYPOINT deve ser usado para configuração;
CMD pode ser usado como o parâmetro padrão de ENTRYPOINT ou como o comando padrão do Docker;
CMD pode ser transmitido por docker run Cobertura de parâmetro;
os parâmetros transmitidos por docker run serão anexados a ENTRYPOINT, desde que o formato exec seja usado
Por exemplo, o Dockerfile é o seguinte
FROM nginx
ENTRYPOINT ["nginx", "-c"]
CMD ["/etc/nginx/nginx.conf"]
Quando habilitamos nginx: docker run nginx: mumu é
equivalente a executar o seguinte comando: nginx -c /etc/nginx/nginx.conf
Quando alteramos o comando de inicialização para: docker run nginx: mumu -c /etc/nginx/new.conf é
equivalente a executar o seguinte comando: nginx -c / etc / nginx / new. conf
LABEL: Usado para adicionar metadados à imagem espelhada
LABEL == =
Exemplo:
LABEL version = “1.0” descriptioin = “Este é um serviço da Mumu”
Nota: Ao usar LABEL para especificar metadados, um LABEL pode especificar uma ou mais partes de metadados, separados por espaços. Recomenda-se especificar todos os metadados por meio de um comando LABEL para evitar a geração de muitas imagens intermediárias.
ENV: Definir a variável de ambiente
ENV só pode definir uma variável de cada vez, o conteúdo após a chave será considerado como valor
ENV = ... Múltiplas variáveis podem ser definidas, cada variável é um par de valor-chave "=", se contiver espaços Caracteres especiais, você pode usar \ para escapar
Exemplo:
ENV nome de usuário admin
ENV senha 123456
ENV porta = 3306
EXPOSE: Especifique a porta para interação externa
EXPOSE […]
Exemplo:
EXPOSE 80 443
EXPOSE 11221 / tcp 11221 / udp
Nota: O comando EXPOSE apenas declara que a porta que o contêiner deve abrir não está realmente aberta, se você não especificar a porta a ser mapeada sem -p, o contêiner não mapeará a porta; para torná-la acessível, você precisa especificar essas portas por meio de -p quando o docker é executado
VOLUME: Usado para especificar o diretório persistente
VOLUME ["/ path / to / dir"]
Exemplo:
VOLUME ["/ect/nginx/con.d"]
VOLUME ["/ etc / nginx / con.d", "/ etc / nginx / logs ”]
Nota: Quando o contêiner estiver em execução, tente evitar que a camada de armazenamento do contêiner seja gravada. Para evitar que os usuários se esqueçam de montar o diretório onde o arquivo dinâmico é salvo como um volume durante a execução, podemos especificar determinados diretórios no Dokcerfile com antecedência. A montagem é um volume anônimo, de modo que mesmo se o usuário não especificar a montagem, ele não gravará uma grande quantidade de dados na camada de armazenamento do contêiner; não pode especificar o correspondente no host e é gerado automaticamente.
Observação: o volume pode ser compartilhado com outros contêineres e seu ciclo de vida é independente do contêiner. O Docker não excluirá automaticamente o volume de dados depois que o contêiner for excluído e não há mecanismo de coleta de lixo para lidar com qualquer volume de dados referenciado por o contêiner, se necessário Remova o volume de dados enquanto exclui o contêiner. Você pode usar o comando docker rm -v ao excluir o contêiner.
Aqui está o foco no que está montando:
WORKDIR: diretório de trabalho, semelhante ao comando cd
WORKDIR / path / to / dir
Exemplo:
WORKDIR / etc (o diretório de trabalho é etc)
WORKDIR nginx (o diretório de trabalho torna-se / etc / nginx)
Nota: Após definir o diretório por meio de WORKDIR, a parte de trás no Dockerfile Os comandos são executados no diretório especificado. Ao executar o contêiner, você pode passar -w para sobrescrever o diretório de trabalho do Dockerfile.
USUÁRIO: Especifique o nome de usuário ou UID ao executar o contêiner e a série de comandos subsequentes usará esse usuário.
USUÁRIO usuário
USUÁRIO uid
USUÁRIO uid: gid
USUÁRIO usuário: gid
USUÁRIO uid: grupo
USUÁRIO usuário: grupo
Exemplo:
USUÁRIO mumu
Nota: Após USUÁRIO ser usado para especificar um usuário, os comandos após o Dockerfile usarão esse usuário, mas ao executar o contêiner , você pode passar o parâmetro u para substituir o usuário especificado.
ARG: Usado para especificar as variáveis passadas para o tempo de execução de construção, semelhante a EVN
ARG [= <valor padrão]
Exemplo:
ARG site
ARG usuário = mumu
Nota: Se ARG especifica um valor padrão e nenhum valor é passado durante a construção, então use o valor padrão.
ONBUILD: Usado para definir o acionador de espelhamento
ONBUILD [INSTRUÇÃO]
Exemplo:
ONBUILD ADD. / Etc / nginx
ONBUILD RUN
Nota: O parâmetro pode ser qualquer instrução Dockerfile, que não terá um impacto substancial no espelho atual (mude o espelho atual Nomeado A), mas se o espelho B for baseado no espelho A, então suas instruções serão executadas durante a construção do espelho B, mas quando C for baseado em B, a instrução não será executada (pode-se entender que não pode ser herdada de geração em geração, haha).
Vamos revê-lo com outro caso:
vamos dar uma olhada no Dokcerfile do nginx: versão mais recente, a parte do comentário foi excluída
FROM debian:buster-slim
LABEL maintainer="NGINX Docker Maintainers <[email protected]>"
ENV NGINX_VERSION 1.19.6
ENV NJS_VERSION 0.5.0
ENV PKG_RELEASE 1~buster
RUN set -x \
COPY docker-entrypoint.sh /
COPY 10-listen-on-ipv6-by-default.sh /docker-entrypoint.d
COPY 20-envsubst-on-templates.sh /docker-entrypoint.d
ENTRYPOINT ["/docker-entrypoint.sh"]
EXPOSE 80
STOPSIGNAL SIGQUIT
CMD ["nginx", "-g", "daemon off;"]
Consulte a imagem de base: debian: buster-slim e
adicione os dados de origem: keeper = "NGINX Docker Maintainers [email protected]"
apresenta três variáveis de ambiente: NGINX_VERSION 1.19.6 NJS_VERSION 0.5.0
PKG_RELEASE 1 ~ buster
executa o comando set -x, Este é o comando no shell para imprimir o comando na tela.
Copie os três arquivos para o local especificado
. A combinação de ENTRYPOINT e CMD é: /docker-entrypoin.sh nginx -g daemon off
Especifique a porta 80
STOPSIGNAL: Isto é introduzido após docker1.9, e esta instrução é enviada ao sistema iniciado pelo contêiner Chame sinais, como o que fazer antes de sair do sistema.