Compila imágenes de varias arquitecturas para cargas de trabajo de Arm

En esta página, se explica qué son las imágenes de varias arquitecturas (multiarquitectura), por qué las arquitecturas de nodos y las imágenes de contenedor son importantes, y por qué las imágenes multiarquitectura facilitan la implementación de cargas de trabajo en clústeres de GKE. En esta página, también se proporciona orientación sobre cómo verificar si tus cargas de trabajo están listas para ejecutarse en Arm y cómo compilar imágenes multiarquitectura.

Para obtener un instructivo sobre cómo implementar en arquitecturas con imágenes multiarquitectura, consulta Migra la aplicación x86 en GKE a varias arquitecturas con Arm.

¿Qué es una imagen multiarquitectura?

Una imagen multiarquitectura es una imagen que admite varias arquitecturas. Parece una sola imagen con una sola etiqueta, pero es una lista de imágenes orientadas a varias arquitecturas organizadas por una lista de manifiestos. Las imágenes multiarquitectura son compatibles con Docker Image Manifest V2 Scheme 2 y con OCI Image Index Specifications. Cuando implementas una imagen multiarquitectura en un clúster, GKE elige automáticamente la imagen correcta que es compatible con la arquitectura del nodo en el que se implementa. Una vez que tengas una imagen multiarquitectura para una carga de trabajo, puedes implementarla sin problemas en varias arquitecturas.

Las imágenes multiarquitectura son más útiles cuando deseas usar la misma carga de trabajo en varias arquitecturas. Como alternativa, puedes usar imágenes de contenedor con una sola arquitectura con cualquier tipo de nodos de GKE. Si solo usas una carga de trabajo en una arquitectura y ya tienes una imagen compatible, no necesitas compilar una imagen multiarquitectura.

Si usas una imagen de una sola arquitectura o una imagen multiarquitectura que es compatible con Arm y deseas implementarla en un nodo de Arm, debes seguir las instrucciones para incluir los campos necesarios a fin de que GKE programe la carga de trabajo como espera. A fin de obtener más información, consulta Prepara una carga de trabajo de Arm para la implementación. No es necesario que agregues estos campos para programar las cargas de trabajo si estas solo se programarán en nodos basados en x86.

¿Por qué es importante la arquitectura de un nodo de GKE para las cargas de trabajo?

Los nodos de GKE son instancias individuales de VM de Compute Engine que GKE crea y administra en tu nombre. Cada nodo es de un tipo de máquina estándar (por ejemplo, t2a-standard-1) que usa procesadores x86 (Intel o AMD) o Arm. Para obtener más información, consulta Plataformas de CPU.

Debes usar imágenes de contenedor que sean compatibles con la arquitectura del nodo en el que deseas ejecutar las cargas de trabajo. Por ejemplo, si deseas ejecutar una imagen de contenedor con la arquitectura arm64, debes usar un tipo de máquina que admita cargas de trabajo de Arm, como t2a-standard-1 de la serie de máquinas Tau T2A. Puedes usar nodos con varios tipos de arquitectura en un clúster de GKE. Si deseas usar una carga de trabajo en varios tipos de arquitectura, debes mantener todas las imágenes de contenedor y los archivos de implementación organizados para las imágenes específicas de cada arquitectura. Las imágenes multiarquitectura simplifican el proceso de implementación en diferentes tipos de arquitectura.

Compila una imagen multiarquitectura para implementarla en los nodos x86 y Arm

Las siguientes instrucciones son para los desarrolladores de apps que ya tienen lo siguiente:

  • un entorno de compilación con una herramienta de contenedor descargada (por ejemplo, Docker)
  • una imagen de contenedor existente

Los siguientes comandos usan Docker, pero es posible que puedas usar otras herramientas de contenedores para ejecutar las mismas tareas.

¿Mi carga de trabajo está lista para Arm?

Si tienes una imagen de contenedor existente, puedes verificar si esta carga de trabajo está lista para ejecutarse en un nodo de Arm. En las siguientes secciones, se explica cómo hacerlo mediante docker run para intentar ejecutar el contenedor con la arquitectura de Arm.

Prepara Docker en tu entorno x86 para verificar una imagen de contenedor

Si ejecutas Docker en un entorno x86, debes descargar paquetes adicionales para ejecutar una imagen de contenedor arm64. En estas instrucciones, se usa apt para la administración de paquetes, pero puedes usar el administrador de paquetes de tu entorno a fin de descargar los paquetes necesarios.

Si ejecutas Docker en un entorno de Arm, puedes omitir esta sección.

Mediante los siguientes comandos, se descargan paquetes y se registra QEMU como el intérprete de binfmt para las arquitecturas que tu máquina no admite:

sudo apt-get install qemu binfmt-support qemu-user-static
docker run --rm --privileged multiarch/qemu-user-static --reset -p yes

Después de configurar los intérpretes de binfmt, puedes ejecutar la imagen arm64 en el entorno x86.

Verifica si la carga de trabajo está preparada para Arm

Si ejecutas Docker en un entorno de Arm o preparaste tu entorno x86 para ejecutar imágenes de Arm, ejecuta el siguiente comando:

docker run --platform linux/arm64 IMAGE_NAME

Reemplaza IMAGE_NAME por el nombre de la imagen de contenedor.

El siguiente resultado indica que tu imagen de contenedor está lista para ejecutarse en nodos Arm con tu clúster de GKE:

Hello from Docker!
This message shows that your installation appears to be working correctly.

Si tu carga de trabajo está lista para ejecutarse en Arm, puedes continuar con la sección Prepara una carga de trabajo de Arm para la implementación.

El siguiente resultado indica que tu imagen no está lista para ejecutarse en Arm:

Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
93288797bd35: Pull complete
Digest: sha256:507ecde44b8eb741278274653120c2bf793b174c06ff4eaa672b713b3263477b
Status: Downloaded newer image for hello-world:latest
standard_init_linux.go:219: exec user process caused: exec format error

Este resultado indica que esta es una imagen x86_64 o amd64 y debes compilar una imagen arm64. Continúa a la siguiente sección, Compila una imagen multiarquitectura, en la que puedes usar una imagen de contenedor no compatible con ARM, un Dockerfile y compilar una imagen multiarquitectura que se puede ejecutar en diferentes tipos de arquitectura.

Compila una imagen multiarquitectura

Si tienes un Dockerfile, puedes usarlo para compilar una imagen multiarquitectura compatible con Arm y x86, que puedes implementar en nodos con diferentes tipos de arquitectura.

Debes descargar Docker Buildx para completar los siguientes pasos. También debes tener un Dockerfile existente.

Prepara el entorno si tienes una VM x86 y una VM Arm

Los siguientes comandos suponen que tienes una VM de compilación Arm y una VM de compilación x86 en tu entorno de compilación, y la VM x86 puede establecer una conexión SSH como raíz en tu VM de Arm. Si solo tienes una VM x86 en tu entorno de compilación, sigue las instrucciones de la siguiente sección, Prepara tu entorno si solo tienes una VM x86.

Prepara tu entorno para compilar imágenes multiarquitectura:

  1. Crea un contexto para el nodo x86 con el socket local y un contexto para el nodo Arm con SSH:

     docker context create amd_node --docker "host=unix:///var/run/docker.sock"
 docker context create arm_node --docker "host=ssh://root@NODE_IP"

    Reemplaza NODE_IP por la dirección IP del nodo Arm.

  2. Crea un compilador con el nodo x86:

    docker buildx create --use --name BUILDER_NAME --platform linux/amd64 amd_node
docker buildx create --append --name BUILDER_NAME --platform linux/arm64 arm_node

    Reemplaza BUILDER_NAME por un nombre que elijas para el compilador de Buildx.

Prepara tu entorno si solo tienes una VM x86

Si solo tienes una VM x86 en tu entorno de compilación, puedes seguir estos pasos a fin de preparar tu entorno para compilar imágenes multiarquitectura. Con esta opción, el paso de compilación puede tomar más tiempo.

  1. Instala los paquetes QEMU:

    docker run --rm --privileged multiarch/qemu-user-static

  2. Crea un compilador multiarquitectura (el compilador predeterminado no admite varias arquitecturas):

    docker buildx create --name BUILDER_NAME --use

    Reemplaza BUILDER_NAME por un nombre que elijas para el compilador de Buildx.

Compila la imagen

Ahora que tu entorno está listo, ejecuta el siguiente comando para compilar una imagen multiarquitectura:

docker buildx build . -t PATH_TO_REGISTRY  --platform linux/amd64,linux/arm64 --push

Reemplaza PATH_TO_REGISTRY por la ruta de acceso al registro, terminada en el nombre de tu imagen de contenedor y una etiqueta (por ejemplo, gcr.io/myproject/myimage:latest).

Si recibes un mensaje de error en este paso, consulta la guía de Docker y la documentación asociada para solucionar más problemas.

Una vez que hayas compilado una imagen multiarquitectura, tu carga de trabajo estará lista para ejecutarse en ARM. Continúa con la sección Prepara una carga de trabajo de Arm para la implementación.

¿Qué sigue?