Cómo usar el comando docker buildx bake para construir múltiples objetivos

DockerDockerBeginner
Practicar Ahora

💡 Este tutorial está traducido por IA desde la versión en inglés. Para ver la versión original, puedes hacer clic aquí

Introducción

En este laboratorio, aprenderás a utilizar eficazmente el comando docker buildx bake para gestionar y construir múltiples objetivos (targets) de imágenes Docker desde un único archivo de configuración. Comenzaremos creando un archivo docker-bake.hcl que defina diferentes objetivos de compilación con configuraciones variables.

A través de pasos prácticos, practicarás la construcción de objetivos específicos definidos en el archivo bake, listarás los objetivos disponibles, anularás configuraciones de objetivos usando banderas (flags) de línea de comandos y previsualizarás la configuración de compilación sin ejecutar realmente la construcción. Este laboratorio te proporcionará las habilidades para optimizar tus flujos de trabajo de construcción de imágenes Docker para proyectos complejos.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL docker(("Docker")) -.-> docker/ImageOperationsGroup(["Image Operations"]) docker(("Docker")) -.-> docker/DockerfileGroup(["Dockerfile"]) docker/ImageOperationsGroup -.-> docker/images("List Images") docker/DockerfileGroup -.-> docker/build("Build Image from Dockerfile") subgraph Lab Skills docker/images -.-> lab-555044{{"Cómo usar el comando docker buildx bake para construir múltiples objetivos"}} docker/build -.-> lab-555044{{"Cómo usar el comando docker buildx bake para construir múltiples objetivos"}} end

Crear un archivo docker-bake.hcl simple con múltiples objetivos (targets)

En este paso, crearemos un archivo básico docker-bake.hcl. Este archivo utiliza el formato HCL (HashiCorp Configuration Language) y te permite definir múltiples objetivos de compilación para tus imágenes Docker. Esto es especialmente útil cuando tienes diferentes configuraciones de compilación o deseas construir múltiples imágenes relacionadas desde una sola fuente.

Primero, navega al directorio ~/project, que es tu directorio de trabajo para este laboratorio.

cd ~/project

Ahora, creemos un nuevo archivo llamado docker-bake.hcl usando el editor nano.

nano docker-bake.hcl

Dentro del editor nano, pega el siguiente contenido. Este archivo define dos objetivos de compilación: my-app-dev y my-app-prod. Cada objetivo especifica el Dockerfile a usar (Dockerfile), el contexto de compilación (.) y las etiquetas (tags) para la imagen 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"
  }
}

En este archivo:

  • target "my-app-dev" define un objetivo llamado my-app-dev.
  • dockerfile = "Dockerfile" especifica que la compilación debe usar un archivo llamado Dockerfile en el contexto.
  • context = "." establece el contexto de compilación como el directorio actual.
  • tags = ["my-app:dev"] asigna la etiqueta my-app:dev a la imagen resultante.
  • target "my-app-prod" define otro objetivo llamado my-app-prod.
  • También usa Dockerfile y el directorio actual como contexto.
  • tags = ["my-app:prod"] asigna la etiqueta my-app:prod a esta imagen.
  • args = { BUILD_ENV = "production" } pasa un argumento de compilación BUILD_ENV con el valor production al Dockerfile durante la compilación de este objetivo.

Guarda el archivo presionando Ctrl + S y sal de nano presionando Ctrl + X.

A continuación, necesitamos un Dockerfile simple para que nuestro archivo bake lo referencie. Crea un archivo llamado Dockerfile en el mismo directorio.

nano Dockerfile

Pega el siguiente contenido en el 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 la imagen base alpine:latest. Define un argumento de compilación BUILD_ENV con un valor predeterminado de development. La instrucción RUN imprime el entorno de compilación durante el proceso de compilación, y la instrucción CMD establece el comando predeterminado que se ejecutará cuando se inicie un contenedor desde esta imagen.

Guarda el Dockerfile y sal de nano.

Ahora has creado exitosamente un archivo docker-bake.hcl con dos objetivos y un Dockerfile simple para usarlo.

Construir un objetivo específico usando docker buildx bake

En el paso anterior, creamos un archivo docker-bake.hcl con dos objetivos de compilación: my-app-dev y my-app-prod. Ahora usaremos el comando docker buildx bake para construir un objetivo específico definido en este archivo.

El comando docker buildx bake te permite construir imágenes basadas en las configuraciones definidas en un archivo bake. Al especificar el nombre del objetivo después del comando, le indicas a Buildx que construya solo ese objetivo en particular.

Construyamos el objetivo my-app-dev. Asegúrate de estar en el directorio ~/project.

cd ~/project

Ahora, ejecuta el siguiente comando:

docker buildx bake my-app-dev

Este comando leerá el archivo docker-bake.hcl en el directorio actual y construirá el objetivo llamado my-app-dev. Deberías ver una salida que indica el proceso de compilación, incluyendo los pasos definidos en el Dockerfile.

[+] Building 0.0s (0/0)
... (salida de compilación) ...

Una vez completada la compilación, puedes verificar que la imagen my-app:dev se ha creado listando tus imágenes locales de Docker.

docker images

Deberías ver my-app con la etiqueta dev en la lista de imágenes.

Ahora, construyamos el objetivo my-app-prod. Este objetivo incluye un argumento de compilación BUILD_ENV establecido como production.

docker buildx bake my-app-prod

Observa la salida. Deberías ver la línea Building for environment: production durante el proceso de compilación, lo que confirma que el argumento de compilación se pasó correctamente.

[+] Building 0.0s (0/0)
... (salida mostrando "Building for environment: production") ...

Cuando termine esta compilación, lista tus imágenes nuevamente.

docker images

Ahora deberías ver tanto my-app:dev como my-app:prod en tu lista de imágenes.

Al usar docker buildx bake seguido del nombre del objetivo, puedes construir selectivamente diferentes configuraciones definidas en tu archivo bake.

Listar objetivos disponibles en el archivo bake

En los pasos anteriores, creamos un archivo docker-bake.hcl y construimos objetivos específicos a partir de él. A veces, es posible que desees ver todos los objetivos disponibles definidos en un archivo bake sin necesidad de construirlos. El comando docker buildx bake proporciona una forma de hacer esto.

Para listar los objetivos disponibles, simplemente puedes ejecutar el comando docker buildx bake sin especificar ningún nombre de objetivo. Por defecto, leerá el archivo docker-bake.hcl en el directorio actual y mostrará los nombres de todos los objetivos definidos.

Asegúrate de estar en el directorio ~/project donde se encuentra tu archivo docker-bake.hcl.

cd ~/project

Ahora, ejecuta el siguiente comando:

docker buildx bake

Deberías ver una salida similar a esta, que enumera los objetivos definidos en tu archivo docker-bake.hcl:

my-app-dev
my-app-prod

Esta salida muestra los nombres de los dos objetivos que definimos en el archivo docker-bake.hcl: my-app-dev y my-app-prod. Esta es una forma rápida de obtener una visión general de las configuraciones de compilación disponibles en un archivo bake.

Este comando es útil para comprender la estructura de un archivo bake e identificar los objetivos que puedes construir.

Sobrescribir configuración de objetivos usando el flag --set

En este paso, aprenderemos cómo sobrescribir la configuración de un objetivo específico definido en el archivo docker-bake.hcl usando el flag --set con el comando docker buildx bake. Esto es útil cuando necesitas hacer ajustes menores a la configuración de un objetivo sin modificar el archivo bake en sí.

El flag --set permite sobrescribir atributos específicos de un objetivo. La sintaxis es nombre_objetivo.atributo=valor.

Supongamos que queremos construir el objetivo my-app-dev pero con un tag diferente, por ejemplo my-app:staging. Podemos lograrlo usando el flag --set.

Asegúrate de estar en el directorio ~/project.

cd ~/project

Ahora, ejecuta el siguiente comando:

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

En este comando:

  • my-app-dev es el nombre del objetivo que estamos construyendo
  • --set my-app-dev.tags=my-app:staging sobrescribe el atributo tags del objetivo my-app-dev, estableciendo su valor como my-app:staging

Verás la salida del proceso de construcción.

[+] Building 0.0s (0/0)
... (salida de construcción) ...

Una vez completada la construcción, lista tus imágenes locales de Docker para verificar que se creó la imagen con el nuevo tag.

docker images

Ahora deberías ver my-app con el tag staging en la lista, además de los tags dev y prod de pasos anteriores.

También puedes sobrescribir otros atributos, como argumentos de construcción. Construyamos el objetivo my-app-prod pero sobrescribiendo el argumento BUILD_ENV como qa.

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

Observa la salida de construcción. Deberías ver Building for environment: qa, indicando que el argumento de construcción fue sobrescrito exitosamente.

[+] Building 0.0s (0/0)
... (salida mostrando "Building for environment: qa") ...

El flag --set proporciona una forma flexible de personalizar tus construcciones directamente desde la línea de comandos sin alterar tu archivo bake.

Mostrar la configuración resultante sin construir

En este paso final, exploraremos cómo ver la configuración final que docker buildx bake utilizará para un objetivo específico, incluyendo cualquier sobrescritura aplicada con el flag --set, sin necesidad de ejecutar realmente la construcción. Esto es útil para depurar tus archivos bake y comprender la configuración efectiva antes de construir.

El flag --print con docker buildx bake te permite mostrar la configuración resuelta en formato JSON.

Asegúrate de estar en el directorio ~/project.

cd ~/project

Mostremos la configuración para el objetivo my-app-dev.

docker buildx bake my-app-dev --print

Este comando mostrará una representación JSON de la configuración del objetivo my-app-dev derivada del archivo docker-bake.hcl.

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

Ahora veamos cómo el flag --set afecta la configuración mostrada. Mostraremos la configuración para my-app-dev sobrescribiendo el tag a my-app:testing.

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

Observa la salida. El atributo tags en el JSON ahora debería reflejar el valor sobrescrito.

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

De manera similar, puedes mostrar la configuración para el objetivo my-app-prod y sobrescribir su argumento de construcción.

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

La salida JSON para el objetivo my-app-prod mostrará los args con el valor sobrescrito de BUILD_ENV.

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

El flag --print es una herramienta valiosa para verificar las configuraciones de tus archivos bake y comprender cómo se aplican las sobrescrituras antes de iniciar construcciones que podrían ser largas.

Resumen

En este laboratorio, aprendimos cómo utilizar el comando docker buildx bake para gestionar y construir múltiples objetivos de imágenes Docker definidos en un único archivo docker-bake.hcl. Comenzamos creando un archivo básico docker-bake.hcl con objetivos distintos, cada uno especificando su Dockerfile, contexto, tags y argumentos de construcción.

Luego exploramos cómo:

  • Construir un objetivo específico del archivo bake usando docker buildx bake <nombre_objetivo>
  • Listar todos los objetivos disponibles dentro del archivo
  • Sobrescribir configuraciones de objetivos al vuelo usando el flag --set
  • Previsualizar la configuración de construcción resultante sin ejecutar realmente la construcción mediante el flag --print

Estos pasos demuestran la flexibilidad y potencia de docker buildx bake para optimizar flujos de trabajo complejos de construcción de múltiples imágenes.