Esta página se ha traducido con Cloud Translation API.

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

Autopilot Standard

En esta página se explica qué son las imágenes de varias arquitecturas, por qué son importantes las arquitecturas de los nodos y las imágenes de contenedor, y por qué las imágenes de varias arquitecturas facilitan el despliegue de cargas de trabajo en clústeres de GKE. En esta página también se explica cómo comprobar si tus cargas de trabajo están listas para ejecutarse en Arm y cómo puedes crear imágenes de varias arquitecturas.

Para ver un tutorial sobre cómo desplegar aplicaciones en varias arquitecturas con imágenes multiarquitectura, consulta Migrar una aplicación x86 en GKE a una multiarquitectura con Arm.

¿Qué es una imagen multiarquitectura?

Una imagen multiarquitectura es una imagen que puede admitir 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 de varias arquitecturas son compatibles con el esquema 2 del manifiesto de imagen de Docker V2 o con las especificaciones del índice de imágenes de OCI. Cuando despliegas una imagen de varias arquitecturas en un clúster, GKE elige automáticamente la imagen adecuada que sea compatible con la arquitectura del nodo en el que se va a desplegar. Una vez que tengas una imagen de varias arquitecturas para una carga de trabajo, podrás desplegarla sin problemas en varias arquitecturas.

Las imágenes de varias arquitecturas son más útiles cuando quieres usar la misma carga de trabajo en diferentes arquitecturas. También puedes usar imágenes de contenedor con una sola arquitectura con cualquier tipo de nodo de GKE. Si solo usas una carga de trabajo en una arquitectura y ya tienes una imagen compatible, no es necesario que compiles una imagen de varias arquitecturas.

Si usas una imagen de una sola arquitectura o de varias arquitecturas que sea compatible con Arm y quieres desplegarla en un nodo Arm, debes seguir las instrucciones para incluir los campos necesarios de forma que GKE programe la carga de trabajo como se espera. Para obtener más información, consulta Prepara una carga de trabajo de Arm para el despliegue. No es necesario que añada estos campos para programar cargas de trabajo si solo se van a programar 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 de VM de Compute Engine individuales que GKE crea y gestiona 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 quieras ejecutar las cargas de trabajo. Por ejemplo, si quieres ejecutar una imagen de contenedor con la arquitectura arm64, debes usar un tipo de máquina que admita cargas de trabajo 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 quieres usar una carga de trabajo en varios tipos de arquitectura, debes mantener organizadas todas las imágenes de contenedor y los archivos de implementación de las imágenes específicas de la arquitectura. Las imágenes de varias arquitecturas simplifican el proceso de implementación en diferentes tipos de arquitectura.

Crear una imagen de varias arquitecturas para desplegarla en nodos x86 y Arm

Las siguientes instrucciones están dirigidas a los desarrolladores de aplicaciones que ya tengan lo siguiente:

un entorno de compilación con una herramienta de contenedores descargada (por ejemplo, Docker).
una imagen de contenedor que ya existe.

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

¿Está mi carga de trabajo lista para Arm?

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

Preparar Docker en un entorno x86 para comprobar 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 gestión de paquetes, pero puedes usar el gestor de paquetes de tu entorno para descargar los paquetes necesarios.

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

Los siguientes comandos descargan paquetes y registran QEMU como intérprete de binfmt para 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 tu entorno x86.

Comprobar si la carga de trabajo está preparada para Arm

Si estás ejecutando Docker en un entorno Arm o has preparado tu entorno x86 para ejecutar imágenes Arm, ejecuta el siguiente comando:

docker run --platform linux/arm64 IMAGE_NAME

Sustituye IMAGE_NAME por el nombre de la imagen del 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 ir a Prepara una carga de trabajo de Arm para el despliegue.

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 se trata de una imagen x86_64 o amd64, por lo que debes crear una imagen arm64. Ve a la siguiente sección, Crear una imagen de varias arquitecturas, donde puedes usar una imagen de contenedor no compatible con Arm, un Dockerfile y crear una imagen de varias arquitecturas que se pueda ejecutar en diferentes tipos de arquitectura.

Crear una imagen de varios arcos

Si tienes un Dockerfile, puedes usarlo para crear una imagen de arquitectura múltiple compatible con Arm y x86 que puedes desplegar en nodos con diferentes tipos de arquitectura.

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

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

En los siguientes comandos se da por hecho que tienes una VM de compilación Arm y una VM de compilación x86 en tu entorno de compilación, y que tu VM x86 puede usar SSH como raíz en tu VM Arm. Si solo tienes una máquina virtual x86 en tu entorno de compilación, sigue las instrucciones de la siguiente sección: Preparar el entorno si solo tienes una máquina virtual x86.

Prepara tu entorno para crear imágenes de varias arquitecturas:

Crea un contexto para el nodo x86 mediante el socket local y un contexto para el nodo Arm mediante SSH:

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

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

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

Sustituye BUILDER_NAME por el nombre que elijas para el compilador de Buildx.

Preparar el entorno si solo tienes una máquina virtual x86

Si solo tiene una VM x86 en su entorno de compilación, puede seguir estos pasos para preparar su entorno y compilar imágenes de varias arquitecturas. Con esta opción, el paso de compilación puede tardar más.

Instala los paquetes de QEMU:

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

Crea un compilador multiarquitectura (el compilador predeterminado no admite multiarquitectura):
```
docker buildx create --name BUILDER_NAME --use
```
Sustituye BUILDER_NAME por el nombre que elijas para el compilador de Buildx.

Crear la imagen

Ahora que tu entorno está listo, ejecuta el siguiente comando para crear una imagen de varias arquitecturas:

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

Sustituye PATH_TO_REGISTRY por la ruta a tu registro, que termina con el nombre de tu imagen de contenedor y una etiqueta (por ejemplo, gcr.io/myproject/myimage:latest).

Si aparece un mensaje de error en este paso, consulta la guía de Docker y la documentación asociada para solucionar el problema.

Una vez que hayas creado una imagen de varias arquitecturas, tu carga de trabajo estará lista para ejecutarse en Arm. Ve a Prepara una carga de trabajo de Arm para el despliegue.