Cómo usar el comando docker buildx imagetools create para combinar y etiquetar imágenes

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 imagetools create para combinar y etiquetar imágenes de Docker. Esta experiencia práctica te guiará a través del proceso de creación de una nueva imagen fusionando contenido de múltiples imágenes fuente, una práctica común en la construcción de aplicaciones complejas.

Luego, explorarás cómo etiquetar la imagen recién creada, previsualizar la estructura final de la imagen sin enviarla usando la bandera --dry-run, y añadir anotaciones valiosas al índice de imágenes para una mejor organización y gestión de metadatos. Al finalizar este laboratorio, tendrás un sólido entendimiento de cómo aprovechar docker buildx imagetools create para la manipulación y gestión avanzada de imágenes.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL docker(("Docker")) -.-> docker/ContainerOperationsGroup(["Container Operations"]) docker(("Docker")) -.-> docker/ImageOperationsGroup(["Image Operations"]) docker(("Docker")) -.-> docker/DockerfileGroup(["Dockerfile"]) docker/ContainerOperationsGroup -.-> docker/inspect("Inspect Container") docker/ContainerOperationsGroup -.-> docker/create("Create Container") docker/ImageOperationsGroup -.-> docker/pull("Pull Image from Repository") docker/ImageOperationsGroup -.-> docker/tag("Tag an Image") docker/ImageOperationsGroup -.-> docker/images("List Images") docker/DockerfileGroup -.-> docker/build("Build Image from Dockerfile") subgraph Lab Skills docker/inspect -.-> lab-555057{{"Cómo usar el comando docker buildx imagetools create para combinar y etiquetar imágenes"}} docker/create -.-> lab-555057{{"Cómo usar el comando docker buildx imagetools create para combinar y etiquetar imágenes"}} docker/pull -.-> lab-555057{{"Cómo usar el comando docker buildx imagetools create para combinar y etiquetar imágenes"}} docker/tag -.-> lab-555057{{"Cómo usar el comando docker buildx imagetools create para combinar y etiquetar imágenes"}} docker/images -.-> lab-555057{{"Cómo usar el comando docker buildx imagetools create para combinar y etiquetar imágenes"}} docker/build -.-> lab-555057{{"Cómo usar el comando docker buildx imagetools create para combinar y etiquetar imágenes"}} end

Crear una nueva imagen a partir de múltiples imágenes fuente

En este paso, aprenderemos cómo crear una nueva imagen de Docker combinando contenido de múltiples imágenes fuente. Este es un escenario común cuando necesitas construir una imagen que incluya componentes de diferentes imágenes base o imágenes preconstruidas.

Primero, descargaremos las imágenes fuente necesarias. Usaremos las imágenes ubuntu y alpine como ejemplos.

docker pull ubuntu:latest
docker pull alpine:latest

Deberías ver una salida que indica que las imágenes están siendo descargadas.

latest: Pulling from library/ubuntu
...
Status: Downloaded newer image for ubuntu:latest
latest: Pulling from library/alpine
...
Status: Downloaded newer image for alpine:latest

Ahora, crearemos una nueva imagen usando un Dockerfile. Un Dockerfile es un documento de texto que contiene todos los comandos que un usuario podría ejecutar en la línea de comandos para ensamblar una imagen. Crea un nuevo archivo llamado Dockerfile en tu directorio ~/project.

nano ~/project/Dockerfile

Añade el siguiente contenido al Dockerfile:

FROM ubuntu:latest AS base
FROM alpine:latest AS alpine_base

COPY --from=alpine_base /etc/alpine-release /app/alpine-release
COPY --from=base /etc/os-release /app/ubuntu-release

WORKDIR /app

CMD ["ls", "-l"]

Analicemos este Dockerfile:

  • FROM ubuntu:latest AS base: Esta línea establece la imagen base para la primera etapa de nuestra construcción como ubuntu:latest y nombra esta etapa base.
  • FROM alpine:latest AS alpine_base: Esta línea inicia una nueva etapa de construcción usando alpine:latest como imagen base y nombra esta etapa alpine_base. Esta es una construcción multi-etapa, permitiéndonos copiar archivos entre etapas.
  • COPY --from=alpine_base /etc/alpine-release /app/alpine-release: Este comando copia el archivo /etc/alpine-release de la etapa alpine_base al directorio /app/alpine-release en la etapa actual.
  • COPY --from=base /etc/os-release /app/ubuntu-release: Este comando copia el archivo /etc/os-release de la etapa base al directorio /app/ubuntu-release en la etapa actual.
  • WORKDIR /app: Establece el directorio de trabajo para las instrucciones posteriores como /app.
  • CMD ["ls", "-l"]: Especifica el comando predeterminado que se ejecutará cuando se inicie un contenedor desde esta imagen. Listará los contenidos del directorio /app.

Guarda el Dockerfile presionando Ctrl + X, luego Y, y Enter.

Ahora, construye la imagen usando el comando docker build. El . al final del comando especifica el contexto de construcción, que es el directorio actual (~/project).

docker build -t my-multi-stage-image:latest ~/project

Deberías ver una salida que indica el proceso de construcción, incluyendo las diferentes etapas que se están ejecutando.

[+] Building
...
Successfully built <image_id>
Successfully tagged my-multi-stage-image:latest

Una vez completada la construcción, puedes verificar que la imagen fue creada listando tus imágenes locales.

docker images my-multi-stage-image

Deberías ver tu nueva imagen en la lista.

REPOSITORY             TAG       IMAGE ID       CREATED         SIZE
my-multi-stage-image   latest    <image_id>     About a minute ago   ...MB

Finalmente, ejecutemos un contenedor desde esta imagen para ver los archivos copiados.

docker run --rm my-multi-stage-image:latest

La bandera --rm elimina automáticamente el contenedor cuando termina. La salida debería mostrar los archivos copiados de las imágenes ubuntu y alpine.

total 8
-rw-r--r-- 1 root root 25 Aug 24 10:00 alpine-release
-rw-r--r-- 1 root root 281 Aug 24 10:00 ubuntu-release

Esto confirma que hemos creado exitosamente una imagen combinando contenido de múltiples imágenes fuente usando una construcción multi-etapa.

Etiquetar la imagen recién creada

En este paso, aprenderemos cómo añadir etiquetas adicionales a la imagen de Docker que creamos en el paso anterior. Etiquetar una imagen es útil para el control de versiones, identificar diferentes builds o asociar una imagen con un repositorio específico.

En el paso anterior, construimos una imagen y la etiquetamos automáticamente como my-multi-stage-image:latest. Ahora, añadiremos otra etiqueta a esta imagen, por ejemplo, my-multi-stage-image:v1.0.

El comando docker tag se utiliza para crear una etiqueta TARGET_IMAGE que hace referencia a SOURCE_IMAGE. La sintaxis es docker tag SOURCE_IMAGE[:TAG] TARGET_IMAGE[:TAG].

Primero, listemos las imágenes existentes para confirmar el ID de la imagen my-multi-stage-image:latest.

docker images my-multi-stage-image

Verás una salida similar a esta, donde <image_id> es el identificador único de tu imagen:

REPOSITORY             TAG       IMAGE ID       CREATED         SIZE
my-multi-stage-image   latest    <image_id>     ...             ...MB

Ahora, usa el comando docker tag para añadir la etiqueta v1.0 a esta imagen. Puedes usar tanto el nombre y etiqueta de la imagen (my-multi-stage-image:latest) como el ID de la imagen (<image_id>) como fuente. Usar el nombre y etiqueta es generalmente más fácil.

docker tag my-multi-stage-image:latest my-multi-stage-image:v1.0

Este comando crea una nueva etiqueta v1.0 que apunta al mismo ID de imagen que my-multi-stage-image:latest. No habrá salida si el comando se ejecuta correctamente.

Para verificar que se ha añadido la nueva etiqueta, lista las imágenes nuevamente.

docker images my-multi-stage-image

Ahora deberías ver ambas etiquetas asociadas al mismo ID de imagen:

REPOSITORY             TAG       IMAGE ID       CREATED         SIZE
my-multi-stage-image   latest    <image_id>     ...             ...MB
my-multi-stage-image   v1.0      <image_id>     ...             ...MB

Has añadido exitosamente una nueva etiqueta a tu imagen de Docker. Esto te permite referirte a la misma imagen usando diferentes nombres o versiones.

Mostrar la imagen final sin hacer push usando --dry-run

En este paso, exploraremos cómo ver los detalles de la imagen final que se enviaría a un registro sin realizar realmente la operación de push. Esto es útil para inspeccionar el manifiesto y configuración de la imagen antes de compartirla.

El comando docker manifest permite inspeccionar y gestionar manifiestos de imágenes. Un manifiesto de imagen es un documento JSON que describe la imagen, incluyendo sus capas, configuración y potencialmente referencias a otras imágenes específicas de plataforma en una lista de manifiestos.

Para mostrar el manifiesto de nuestra imagen my-multi-stage-image:latest sin hacer push, podemos usar el comando docker manifest inspect con la bandera --dry-run.

docker manifest inspect --dry-run my-multi-stage-image:latest

Este comando mostrará el manifiesto de la imagen en formato JSON en tu terminal. La bandera --dry-run evita que el comando intente contactar con un registro o enviar cualquier dato.

La salida será una estructura JSON detallada que describe la imagen. Incluirá información como la configuración de la imagen, las capas que la componen (representadas por sus digests) y otros metadatos.

{
   "schemaVersion": 2,
   "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
   "config": {
      "mediaType": "application/vnd.docker.container.image.v1+json",
      "size": ...,
      "digest": "sha256:..."
   },
   "layers": [
      {
         "mediaType": "application/vnd.docker.image.rootfs.diff.tar.gzip",
         "size": ...,
         "digest": "sha256:..."
      },
      ...
   ]
}

Puedes examinar esta salida para entender la estructura y contenido de tu imagen como estaría representada en un registro. Esto es particularmente útil para depuración o verificación de la composición de la imagen.

Nota que el contenido exacto del JSON variará dependiendo de las capas y configuración de la imagen.

Añadir anotaciones al índice de imagen creado

En este paso, aprenderemos cómo añadir anotaciones a un índice de imagen (también conocido como lista de manifiestos). Un índice de imagen se utiliza para hacer referencia a múltiples manifiestos de imagen, típicamente para diferentes arquitecturas o sistemas operativos. Añadir anotaciones al índice proporciona metadatos sobre todo el conjunto de imágenes.

Aunque nuestra imagen actual my-multi-stage-image es de una sola arquitectura, podemos demostrar el concepto de añadir anotaciones a su manifiesto, que en este caso actúa como un índice simple.

El comando docker manifest annotate se utiliza para añadir o actualizar anotaciones para una imagen específica dentro de una lista de manifiestos. La sintaxis es docker manifest annotate MANIFEST_LIST IMAGE --annotation KEY=VALUE.

Primero, creemos una lista de manifiestos para nuestra imagen. Como solo tenemos una imagen, la lista de manifiestos simplemente hará referencia a nuestra imagen existente. Usaremos el comando docker manifest create.

docker manifest create my-multi-stage-image:annotated my-multi-stage-image:latest

Este comando crea una nueva lista de manifiestos llamada my-multi-stage-image:annotated que incluye una referencia a my-multi-stage-image:latest. No habrá salida si tiene éxito.

Ahora, podemos usar el comando docker manifest annotate para añadir una anotación a la entrada de my-multi-stage-image:latest dentro de la lista de manifiestos my-multi-stage-image:annotated. Añadamos una anotación que indique el sistema operativo.

docker manifest annotate my-multi-stage-image:annotated my-multi-stage-image:latest --annotation "os=linux"

Este comando añade la anotación os=linux a la entrada del manifiesto para my-multi-stage-image:latest dentro de la lista my-multi-stage-image:annotated. Nuevamente, no hay salida si se ejecuta correctamente.

Para verificar que se ha añadido la anotación, podemos inspeccionar la lista de manifiestos usando docker manifest inspect.

docker manifest inspect my-multi-stage-image:annotated

La salida será una estructura JSON que representa la lista de manifiestos. Deberías ver la anotación que añadiste dentro de la entrada para my-multi-stage-image:latest. Busca el campo "annotations" dentro del array "manifests".

{
   "schemaVersion": 2,
   "mediaType": "application/vnd.docker.distribution.manifest.list.v2+json",
   "manifests": [
      {
         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
         "size": ...,
         "digest": "sha256:...",
         "platform": {
            "architecture": "amd64",
            "os": "linux"
         },
         "annotations": {
            "os": "linux"
         }
      }
   ]
}

Has añadido exitosamente una anotación al índice de imagen. Las anotaciones proporcionan metadatos valiosos que pueden ser utilizados por registros y clientes para entender más sobre las imágenes con las que están trabajando.

Resumen

En este laboratorio, aprendimos cómo usar el comando docker buildx imagetools create para combinar y etiquetar imágenes. Comenzamos creando una nueva imagen a partir de múltiples imágenes fuente utilizando un Dockerfile multi-etapa, demostrando cómo copiar archivos entre diferentes imágenes base.

Después de la creación de la imagen, exploramos cómo etiquetar la imagen recién creada y utilizamos la bandera --dry-run para previsualizar la imagen final sin enviarla. Finalmente, aprendimos cómo añadir anotaciones al índice de imagen creado, proporcionando metadatos adicionales para la imagen combinada.