Como usar o Dockerfile ONBUILD para executar gatilhos em versões posteriores

A instrução ONBUILD do Docker permite que você configure gatilhos em uma imagem. Seus gatilhos serão executados posteriormente, quando a imagem for usada como base para outra. Eles se tornarão parte do novo contexto de imagem downstream e não serão camadas do sistema de arquivos em sua construção inicial do docker.

Adicionando acionadores ONBUILD

ONBUILD é uma instrução que você escreve em seus Dockerfiles. É único, pois aceita outra instrução como argumento. Você pode especificar qualquer operação do Dockerfile, como COPY ou RUN, e executá-la durante a criação de uma imagem downstream.

 EXECUÇÃO ONBUILD de exemplo de comando 

Este exemplo executa o comando de exemplo na imagem filha no momento em que é construído. Este é outro caso em que um arquivo é copiado do contexto de construção da imagem downstream para o sistema de arquivos:

 CÓPIA ONBUILD assets. json /app/assets. json

As instruções ONBUILD não têm nenhum efeito na imagem produzida pelo Dockerfile em que foram definidas. Criar o Dockerfile acima não executaria o comando example ou incluiria assets. json na imagem:

 # Não inclui as instruções extras docker build -t imagem-base: mais recente. 

Os gatilhos serão usados ​​quando você escrever outro Dockerfile que usa o primeiro como base:

 DA imagem base: RUN meu binário mais recente 

 docker build -t downstream-image: mais recente. 

Publicidade

Construir este Dockerfile executará example-command, copiará em assets. json e, finalmente, executará my-binary. Os gatilhos ONBUILD são sempre executados primeiro, imediatamente após a instrução FROM no Dockerfile downstream.

Como o Docker reconhece os gatilhos?

ONBUILD não afeta o sistema de arquivos do contêiner básico, mas o Docker ainda sabe que os gatilhos estão presentes quando você cria uma imagem downstream. O processo de compilação rastreia as instruções ONBUILD que encontra e as registra nos metadados da imagem.

O Docker inspeciona os metadados das imagens referenciadas em uma instrução FROM. Se a imagem nomeada incluir gatilhos em seus metadados, essas instruções de gatilho são efetivamente coladas no topo do Dockerfile downstream antes do início da compilação.

Os gatilhos, na verdade, são executados como parte do estágio FROM da construção. Eles serão executados na ordem em que foram escritos no Dockerfile upstream. Se uma instrução ONBUILD falhar, o Docker cancelará a compilação e parecerá que o estágio FROM foi a causa.

Limitações

Você pode usar qualquer instrução Dockerfile como argumento para um gatilho ONBUILD com três exceções:

• ONBUILD DE – Isso não é permitido, pois substituiria a imagem de base usada para a construção. Cada Dockerfile deve ser herdado de uma única base.
• ONBUILD MAINTAINER – A instrução MAINTAINER está obsoleta e não deve ser usada; as informações de autoria são fornecidas melhor como um rótulo. A instrução LABEL é compatível com ONBUILD.
• ONBUILD ONBUILD – O encadeamento de instruções ONBUILD não é suportado. Todos os gatilhos são executados na imagem imediatamente após o seu Dockerfile. Você não pode definir gatilhos destinados a serem executados no “ neto ” imagens dois ou mais níveis abaixo do Dockerfile de definição.

Todas as instruções são definidas da mesma maneira que seus usos regulares. Escrever uma etapa comum em seu Dockerfile e, em seguida, prefixá-la com ONBUILD, a tirará do fluxo de compilação normal e a tornará um gatilho de compilação downstream.

Quando os acionadores ONBUILD são úteis?

ONBUILD é mais comumente usado em imagens de utilitários que automatizam tarefas como a compilação de código. Esse tipo de procedimento geralmente requer que várias etapas sejam executadas em uma sequência específica, com dependências como o código-fonte adicionado em um ponto específico.

Publicidade

Considere uma imagem de compilação que procura o código-fonte em um diretório e, a seguir, executa um comando para criá-lo. Você não pode simplesmente COPIAR e EXECUTAR no Dockerfile dessa imagem, pois a fonte do usuário final não existiria dentro do contexto de criação da sua imagem.

Usar o ONBUILD permite fornecer um Dockerfile padrão que seus usuários podem estender e criar docker sem reinventar a funcionalidade comum:

 ENV BUILD_ENV = produção RUN init-build. sh ONBUILD COPY / src / build ONBUILD RUN compile. sh --destination = / bin 

Este exemplo demonstra como uma imagem de construtor pode fornecer um ambiente de compilação pré-configurado. Quando usado como uma imagem base, o código seria compilado automaticamente a partir do contexto de construção downstream. Essa imagem pode interagir com a saída compilada em / bin dentro de seus próprios estágios do Dockerfile.

Resumo

As instruções ONBUILD em Dockerfiles fornecem uma maneira de executar gatilhos como parte de uma compilação downstream. Você pode usar qualquer outra instrução Dockerfile como um gatilho ONBUILD, exceto por algumas limitações.

Usar ONBUILD permite fornecer imagens Docker genéricas que definem conjuntos reutilizáveis ​​de funcionalidade. Isso é mais eficiente do que fazer com que os usuários copiem o texto dos Dockerfiles de exemplo literalmente e, em seguida, adicionem suas próprias instruções na parte inferior. Você ainda pode modificar e atualizar a imagem de base sem exigir ação dos usuários.

Publicidade

A adoção do ONBUILD reduz a repetição e facilita as imagens de base extensíveis do Docker. As instruções ONBUILD devem ser consideradas quando você estiver criando um Dockerfile padrão que precisará ser personalizado pelos usuários finais antes que o ambiente do contêiner final seja considerado completo.