Como usar o Docker Buildx Bake para criar pipelines de construção de imagens complexas

o docker buildx O grupo de comandos usa o BuildKit para expor recursos avançados de criação de imagens. As compilações preparadas são um recurso de alto nível que pode ser usado para definir pipelines de compilação automatizados. Eles permitem que você produza várias imagens a partir de uma única operação de compilação.

Os fluxos de trabalho preparados são úteis quando você deseja publicar diferentes variantes de suas imagens ou criar vários projetos vinculados em paralelo. Neste artigo, abordaremos os principais recursos do docker buildx bake e como você pode usá-los para simplificar compilações complexas.

Começando

o docker buildx bake O comando executa vários “destinos” de compilação, cada um produzindo uma imagem de contêiner. Os alvos são executados em paralelo sempre que possível para maximizar o desempenho. Os destinos também podem fazer referência direta aos predecessores para criar pipelines sequenciais.

Os destinos de compilação podem ser definidos usando vários mecanismos diferentes, incluindo arquivos existentes do Docker Compose. O Buildx construirá automaticamente todas as imagens identificadas no arquivo.

Recursos mais avançados são expostos quando você lista destinos de compilação em arquivos JSON ou HCL. Essas variáveis ​​de suporte, funções e interpolação de valor para personalizar suas compilações.

o buildx bake O comando procura os seguintes arquivos em ordem:

• docker-compose.yml
• docker-compose.yaml
• docker-bake.json
• docker-bake.override.json
• docker-bake.hcl
• docker-bake.override.hcl

Você pode especificar um arquivo diferente com o -f bandeira de comando.

Construir alvos

Os destinos de compilação encapsulam toda a configuração relacionada à sua compilação. Eles incluem detalhes como

• o caminho para o Dockerfile para construir

• construir caminhos de contexto, definindo o conteúdo disponível em seu Dockerfile

• tags e rótulos para anexar às imagens de saída
• as plataformas para produzir imagens.

Uma lista completa de campos de configuração suportados está disponível na documentação. Anteriormente, você pode ter fornecido essas configurações como sinalizadores de linha de comando para docker buildx build (ou mesmo simples docker build), forçando você a lembrar os valores corretos a cada vez. Com buildx bake você pode usar com segurança os mesmos valores definindo-os em seu arquivo preparado com controle de versão.

Aqui está um exemplo simples de um docker-bake.hcl comando que define um único destino de compilação:

target "default" {
    dockerfile = "app/Dockerfile"
    contexts = {
        app = "app/src"
        shared = "shared-components/src"
    }
    tags = ["my-app:latest", "docker.io/my-org/my-app:latest"]
}

Corrida docker buildx bake com este arquivo bake irá carregar o app/Dockerfile Dockerfile do seu diretório de trabalho. Ele terá acesso ao app/src e shared-components/src diretórios como contextos de construção. A imagem produzida receberá duas tags.

o default target é construído automaticamente quando você executa docker buildx bake. Você também pode definir destinos nomeados que podem ser criados sob demanda:

target "app" {
    // ...
}

$ docker buildx bake app

Usando vários destinos

Você pode construir outra imagem simultaneamente definindo-a como um novo alvo dentro do seu arquivo bake:

group "default" {
    targets = ["app", "api"]
}

target "app" {
    dockerfile = "app/Dockerfile"
    contexts = {
        app = "app/src"
        shared = "shared-components/src"
    }
    tags = ["my-app:latest", "docker.io/my-org/my-app:latest"]
}

target "api" {
    dockerfile = "api/Dockerfile"
    contexts = {
        src = "https://www.howtogeek.com/devops/how-to-use-docker-buildx-bake-to-create-complex-image-build-pipelines/api/src"
    }
    tags = ["my-api:latest", "docker.io/my-org/my-api:latest"]
}

Essas imagens podem ser criadas simultaneamente porque estão aninhadas em um grupo. o api e app as imagens serão construídas em paralelo cada vez que você executar o docker buildx bake comando como o default grupo é selecionado automaticamente. Você pode usar grupos nomeados de maneira semelhante ao exemplo de destinos nomeados acima.

Criar herança de destino

Os destinos de compilação podem herdar uns dos outros para reutilizar a configuração. Um cenário em que isso pode ser útil diz respeito a imagens que precisam ser personalizadas para diferentes ambientes. Você pode querer adicionar arquivos de configuração extras às variantes de imagem destinadas ao uso em desenvolvimento. Aqui está um docker-bake.hcl que demonstra este modelo:

group "default" {
    targets = ["backend", "backend-dev"]
}

target "backend" {
    dockerfile = "backend/Dockerfile"
    contexts = {
        src = "https://www.howtogeek.com/devops/how-to-use-docker-buildx-bake-to-create-complex-image-build-pipelines/api/src"
        config = "api/config"
    }
    tags = ["backend:latest"]
}

target "backend-dev" {
    inherits = ["backend"]
    contexts = {
        config = "api/config-dev"
    }
    tags = ["backend:dev"]
}

o backend-dev alvo herda todas as propriedades do backend alvo, mas substitui o config context e aplica uma tag diferente.

Você pode visualizar a estrutura de arquivos mesclada executando o bake comando com o --print bandeira:

$ docker buildx bake --print
...
    "backend-dev": {
      "context": ".",
      "contexts": {
        "config": "api/config-dev",
        "src": "https://www.howtogeek.com/devops/how-to-use-docker-buildx-bake-to-create-complex-image-build-pipelines/api/src"
      },
      "dockerfile": "backend/Dockerfile",
      "tags": [
        "backend:dev"
      ]
    }
...

Usando um alvo anterior como uma imagem de base

Às vezes, você pode querer que um destino de compilação use a imagem criada por um destino anterior como sua própria base. Essa é uma alternativa para compilações de vários estágios que podem ser usadas quando seus Dockerfiles dependem uns dos outros, mas não podem ser mesclados, talvez porque existam em projetos diferentes.

group "default" {
    targets = ["org-base-image", "api"]
}

target "org-base-image" {
    dockerfile = "docker-base/Dockerfile"
    tags = ["org-base-image:latest"]
}

target "api" {
    dockerfile = "api/Dockerfile"
    contexts = {
        base = "target:org-base-image"
    }
    tags = ["api:latest"]
}

O exemplo primeiro constrói o org-base-image alvo. Isso pode conter alguns utilitários comuns às cargas de trabalho em contêiner da sua organização. o api target é então construído com a saída do org-base-image alvo acessível como o base contexto de construção. O API Dockerfile agora pode fazer referência ao conteúdo dentro da imagem base:

COPY --from=base /utilities/example /usr/bin/example-utility

Este é um padrão poderoso que permite criar links de dependência entre imagens enquanto mantém Dockerfiles separados.

Substituindo propriedades de destinos no tempo de compilação

o docker buildx bake O comando permite que você substitua as propriedades de seus destinos ao executar sua compilação:

$ docker buildx bake --set api.dockerfile="api/Dockerfile-dev"

Este exemplo altera o Dockerfile do api alvo. o * curinga é suportado ao identificar o destino a ser alterado. * por conta própria seleciona todos os alvos enquanto api* modificará todos os alvos que começam com api.

Configurando Variáveis

Os arquivos HCL podem definir variáveis ​​que você pode fazer referência em seus destinos de compilação. use um variable bloco para configurá-los:

variable "TAG" {
    default = "latest"
}

group "default" {
    targets = ["app"]
}

target "app" {
    dockerfile = "src/Dockerfile"
    tags = ["my-app:${TAG}"]
}

Corrida docker buildx bake com esta configuração marcará o app alvo como my-app:latest. Você pode alterar o valor do TAG variável definindo uma variável de ambiente antes de executar o comando:

$ TAG=v1 docker buildx bake

Você pode usar todos os recursos de interpolação e comparação de variáveis ​​da linguagem HCL para tornar seus destinos de compilação reutilizáveis. As funções também estão disponíveis para analisar e transformar seus valores.

Resumo

As compilações Baked Buildx permitem encapsular a configuração de compilação da imagem como “destinos” definidos em um arquivo. Quando você corre buildx bakeas imagens de todos os destinos referenciados são criadas em paralelo.

Os alvos podem herdar e depender uns dos outros. Você também pode usar variáveis ​​e funções para criar pipelines de compilação altamente complexos e configuráveis.

o docker buildx bake O comando é uma operação de alto nível que não é necessária em todos os fluxos de trabalho. Você não precisa usá-lo ao criar imagens simples sem dependências entre projetos. Usando docker compose build é uma alternativa melhor para a maioria dos casos de uso que mantém a configuração de compilação em seu docker-compose.yml Arquivo. Mudar para compilações preparadas deve ser considerado quando você estiver compilando muitas imagens simultaneamente usando diferentes variáveis, plataformas, contextos de compilação e substituições de configuração.