Como usar o comando docker buildx bake para construir múltiplos alvos

DockerBeginner
Pratique Agora

Introdução

Neste laboratório, você aprenderá como usar efetivamente o comando docker buildx bake para gerenciar e construir múltiplos alvos de imagem Docker a partir de um único arquivo de configuração. Começaremos criando um arquivo docker-bake.hcl que define diferentes alvos de construção com configurações variadas.

Através de passos práticos, você praticará a construção de alvos específicos definidos no arquivo bake, listando os alvos disponíveis, substituindo as configurações dos alvos usando flags de linha de comando e visualizando a configuração da construção sem realmente realizar a construção. Este laboratório irá equipá-lo com as habilidades para otimizar seus fluxos de trabalho de construção de imagem Docker para projetos complexos.

Criar um arquivo docker-bake.hcl simples com múltiplos alvos

Nesta etapa, criaremos um arquivo docker-bake.hcl básico. Este arquivo usa o formato HCL (HashiCorp Configuration Language) e permite que você defina múltiplos alvos de construção para suas imagens Docker. Isso é particularmente útil quando você tem diferentes configurações de construção ou deseja construir múltiplas imagens relacionadas a partir de uma única fonte.

Primeiro, navegue até o diretório ~/project, que é seu diretório de trabalho para este laboratório.

cd ~/project

Agora, vamos criar um novo arquivo chamado docker-bake.hcl usando o editor nano.

nano docker-bake.hcl

Dentro do editor nano, cole o seguinte conteúdo. Este arquivo define dois alvos de construção: my-app-dev e my-app-prod. Cada alvo especifica o Dockerfile a ser usado (Dockerfile), o contexto de construção (.) e as tags para a imagem resultante.

target "my-app-dev" {
  dockerfile = "Dockerfile"
  context = "."
  tags = ["my-app:dev"]
}

target "my-app-prod" {
  dockerfile = "Dockerfile"
  context = "."
  tags = ["my-app:prod"]
  args = {
    BUILD_ENV = "production"
  }
}

Neste arquivo:

  • target "my-app-dev" define um alvo chamado my-app-dev.
  • dockerfile = "Dockerfile" especifica que a construção deve usar um arquivo chamado Dockerfile no contexto.
  • context = "." define o contexto de construção para o diretório atual.
  • tags = ["my-app:dev"] atribui a tag my-app:dev à imagem resultante.
  • target "my-app-prod" define outro alvo chamado my-app-prod.
  • Ele também usa Dockerfile e o diretório atual como contexto.
  • tags = ["my-app:prod"] atribui a tag my-app:prod a esta imagem.
  • args = { BUILD_ENV = "production" } passa um argumento de construção BUILD_ENV com o valor production para o Dockerfile durante a construção deste alvo.

Salve o arquivo pressionando Ctrl + S e saia do nano pressionando Ctrl + X.

Em seguida, precisamos de um Dockerfile simples para que nosso arquivo bake possa referenciar. Crie um arquivo chamado Dockerfile no mesmo diretório.

nano Dockerfile

Cole o seguinte conteúdo no Dockerfile:

FROM alpine:latest

ARG BUILD_ENV=development

RUN echo "Building for environment: $BUILD_ENV"

CMD ["echo", "Hello from $BUILD_ENV environment!"]

Este Dockerfile usa a imagem base alpine:latest. Ele define um argumento de construção BUILD_ENV com um valor padrão de development. A instrução RUN imprime o ambiente de construção durante o processo de construção, e a instrução CMD define o comando padrão a ser executado quando um contêiner é iniciado a partir desta imagem.

Salve o Dockerfile e saia do nano.

Você criou com sucesso um arquivo docker-bake.hcl com dois alvos e um Dockerfile simples para ser usado com ele.

Construir um alvo específico usando docker buildx bake

Na etapa anterior, criamos um arquivo docker-bake.hcl com dois alvos de construção: my-app-dev e my-app-prod. Agora, usaremos o comando docker buildx bake para construir um alvo específico definido neste arquivo.

O comando docker buildx bake permite que você construa imagens com base nas configurações definidas em um arquivo bake. Ao especificar o nome do alvo após o comando, você instrui o Buildx a construir apenas aquele alvo específico.

Vamos construir o alvo my-app-dev. Certifique-se de estar no diretório ~/project.

cd ~/project

Agora, execute o seguinte comando:

docker buildx bake my-app-dev

Este comando lerá o arquivo docker-bake.hcl no diretório atual e construirá o alvo chamado my-app-dev. Você deve ver a saída indicando o processo de construção, incluindo as etapas definidas no Dockerfile.

[+] Building 0.0s (0/0)
... (build output) ...

Após a conclusão da construção, você pode verificar se a imagem my-app:dev foi criada listando suas imagens Docker locais.

docker images

Você deve ver my-app com a tag dev na lista de imagens.

Agora, vamos construir o alvo my-app-prod. Este alvo inclui um argumento de construção BUILD_ENV definido como production.

docker buildx bake my-app-prod

Observe a saída. Você deve ver a linha Building for environment: production durante o processo de construção, o que confirma que o argumento de construção foi passado corretamente.

[+] Building 0.0s (0/0)
... (build output showing "Building for environment: production") ...

Após esta construção terminar, liste suas imagens novamente.

docker images

Você deve agora ver tanto my-app:dev quanto my-app:prod em sua lista de imagens.

Ao usar docker buildx bake seguido pelo nome do alvo, você pode construir seletivamente diferentes configurações definidas em seu arquivo bake.

Listar os alvos disponíveis no arquivo bake

Nas etapas anteriores, criamos um arquivo docker-bake.hcl e construímos alvos específicos a partir dele. Às vezes, você pode querer ver todos os alvos disponíveis definidos em um arquivo bake sem realmente construí-los. O comando docker buildx bake oferece uma maneira de fazer isso.

Para listar os alvos disponíveis, você pode simplesmente executar o comando docker buildx bake sem especificar nenhum nome de alvo. Por padrão, ele lerá o arquivo docker-bake.hcl no diretório atual e exibirá os nomes de todos os alvos definidos.

Certifique-se de estar no diretório ~/project onde seu arquivo docker-bake.hcl está localizado.

cd ~/project

Agora, execute o seguinte comando:

docker buildx bake

Você deve ver uma saída semelhante a esta, listando os alvos definidos em seu arquivo docker-bake.hcl:

my-app-dev
my-app-prod

Esta saída mostra os nomes dos dois alvos que definimos no arquivo docker-bake.hcl: my-app-dev e my-app-prod. Esta é uma maneira rápida de obter uma visão geral das configurações de construção disponíveis em um arquivo bake.

Este comando é útil para entender a estrutura de um arquivo bake e identificar os alvos que você pode construir.

Substituir a configuração do alvo usando a flag --set

Nesta etapa, aprenderemos como substituir a configuração de um alvo específico definido no arquivo docker-bake.hcl usando a flag --set com o comando docker buildx bake. Isso é útil quando você precisa fazer pequenos ajustes na configuração de um alvo sem modificar o próprio arquivo bake.

A flag --set permite que você substitua atributos específicos de um alvo. A sintaxe é nome_do_alvo.atributo=valor.

Digamos que queremos construir o alvo my-app-dev, mas com uma tag diferente, por exemplo, my-app:staging. Podemos conseguir isso usando a flag --set.

Certifique-se de estar no diretório ~/project.

cd ~/project

Agora, execute o seguinte comando:

docker buildx bake my-app-dev --set my-app-dev.tags=my-app:staging

Neste comando:

  • my-app-dev é o nome do alvo que estamos construindo.
  • --set my-app-dev.tags=my-app:staging substitui o atributo tags do alvo my-app-dev, definindo seu valor como my-app:staging.

Você verá a saída do processo de construção.

[+] Building 0.0s (0/0)
... (build output) ...

Após a conclusão da construção, liste suas imagens Docker locais para verificar se a imagem com a nova tag foi criada.

docker images

Você deve agora ver my-app com a tag staging na lista, além das tags dev e prod das etapas anteriores.

Você também pode substituir outros atributos, como argumentos de construção. Vamos construir o alvo my-app-prod, mas substituir o argumento BUILD_ENV para qa.

docker buildx bake my-app-prod --set my-app-prod.args.BUILD_ENV=qa

Observe a saída da construção. Você deve ver Building for environment: qa, indicando que o argumento de construção foi substituído com sucesso.

[+] Building 0.0s (0/0)
... (build output showing "Building for environment: qa") ...

A flag --set fornece uma maneira flexível de personalizar suas construções diretamente da linha de comando sem alterar seu arquivo bake.

Imprimir a configuração resultante sem construir

Nesta etapa final, exploraremos como visualizar a configuração final que o docker buildx bake usará para um alvo específico, incluindo quaisquer substituições aplicadas com a flag --set, sem realmente acionar uma construção. Isso é útil para depurar seus arquivos bake e entender a configuração efetiva antes de construir.

A flag --print com docker buildx bake permite que você produza a configuração resolvida em formato JSON.

Certifique-se de estar no diretório ~/project.

cd ~/project

Vamos imprimir a configuração para o alvo my-app-dev.

docker buildx bake my-app-dev --print

Este comando produzirá uma representação JSON da configuração do alvo my-app-dev conforme derivado do arquivo docker-bake.hcl.

{
  "target": {
    "my-app-dev": {
      "dockerfile": "Dockerfile",
      "context": ".",
      "tags": ["my-app:dev"]
    }
  }
}

Agora, vamos ver como a flag --set afeta a configuração impressa. Imprimiremos a configuração para my-app-dev enquanto substituímos a tag para my-app:testing.

docker buildx bake my-app-dev --set my-app-dev.tags=my-app:testing --print

Observe a saída. O atributo tags na saída JSON agora deve refletir o valor substituído.

{
  "target": {
    "my-app-dev": {
      "dockerfile": "Dockerfile",
      "context": ".",
      "tags": ["my-app:testing"]
    }
  }
}

Da mesma forma, você pode imprimir a configuração para o alvo my-app-prod e substituir seu argumento de construção.

docker buildx bake my-app-prod --set my-app-prod.args.BUILD_ENV=staging --print

A saída JSON para o alvo my-app-prod mostrará os args com o valor BUILD_ENV substituído.

{
  "target": {
    "my-app-prod": {
      "dockerfile": "Dockerfile",
      "context": ".",
      "tags": ["my-app:prod"],
      "args": {
        "BUILD_ENV": "staging"
      }
    }
  }
}

A flag --print é uma ferramenta valiosa para verificar suas configurações de arquivo bake e entender como as substituições são aplicadas antes de iniciar construções potencialmente demoradas.

Resumo

Neste laboratório, aprendemos como aproveitar o comando docker buildx bake para gerenciar e construir múltiplos alvos de imagem Docker definidos em um único arquivo docker-bake.hcl. Começamos criando um arquivo docker-bake.hcl básico com alvos distintos, cada um especificando seu Dockerfile, contexto, tags e argumentos de construção.

Em seguida, exploramos como construir um alvo específico do arquivo bake usando docker buildx bake <nome_do_alvo>, listar todos os alvos disponíveis dentro do arquivo, substituir as configurações do alvo em tempo real usando a flag --set e visualizar a configuração de construção resultante sem realmente realizar a construção usando a flag --print. Essas etapas demonstram a flexibilidade e o poder do docker buildx bake para otimizar fluxos de trabalho complexos de construção de múltiplas imagens.