🥇 ▷ Cómo utilizar Docker Buildx Bake para crear canales de creación de imágenes complejas ✅

 docker buildx

El grupo de comandos utiliza BuildKit para exponer capacidades avanzadas de creación de imágenes. Las compilaciones horneadas son una característica de alto nivel que se puede utilizar para definir canales de compilación automatizados. Le permiten producir múltiples imágenes a partir de una sola operación de compilación.

Los flujos de trabajo horneados son útiles cuando desea publicar diferentes variantes de sus imágenes o crear varios proyectos vinculados en paralelo. En este artículo cubriremos las características clave de Docker Buildx Bake y cómo puedes usarlas para optimizar compilaciones complejas.

Empezando

El comando docker buildx bake ejecuta múltiples “objetivos” de compilación y cada uno de ellos produce una imagen de contenedor. Los objetivos se ejecutan en paralelo siempre que sea posible para maximizar el rendimiento. Los objetivos también pueden hacer referencia directa a sus predecesores para crear canalizaciones secuenciales.

Los objetivos de compilación se pueden definir utilizando varios mecanismos diferentes, incluidos los archivos Docker Compose existentes. Buildx creará automáticamente todas las imágenes identificadas en el archivo.

Se exponen funciones más avanzadas cuando enumera los objetivos de compilación en JSON o Archivos HCL. Estos admiten variables, funciones y valores. interpolación para personalizar tus compilaciones.

El comando buildx bake busca los siguientes archivos en orden:

Puede especificar un archivo diferente con el

-f

bandera de comando.

Construir objetivos

Los objetivos de compilación encapsulan toda la configuración relacionada con su compilación. Incluyen detalles como

la ruta al Dockerfile para construir
construir rutas de contextodefiniendo el contenido disponible dentro de su Dockerfile
etiquetas y rótulos para adjuntar a las imágenes de salida
las plataformas para producir imágenes.

Está disponible una lista completa de campos de configuración admitidos en la documentación. Es posible que anteriormente haya proporcionado estas configuraciones como indicadores de línea de comandos para

 docker buildx build

(o incluso simple

 docker build

), lo que le obliga a recordar los valores correctos cada vez. Con buildx bake puedes usar de manera confiable los mismos valores definiéndolos en tu archivo horneado con control de versión.

A continuación se muestra un ejemplo sencillo de un comando docker-bake.hcl que define un único objetivo de compilación:

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

Al ejecutar docker buildx bake con este archivo de horneado se cargará el

 app/Dockerfile

Dockerfile desde su directorio de trabajo. Tendrá acceso a la

 app/src

 shared-components/src

directorios como contextos de construcción. A la imagen producida se le asignarán dos etiquetas.

El destino predeterminado se crea automáticamente cuando ejecuta docker buildx bake. También puede definir objetivos con nombre que se pueden crear bajo demanda:

 target "app" {
    
}

 $ docker buildx bake app

Usando múltiples objetivos

Puedes crear otra imagen simultáneamente definiéndola como un nuevo objetivo dentro de tu archivo 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://youtwo.net/applexgen/como-utilizar-docker-buildx-bake-para-crear-canales-de-creacion-de-imagenes-complejas/api/src" } tags = ["my-api:latest", "docker.io/my-org/my-api:latest"]}

Estas imágenes se pueden crear simultáneamente porque están anidadas en un grupo. Las imágenes de la API y la aplicación se crearán en paralelo cada vez que ejecute el comando docker buildx bake, ya que el grupo predeterminado se selecciona automáticamente. Puede utilizar grupos con nombre de forma similar al ejemplo anterior de objetivos con nombre.

Construir herencia de destino

Los objetivos de compilación pueden heredar unos de otros para reutilizar la configuración. Un escenario en el que esto puede resultar útil se refiere a las imágenes que deben personalizarse para diferentes entornos. Es posible que desee agregar archivos de configuración adicionales a las variantes de imagen destinadas al uso en desarrollo. Aquí hay un docker-bake.hcl que demuestra este modelo:

 group "default" { targets = ["backend", "backend-dev"]}target "backend" { dockerfile = "backend/Dockerfile" contexts = { src = "https://youtwo.net/applexgen/como-utilizar-docker-buildx-bake-para-crear-canales-de-creacion-de-imagenes-complejas/api/src" config = "api/config" } tags = ["backend:latest"]}target "backend-dev" { inherits = ["backend"] contexts = { config = "api/config-dev" } tags = ["backend:dev"]}

El destino backend-dev hereda todas las propiedades del destino backend pero anula el contexto de configuración y aplica una etiqueta diferente.

Puede obtener una vista previa de la estructura del archivo fusionado ejecutando el comando hornear con el indicador –print:

 $ docker buildx bake --print
...
    "backend-dev": {
      "context": ".",
      "contexts": {
        "config": "api/config-dev",
        "src": "https://youtwo.net/applexgen/como-utilizar-docker-buildx-bake-para-crear-canales-de-creacion-de-imagenes-complejas/api/src"
      },
      "dockerfile": "backend/Dockerfile",
      "tags": [
        "backend:dev"
      ]
    }
...

Usar un objetivo anterior como imagen base

A veces es posible que desee que un objetivo de compilación utilice la imagen creada por un objetivo anterior como su propia base. Esta es una alternativa a las compilaciones de varias etapas que se puede usar cuando los Dockerfiles dependen unos de otros pero no se pueden fusionar, tal vez porque existen en proyectos 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"]}

El ejemplo primero construye el objetivo de imagen base de organización. Esto podría contener algunas utilidades que son comunes a las cargas de trabajo en contenedores de su organización. Luego, el destino de la API se construye con la salida del destino de la imagen base de la organización accesible como contexto de compilación base. La API Dockerfile ahora puede hacer referencia al contenido dentro de la imagen base:

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

Este es un patrón poderoso que le permite crear vínculos de dependencia entre imágenes mientras mantiene Dockerfiles separados.

Anulación de propiedades de objetivos en el momento de la construcción

El comando docker buildx bake le permite anular las propiedades de sus objetivos cuando ejecuta su compilación:

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

Este ejemplo cambia el Dockerfile del destino de la API. El comodín * se admite al identificar el objetivo a cambiar. * por sí solo selecciona cada objetivo, mientras que api* modificará todos los objetivos que comiencen con api.

Configuración de variables

Los archivos HCL pueden definir variables a las que puede hacer referencia en sus objetivos de compilación. use un bloque de variables para configurarlos:

 variable "TAG" { default = "latest"}group "default" { targets = ["app"]}target "app" { dockerfile = "src/Dockerfile" tags = ["my-app:${TAG}"]}

Al ejecutar docker buildx bake con esta configuración, se etiquetará el destino de la aplicación como my-app:latest. Puede cambiar el valor de la variable TAG configurando una variable de entorno antes de ejecutar el comando:

 $ TAG=v1 docker buildx bake

Puede utilizar todas las capacidades de interpolación y comparación de variables de el lenguaje HCL para que sus objetivos de compilación sean reutilizables. Funciones están disponibles también para analizar y transformar sus valores.

Resumen

Las compilaciones Baked Buildx le permiten encapsular la configuración de compilación de imágenes como “objetivos” definidos en un archivo. Cuando ejecuta buildx bake, las imágenes de todos los objetivos a los que se hace referencia se crean en paralelo.

Los objetivos pueden heredar unos de otros y depender unos de otros. También puedes usar variables y funciones para crear canales de construcción altamente complejos y configurables.

El comando docker buildx bake es una operación de alto nivel que no es necesaria en todos los flujos de trabajo. No es necesario usarlo cuando crea imágenes simples sin dependencias entre proyectos. El uso de Docker Compose Build es una mejor alternativa para la mayoría de los casos de uso que mantiene la configuración de compilación en su archivo Docker-compose.yml. Se debe considerar el cambio a compilaciones horneadas cuando se crean muchas imágenes simultáneamente utilizando diferentes variables, plataformas, contextos de compilación y anulaciones de configuración.

Resumen del Contenido