ARG

A instrução ARG em um Dockerfile é usada para definir variáveis de build-time (tempo de construção) que podem ser passadas como argumentos ao construir uma imagem Docker. Essas variáveis permitem que você personalize o processo de construção da imagem sem precisar modificar o Dockerfile diretamente.

Sintaxe Básica

ARG NOME_DO_ARG=[valor padrão]

• NOME_DO_ARG: O nome do argumento que você deseja definir. Pode ser utilizado posteriormente no Dockerfile.

• valor padrão (opcional): Um valor padrão que será usado caso o argumento não seja fornecido durante a construção da imagem.

Funcionalidades do ARG

• Flexibilidade na Construção: ARG permite que você passe diferentes valores de argumento durante o processo de construção, tornando seu Dockerfile mais flexível e reutilizável.

• Valores Padrão: Se um valor padrão for fornecido no ARG, ele será usado se o argumento não for especificado ao construir a imagem.

Exemplos de Uso

Definir um Argumento Simples

FROM ubuntu:20.04
ARG VERSAO_BASE
RUN echo "Construindo imagem baseada na versão: $VERSAO_BASE"

Neste exemplo, o argumento VERSAO_BASE é definido e utilizado na instrução RUN. Se o valor de VERSAO_BASE não for fornecido durante a construção, ele será tratado como vazio.

Usar ARG com Valor Padrão

FROM ubuntu:20.04
ARG VERSAO_BASE=1.0
RUN echo "Construindo imagem baseada na versão: $VERSAO_BASE"

Aqui, o argumento VERSAO_BASE tem um valor padrão de 1.0. Se o valor não for passado durante a construção, 1.0 será usado.

Passando Argumentos Durante a Construção

Você pode passar argumentos para a construção da imagem usando a flag --build-arg com o comando docker build:

docker build --build-arg VERSAO_BASE=2.0 -t minha_imagem:2.0 .

Neste comando, o valor 2.0 é passado para o argumento VERSAO_BASE durante a construção da imagem.

Uso de ARG com ENV

Embora os argumentos ARG sejam usados principalmente durante o tempo de construção, você pode combiná-los com a instrução ENV para definir variáveis de ambiente que estarão disponíveis no contêiner em execução.

FROM node:14
ARG AMBIENTE=desenvolvimento
ENV NODE_ENV=$AMBIENTE
RUN echo "O ambiente de execução é: $NODE_ENV"

Neste exemplo, o argumento AMBIENTE é usado para definir a variável de ambiente NODE_ENV. Assim, o valor passado durante a construção determinará o ambiente de execução no contêiner.

Boas Práticas e Considerações

• Uso Limitado: ARG é apenas para uso durante a construção da imagem. As variáveis definidas com ARG não estarão disponíveis no contêiner em tempo de execução, a menos que sejam explicitamente passadas para ENV ou usadas em outras instruções.

• Compatibilidade com Cache: Mudanças nos valores de ARG podem invalidar o cache de construção, fazendo com que as instruções subsequentes sejam reconstruídas. Use ARG estrategicamente para maximizar a eficiência do cache.

• Exposição Limitada: Diferente das variáveis de ambiente (ENV), os valores de ARG não são expostos automaticamente ao contêiner em execução, o que pode ser uma vantagem de segurança em alguns cenários.

Exemplos Avançados

Usando ARG para Escolher uma Imagem Base

ARG IMAGEM_BASE=alpine:3.14
FROM $IMAGEM_BASE
RUN echo "Usando imagem base: $IMAGEM_BASE"

Neste exemplo, o argumento IMAGEM_BASE define qual imagem base será usada para construir a imagem Docker. Isso permite que você altere facilmente a base da imagem sem modificar o Dockerfile.

Passando Múltiplos Argumentos

FROM python:3.10
ARG PIP_INDEX_URL
RUN pip install --index-url $PIP_INDEX_URL -r requirements.txt

Neste exemplo, PIP_INDEX_URL permite especificar um repositório Python alternativo para instalar as dependências, o que pode ser útil em ambientes que utilizam repositórios privados.

Resumo

• ARG define variáveis de build-time que podem ser passadas como argumentos durante a construção da imagem Docker.

• Flexibilidade: ARG oferece flexibilidade ao permitir que você personalize a construção da imagem sem modificar o Dockerfile.

• Uso em Tempo de Construção: Os valores de ARG só estão disponíveis durante a construção da imagem, não em tempo de execução, a menos que sejam passados para ENV.

Laboratório

FROM ubuntu
RUN apt update && apt install curl --yes
WORKDIR /app

# RUN echo "teste xpto" > arquivo.txt
ARG VAR_TEXTO="Texto XPTO"
RUN echo $VAR_TEXTO > arquivo.txt

$ docker build -t ubuntu-curl .
[+] Building 0.4s (8/8) FINISHED                             docker:default
 => [internal] load build definition from Dockerfile                   0.0s
 => => transferring dockerfile: 205B                                   0.0s
 => [internal] load metadata for docker.io/library/ubuntu:latest       0.0s
 => [internal] load .dockerignore                                      0.0s
 => => transferring context: 2B                                        0.0s
 => [1/4] FROM docker.io/library/ubuntu:latest                         0.0s
 => CACHED [2/4] RUN apt update && apt install curl --yes              0.0s
 => CACHED [3/4] WORKDIR /app                                          0.0s
 => [4/4] RUN echo Texto XPTO > arquivo.txt                            0.2s
 => exporting to image                                                 0.0s
 => => exporting layers                                                0.0s
 => => writing image sha256:d2c4ed3d85f42991d541f1aa3bd83fa757db03fa2  0.0s
 => => naming to docker.io/library/ubuntu-curl                         0.0s
$ docker container run -it ubuntu-curl /bin/bash
root@3df23c5aa189:/app# ls
arquivo.txt
root@3df23c5aa189:/app# cat arquivo.txt
Texto XPTO

Alterar o arquivo em tempo de execução do container:

$ docker build -t ubuntu-curl --build-arg VAR_TEXTO="Valor ABC" .
[+] Building 0.4s (8/8) FINISHED                             docker:default
 => [internal] load build definition from Dockerfile                   0.0s
 => => transferring dockerfile: 205B                                   0.0s
 => [internal] load metadata for docker.io/library/ubuntu:latest       0.0s
 => [internal] load .dockerignore                                      0.0s
 => => transferring context: 2B                                        0.0s
 => [1/4] FROM docker.io/library/ubuntu:latest                         0.0s
 => CACHED [2/4] RUN apt update && apt install curl --yes              0.0s
 => CACHED [3/4] WORKDIR /app                                          0.0s
 => [4/4] RUN echo Valor ABC > arquivo.txt                             0.2s
 => exporting to image                                                 0.0s
 => => exporting layers                                                0.0s
 => => writing image sha256:0f5880af056e8c9f9b0f9590cdb3964f6ae3737f9  0.0s
 => => naming to docker.io/library/ubuntu-curl                         0.0s
$ docker container run -it ubuntu-curl /bin/bash
root@e8588f49f561:/app# ls
arquivo.txt
root@e8588f49f561:/app# cat arquivo.txt
Valor ABC

Quando o argumento é alterado, o cache não é utilizado para construção da camada de arquivo.

Se o valor do argumento for alterado em tempo de execução, a boa prática seria colocar o arquivo mais abaixo no Dockerfile para aproveitar todas as camadas de cache possível