Como usar o Docker Buildx Bake para criar pipelines de imagem complexos

0
44


a docker buildx O grupo de comandos usa o BuildKit para expor recursos avançados de imagem. 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.

Iniciando

a docker buildx bake O comando executa vários “destinos” de compilação, cada um dos quais produz uma imagem de contêiner. Os destinos 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.

a 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 metas

Os destinos de compilação encapsulam todas as configurações relacionadas à 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
  • plataformas para produzir imagens.

Uma lista completa de campos de configuração suportados está disponível na documentação. Você pode ter fornecido anteriormente essas configurações como sinalizadores de linha de comando para docker buildx build (ou mesmo apenas docker build), forçando você a lembrar os valores corretos todas as vezes. Com buildx bake você pode usar de forma confiável 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"]
}

Corre docker buildx bake com este arquivo bake irá carregar o app/Dockerfile Dockerfile do seu diretório de trabalho. Você terá acesso a app/src S shared-components/src diretórios como contextos de construção. A imagem produzida receberá dois rótulos.

a default o destino é criado 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

Uso de vários alvos

Você pode criar outra imagem simultaneamente definindo-a como um novo destino em 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 construídas simultaneamente porque estão aninhadas em um grupo. a api S app as imagens serão construídas em paralelo cada vez que você executar o docker buildx bake comando como o default o 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 é com imagens que precisam ser personalizadas para diferentes ambientes. Você pode querer adicionar arquivos de configuração adicionais à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"]
}

a backend-dev o alvo herda todas as propriedades do backend alvo, mas cancela o config contexto e aplique uma tag diferente.

Você pode visualizar a estrutura de arquivos combinada 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 às compilações de vários estágios que podem ser usadas quando os 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 objetivo. Isso pode conter alguns utilitários comuns a cargas de trabalho em contêiner em sua organização. a api então o alvo é construído com a saída do org-base-image alvo acessível, como base contexto de construção. A API Dockerfile agora pode fazer referência ao conteúdo na 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 os Dockerfiles separados.

Substituindo propriedades de destino em tempo de compilação

a 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 de api objetivo. a * O curinga é suportado ao identificar o destino a ser alterado. * sozinho seleciona todos os alvos enquanto api* modificará todos os alvos começando com api.

Configuração de variável

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}"]
}

Corre docker buildx bake com esta configuração ele rotulará 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 para 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.

a 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. Vestindo 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 processos. A mudança para builds preparados deve ser considerada quando você está construindo muitas imagens simultaneamente usando diferentes variáveis, plataformas, contextos de compilação e substituições de configuração.