Cómo usar el comando docker manifest create para construir imágenes multi-arquitectura

Introducción

En este laboratorio, aprenderá cómo construir y gestionar imágenes Docker multi-arquitectura utilizando el comando docker manifest create. Las imágenes multi-arquitectura son esenciales para desplegar aplicaciones en diversos entornos con diferentes arquitecturas de CPU, como amd64 y arm64.

El laboratorio lo guiará a través del proceso de preparación de imágenes multi-arquitectura habilitando características experimentales y creando una instancia de constructor multi-arquitectura. Luego, creará una lista de manifiestos que agrupe estas imágenes, inspeccionará la lista de manifiestos creada para verificar su contenido y, finalmente, enviará la lista de manifiestos a un registro, lo que hará que su imagen multi-arquitectura esté disponible para el despliegue en varias plataformas.

Skills Graph

Preparar imágenes multi-arquitectura

En este paso, prepararemos imágenes multi-arquitectura. Las imágenes multi-arquitectura te permiten construir y enviar imágenes que pueden ejecutarse en diferentes arquitecturas, como amd64 y arm64. Esto es útil para desplegar aplicaciones en diversos entornos, incluyendo servidores en la nube, dispositivos perimetrales y máquinas locales.

Primero, necesitamos habilitar las características experimentales en Docker. Esto nos permite utilizar el comando buildx, que es necesario para construir imágenes multi-arquitectura. Podemos hacer esto creando o modificando el archivo de configuración de Docker.

Abre el archivo de configuración de Docker utilizando nano:

nano ~/.docker/config.json

Si el archivo no existe, nano lo creará. Agrega el siguiente contenido al archivo. Si el archivo ya existe, agrega la línea "experimental": "enabled" dentro del objeto JSON principal.

{
  "experimental": "enabled"
}

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

A continuación, necesitamos crear una nueva instancia de constructor que soporte múltiples arquitecturas. Una instancia de constructor es un componente de Docker que gestiona el proceso de construcción.

Crea una nueva instancia de constructor llamada mybuilder:

docker buildx create --name mybuilder --use

Este comando crea una nueva instancia de constructor llamada mybuilder y la establece como el constructor predeterminado para las operaciones de construcción posteriores. La salida debe indicar que el constructor se ha creado y se está utilizando.

Ahora, construyamos una simple imagen multi-arquitectura. Utilizaremos un Dockerfile básico que crea una imagen basada en Alpine Linux.

Crea un directorio para nuestro proyecto y navega hacia él:

mkdir ~/project/multiarch-demo
cd ~/project/multiarch-demo

Crea un Dockerfile en este directorio:

nano Dockerfile

Agrega el siguiente contenido al Dockerfile:

FROM alpine:latest
CMD ["echo", "Hello from multi-architecture image!"]

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

Ahora, construye la imagen para las arquitecturas linux/amd64 y linux/arm64 y envíala a un registro ficticio. Utilizaremos localhost:5000 como marcador de posición para el registro. En un escenario real, reemplazarías esto con la dirección real de tu registro.

Construye y envía la imagen multi-arquitectura:

docker buildx build --platform linux/amd64,linux/arm64 -t localhost:5000/multiarch-demo:latest --push .

Este comando construye la imagen para las plataformas especificadas (linux/amd64 y linux/arm64), la etiqueta como localhost:5000/multiarch-demo:latest y la envía al registro localhost:5000. La salida mostrará el proceso de construcción para cada arquitectura y la operación de envío.

Crear una lista de manifiestos para las imágenes

En este paso, crearemos una lista de manifiestos para las imágenes multi-arquitectura que construimos en el paso anterior. Una lista de manifiestos es una lista de manifiestos de imágenes, cada uno para una arquitectura diferente. Cuando se extrae una imagen utilizando una lista de manifiestos, Docker selecciona automáticamente la imagen correcta para su arquitectura.

Utilizaremos el comando docker manifest create para crear la lista de manifiestos. Este comando toma el nombre de la lista de manifiestos que desea crear, seguido de los nombres de las imágenes que desea incluir en la lista.

Crea una lista de manifiestos llamada localhost:5000/multiarch-demo:latest:

docker manifest create localhost:5000/multiarch-demo:latest \
  localhost:5000/multiarch-demo:latest@sha256:$(docker buildx imagetools inspect localhost:5000/multiarch-demo:latest | grep 'Digest:' | awk '{print $2}' | head -n 1) \
  localhost:5000/multiarch-demo:latest@sha256:$(docker buildx imagetools inspect localhost:5000/multiarch-demo:latest | grep 'Digest:' | awk '{print $2}' | tail -n 1)

Desglosemos este comando:

• docker manifest create localhost:5000/multiarch-demo:latest: Esto especifica el nombre de la lista de manifiestos que estamos creando.
• localhost:5000/multiarch-demo:latest@sha256:...: Estas son las imágenes que estamos agregando a la lista de manifiestos. Estamos utilizando el nombre de la imagen seguido de @sha256: y el resumen (digest) de la imagen. El resumen identifica de manera única una capa de imagen específica.
• $(docker buildx imagetools inspect localhost:5000/multiarch-demo:latest | grep 'Digest:' | awk '{print $2}' | head -n 1): Esta cadena de comandos recupera el resumen de la primera imagen enumerada por docker buildx imagetools inspect.
• $(docker buildx imagetools inspect localhost:5000/multiarch-demo:latest | grep 'Digest:' | awk '{print $2}' | tail -n 1): Esta cadena de comandos recupera el resumen de la segunda imagen enumerada por docker buildx imagetools inspect.

La salida del comando docker manifest create será el resumen de la lista de manifiestos recién creada.

Inspeccionar la lista de manifiestos creada

En este paso, inspeccionaremos la lista de manifiestos que creamos en el paso anterior. Inspeccionar la lista de manifiestos nos permite ver qué imágenes se incluyen en la lista y sus detalles, como la arquitectura y el sistema operativo.

Utilizaremos el comando docker manifest inspect para ver los detalles de la lista de manifiestos.

Inspecciona la lista de manifiestos localhost:5000/multiarch-demo:latest:

docker manifest inspect localhost:5000/multiarch-demo:latest

La salida de este comando será un documento JSON que describe la lista de manifiestos. Deberías ver una matriz de "manifiestos", cada uno representando una imagen para una arquitectura diferente. Busca el campo "platform" dentro de cada entrada de manifiesto para ver la arquitectura y el sistema operativo. Deberías ver entradas tanto para linux/amd64 como para linux/arm64.

Esta inspección confirma que nuestra lista de manifiestos incluye correctamente las imágenes para las diferentes arquitecturas que construimos.

Empujar la lista de manifiestos a un registro

En este paso, empujaremos la lista de manifiestos que creamos a un registro. Empujar la lista de manifiestos la hace disponible para que otros extraigan la imagen multi-arquitectura. Cuando alguien extrae la imagen utilizando la etiqueta de la lista de manifiestos, Docker descargará automáticamente la imagen correcta para la arquitectura de su sistema.

Utilizaremos el comando docker manifest push para empujar la lista de manifiestos.

Empuja la lista de manifiestos localhost:5000/multiarch-demo:latest al registro:

docker manifest push localhost:5000/multiarch-demo:latest

Este comando empuja la lista de manifiestos y todas las imágenes a las que hace referencia al registro especificado (localhost:5000). Dado que ya empujamos las imágenes individuales en el primer paso utilizando docker buildx build --push, este comando principalmente empuja la lista de manifiestos en sí.

La salida mostrará el progreso del empuje de la lista de manifiestos.

Después de empujar la lista de manifiestos, puedes verificar que está disponible en el registro. Aunque no tenemos un registro en ejecución en este entorno de laboratorio para consultar directamente, la ejecución exitosa del comando docker manifest push indica que la lista de manifiestos está lista para ser empujada.

Para simular la extracción de la imagen multi-arquitectura y verificar que Docker selecciona la arquitectura correcta, podrías intentar extraer la imagen en un sistema con una arquitectura diferente (si está disponible). Sin embargo, dentro de este entorno de laboratorio, podemos confiar en el comando de empuje exitoso y en el paso de inspección anterior para confirmar que la lista de manifiestos está lista.

Resumen

En este laboratorio, aprendimos cómo preparar imágenes multi-arquitectura utilizando Docker. Esto implica habilitar características experimentales en Docker para utilizar el comando buildx, que es esencial para construir imágenes compatibles con diferentes arquitecturas como amd64 y arm64. Configuramos el cliente de Docker modificando el archivo config.json para habilitar las características experimentales. Posteriormente, creamos una nueva instancia de constructor llamada mybuilder utilizando docker buildx create --name mybuilder --use, que es capaz de gestionar construcciones multi-arquitectura. Finalmente, configuramos un directorio de proyecto básico y creamos un Dockerfile simple basado en Alpine Linux como base para construir nuestra imagen multi-arquitectura.