Como usar o Docker Build Args para configurar compilações de imagem

O mecanismo de "argumento de compilação" do Docker permite definir variáveis ​​de ambiente que podem ser referenciadas em seu Dockerfile durante a criação da imagem. Ao contrário das instruções ENV normais, os argumentos do compilador não estão presentes na imagem de saída final. Eles são para casos em que você deseja configurar o processo de compilação em vez dos contêineres criados.

índice

  1. Definindo argumentos do compilador
  2. Valores de argumento de compilação padrão
  3. Onde os argumentos do compilador podem ser usados?
  4. Argumentos de compilação predefinidos
  5. Quando usar argumentos do compilador?
  6. Resumo

Definindo argumentos do compilador

Você define os argumentos de compilação em seu Dockerfile usando instruções ARG :

 ARG EXAMPLE_VAR ARG DEMO_VAR RUN echo $EXAMPLE_VAR

dois argumentos, EXAMPLE_VAR e DEMO_VAR são adicionados à compilação pelo Dockerfile acima.

Defina os valores dos argumentos disponíveis através do sinalizador --build-arg para docker build . Repita o sinalizador várias vezes para cobrir todos os argumentos definidos em seu Dockerfile :

 docker build -t example-image:latest --build-arg EXAMPLE_VAR=value1 --build-arg DEMO_VAR=value2 .

Compilando o Dockerfile de exemplo, use este comando para emitir value1 para seu terminal durante a compilação. A variável EXAMPLE_VAR está disponível no ambiente de construção com o valor value1 . O componente value do sinalizador --build-arg é opcional; a omissão dele selecionará automaticamente o valor da variável em seu ambiente shell local.

Como os argumentos de construção não persistem na imagem construída, você verá uma string vazia ao echo $EXAMPLE_VAR dentro de contêineres criados a partir de example-image:latest . As variáveis ​​a serem referenciadas pelos contêineres em execução devem ser adicionadas usando instruções ENV e sinalizadores de compilação --env ou -e .

Embora não estejam na imagem final, os argumentos de compilação ainda afetam o cache de compilação do Docker. Alterar o valor de um argumento entre compilações pode causar erros de cache para instruções que seguem a primeira referência à variável. a instrução de definição ARG não é responsável pela invalidação do cache.

 FROM alpine:latest ARG EXAMPLE_VAR # Cache não é invalidado - arg não foi usado RUN example-command # Build cache não pode ser usado a partir deste ponto RUN echo $EXAMPLE_VAR

Valores de argumento de compilação padrão

A instrução ARG pode receber um valor padrão para usar quando não houver correspondência --build-arg sinalizador é fornecido:

 ARG EXAMPLE_VAR=demo

O Docker sempre preferirá o valor fornecido pelo --build-arg quando um estiver disponível. Se estiver ausente, EXAMPLE_VAR será definido para demo no ambiente de compilação. Isso reduz o número de sinalizadores que você precisa fornecer ao criar uma imagem com argumentos que raramente são substituídos.

Onde os argumentos do compilador podem ser usados?

Os argumentos de compilação podem ser referenciados nas instruções do Dockerfile que os seguem. Eles funcionam com a maioria dos tipos de instruções, incluindo comandos RUN executados em contêineres de compilação intermediários. Os argumentos são referenciados da mesma forma que as variáveis ​​de ambiente, usando a sintaxe $EXAMPLE_VAR .

As instruções ARG são exclusivas porque afetam materialmente a construção, mas podem ser usadas antes das instruções FROM . É permitido referenciar argumentos de construção dentro de uma instrução FROM , permitindo que você selecione uma imagem base diferente dependendo das configurações do usuário:

 ARG BASE_IMAGE_VERSION=alpine FROM my-app-base:2-${BASE_IMAGE_VERSION}
 docker build -t my-app:latest --build-arg BASE_IMAGE_VERSION=debian .

Os argumentos de compilação estão disponíveis na linha em que são definidos. Qualquer instrução a seguir pode fazer referência ao valor dos argumentos de compilação criados acima no Dockerfile. Você deve adicionar instruções ARG para todos os argumentos do compilador a serem usados. Fazer referência a um argumento antes que ele tenha sido definido ou usar --build-arg sem um ARG correspondente – resulta em uma string vazia.

Os argumentos de compilação não funcionam em estágios de compilação. Cada estágio atua como uma nova compilação com seu próprio conjunto de argumentos de compilação. As instruções ARG incluídas nos estágios anteriores não têm efeito nos posteriores, a menos que sejam repetidas em cada estágio:

 FROM php:latest ARG BUILD_VERSION FROM composer:latest ARG BUILD_VERSION

Ambos os estágios definem explicitamente o argumento BUILD_VERSION para que o valor definido com --build-arg seja passado para cada um.

As considerações do estágio de compilação também se aplicam quando você usa ARG antes da instrução FROM . Esses argumentos existem fora de qualquer estágio de construção; eles são compartilhados por todos os FROM , mas não podem ser referenciados seguindo as instruções. Se você quiser reutilizar um argumento de compilação de nível FROM em um estágio, repita a instrução ARG para extrair seu valor:

 # Aplica-se apenas às instruções FROM ARG BASE_IMAGE_VERSION=alpine FROM my-app-base:2-${BASE_IMAGE_VERSION} # Refere-se ao argumento de construção externo ARG BASE_IMAGE_VERSION # Funciona como esperado RUN echo $BASE_IMAGE_VERSION

Deixando de lado essas preocupações especiais, os argumentos se comportam de maneira semelhante às variáveis ​​de ambiente em todos os outros aspectos. Você pode substituir seus valores usando instruções ARG e ENV , interpolá-los em strings e usá-los em expressões de expansão no formato ${EXAMPLE_VAR:-demo} . Isso seleciona demo como o valor quando a variável EXAMPLE_VAR não está definida.

Argumentos de compilação predefinidos

O Docker oferece suporte a alguns argumentos de compilação por padrão, mesmo que você não inclua as instruções ARG em seu Dockerfile. Eles estão relacionados às configurações de proxy e funcionam desde que o sinalizador --build-arg correspondente seja usado. As variáveis ​​também são excluídas da saída do docker history para evitar revelar os detalhes potencialmente confidenciais aos quais se destinam; Mais informações sobre este comando e suas implicações abaixo.

As compilações tratadas pelo backend do BuildKit também podem acessar vários outros argumentos de compilação predefinidos. Estes são fornecidos com valores injetados automaticamente. A lista inclui TARGETOS , TARGETARCH , TARGETPLATFORM , e BUILDOS , BUILDARCH e BUILDPLATFORM , entre vários outros. As variáveis ​​descrevem as características do ambiente de construção e a plataforma que a nova imagem visa.

Quando usar argumentos do compilador?

Os argumentos de compilação podem ser usados ​​para injetar configuração nas compilações de imagem do Docker. Eles são uma maneira de modificar dinamicamente a imagem final sem escrever vários Dockerfiles.

Você pode usar esse mecanismo para modificar a imagem base de uma compilação, alterar os comandos executados pelas instruções RUN e fornecer configurações modificáveis ​​pelo usuário que expõem as opções de personalização da imagem. Os argumentos de compilação fazem sentido para a maioria dos valores que são usados ​​apenas durante o processo de compilação e que você não deseja codificar em seu Dockerfile.

Existem algumas situações em que abordagens alternativas devem ser usadas. Embora convenientes, os argumentos do compilador não são ideais para dados secretos, como tokens e chaves de autenticação. Como o ARG é uma instrução do Dockerfile, as variáveis ​​e seus valores ficam visíveis ao inspecionar uma imagem com o domínio do docker history . Portanto, qualquer pessoa com acesso à sua imagem pode ver as chaves usadas durante a compilação.

As credenciais usadas para autenticar seu processo de compilação para empacotar logs e repositórios de controle do código-fonte são melhor fornecidas como segredos de compilação do BuildKit. Eles são projetados para lidar com informações confidenciais e são montados como arquivos no ambiente de compilação, em vez de serem convertidos em instruções de imagem.

Resumo

Os argumentos de compilação permitem configurar compilações de imagem do Docker usando uma combinação de instruções do Dockerfile e argumentos de linha de comando no momento da compilação. Ao contrário das variáveis ​​de ambiente, os argumentos de construção não podem ser acessados ​​por contêineres em execução, mesmo que ainda estejam visíveis no histórico de camadas da imagem.

Um argumento de compilação é a opção correta para configurações não confidenciais personalizáveis ​​pelo usuário que afetam seu processo de compilação. Use uma variável de ambiente quando quiser expor o valor na imagem final. Os segredos do BuildKit são uma terceira opção melhor para quaisquer dados valiosos que sua compilação precisa acessar.

  • Escolhendo o modelo de ramificação e fluxo de trabalho do Git certo para sua equipe
  • Quais operadoras de celular têm planos realmente ilimitados nos EUA?

descubra mais conteúdo

O que é um amplificador integrado?

Google Pixel Watch também tem detecção de queda, mas não até o próximo ano

As melhores xícaras de café aquecidas de 2022

Como automatizar seu iPhone com base na hora, atividade ou localização

"Isso deve ter sido antes do meu tempo"

Por que a NASA enviou Snoopy para a Lua? – Revisão Geek

O que é um Docker ARG?

A diretiva ARG no Dockerfile define o nome do parâmetro e define seu valor padrão . Esse valor padrão pode ser substituído pelo -build-arg <nome do parâmetro>=<valor> no comando de compilação build.

Como você passa ARG Docker?

Se você quiser passar vários argumentos de compilação com o comando docker build, você deve passar cada argumento com —build-arg. docker build -t <image-name>:<tag> -build-arg <key1>=<value1> -build-arg <key2>=<value2> .

Qual é a diferença entre ARG e ENV?

O ENV é para contêineres em execução no futuro. ARG para construir sua imagem do Docker . ¶ ENV destina-se principalmente a fornecer valores padrão para suas futuras variáveis ​​de ambiente.

Podemos usar ARG e ENV juntos?

Você pode usar valores ARG para definir valores ENV para contornar isso . Os valores ENV estão disponíveis para contêineres, mas também comandos no estilo RUN durante a compilação do Docker, começando com a linha em que são introduzidos.

Ir arriba