Todo sobre Apple, Android, Juegos Apks y Sitios de Peliculas

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

El

 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 

y

 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