Criar imagens de multiarquitetura para cargas de trabalho do Arm

Autopilot Standard

---

Nesta página, explicamos o que são imagens de multiarquitetura (várias arquiteturas), por quê as arquiteturas de nós e imagens de contêiner são importantes e por quê as imagens de várias arquiteturas facilitam a implantação de cargas de trabalho em clusters do GKE. Esta página também oferece orientações sobre como verificar se as cargas de trabalho estão prontas para serem executadas no Arm e como criar imagens de multiarquitetura.

Para ver um tutorial de implantação entre arquiteturas com imagens de várias arquiteturas, consulte Migrar o aplicativo x86 no GKE para várias arquiteturas com Arm.

Observação: as instruções nesta página fornecem apenas um caminho para a verificação da prontidão do Arm e a criação de imagens de várias arquiteturas. Recomendamos que você consulte a documentação dessas ferramentas e desenvolva seu próprio caminho para realizar essas tarefas com base nas necessidades do ambiente e da carga de trabalho. As ferramentas de terceiros usadas aqui não são compatíveis com o GKE e podem ser alteradas a qualquer momento sem aviso prévio.

O que é uma imagem de várias arquiteturas?

Uma imagem com várias setas é compatível com várias arquiteturas. Parece uma única imagem com uma única tag, mas é uma lista de imagens que segmentam várias arquiteturas organizadas por uma lista de manifestos. As imagens em várias arquiteturas são compatíveis com o Esquema 2 do Manifest V2 da imagem Docker ou com as Especificações do índice de imagens OCI. Quando você implanta uma imagem de várias arquiteturas em um cluster, o GKE escolhe automaticamente a imagem correta que é compatível com a arquitetura do nó em que está sendo implantada. Depois que você tiver uma imagem de várias arquiteturas para uma carga de trabalho, será possível implantá-la perfeitamente em várias arquiteturas.

As imagens de multiarquiteturas são mais úteis quando você quer usar a mesma carga de trabalho em arquiteturas. Como alternativa, é possível usar imagens de contêiner com uma única arquitetura com qualquer tipo de nós do GKE. Se você estiver usando apenas uma carga de trabalho em uma arquitetura e já tiver uma imagem compatível, não será necessário criar uma imagem de várias arquiteturas.

Se você estiver usando uma imagem de arquitetura única ou de várias arquiteturas compatíveis com o Arm e quiser implantá-la em um nó do Arm, siga as instruções para incluir os campos necessários para que o GKE programe a carga de trabalho conforme esperado. Para saber mais, consulte Preparar uma carga de trabalho do Arm para implantação. Não é preciso adicionar esses campos para programar cargas de trabalho se elas forem programadas somente para nós baseados em x86.

Por que a arquitetura de um nó do GKE é importante para as cargas de trabalho?

Os nós do GKE são instâncias de VM individuais do Compute Engine que o GKE cria e gerencia em seu nome. Cada nó é de um tipo de máquina padrão (por exemplo, t2a-standard-1) que usa processadores do Arm ou x86 (Intel ou AMD). Para saber mais, consulte Plataformas de CPU.

É preciso usar imagens de contêiner compatíveis com a arquitetura do nó em que você pretende executar as cargas de trabalho. Por exemplo, se você quiser executar uma imagem de contêiner com a arquitetura arm64, será necessário um tipo de máquina compatível com as cargas de trabalho do Arm, como t2a-standard-1, da série de máquinas Tau T2A. É possível usar nós com vários tipos de arquitetura em um cluster do GKE. Se você quiser usar uma carga de trabalho em vários tipos de arquitetura, mantenha todas as imagens de contêiner e arquivos de implantação para a imagem específica da arquitetura organizada. Imagens de várias arquiteturas simplificam o processo de implantação em tipos de arquitetura.

Criar uma imagem de várias arquiteturas para implantação em nós x86 e do Arm

Aviso: as instruções a seguir fornecem orientações sobre como verificar a prontidão do Arm e criar imagens de várias arquiteturas. Estes exemplos usam ferramentas de terceiros não compatíveis que podem ser alteradas a qualquer momento sem aviso prévio do GKE.

As instruções a seguir são para desenvolvedores de apps que já têm:

• um ambiente de build com uma ferramenta de contêiner transferida por download (por exemplo, Docker);
• uma imagem de contêiner.

Os comandos a seguir usam o Docker, mas você pode usar outras ferramentas de contêiner para realizar as mesmas tarefas.

Minha carga de trabalho está pronta para o Arm?

Se já houver uma imagem de contêiner, verifique se essa carga de trabalho está pronta para ser executada em um nó do Arm. As seções a seguir explicam como fazer isso usando docker run para tentar executar o contêiner com a arquitetura do Arm.

Preparar o Docker no seu ambiente x86 para verificar uma imagem de contêiner

Se você estiver executando o Docker em um ambiente x86, faça o download de outros pacotes para executar uma imagem de contêiner arm64. Estas instruções usam o apt para gerenciar pacotes, mas é possível usar o gerenciador de pacotes do ambiente para fazer o download dos pacotes necessários.

Pule esta seção se você estiver executando o Docker em um ambiente Arm.

Os comandos a seguir fazem o download de pacotes e registram o QEMU como o interpretador binfmt para arquiteturas não compatíveis com sua máquina:

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

Depois de definir os intérpretes da binfmt, execute a imagem arm64 no ambiente x86.

Verificar se a carga de trabalho está pronta para o Arm

Se você estiver executando o Docker em um ambiente Arm ou tiver preparado o ambiente x86 para executar imagens Arm, execute o seguinte comando:

docker run --platform linux/arm64 IMAGE_NAME

Substitua IMAGE_NAME pelo nome da imagem de contêiner.

A resposta a seguir indica que a imagem do contêiner está pronta para ser executada em nós do Arm com o cluster do GKE:

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

Se a carga de trabalho estiver pronta para ser executada no Arm, prossiga para Preparar uma carga de trabalho do Arm para implantação.

O resultado a seguir indica que a imagem não está pronta para ser executada no 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

Essa saída indica que é uma imagem x86_64 ou amd64 e que você precisa criar uma imagem arm64. Prossiga para a próxima seção, Criar uma imagem de várias arquiteturas, em que você pode usar uma imagem de contêiner não compatível com o Arm, um Dockerfile e criar uma imagem de várias arquiteturas que podem ser executados em vários tipos de arquitetura.

Criar uma imagem de várias arquiteturas

Se você tiver um Dockerfile, poderá usá-lo para criar uma imagem de várias arquiteturas compatível com Arm e x86 que possa ser implantada em nós com diferentes tipos de arquitetura.

Faça o download do Docker Buildx para concluir as etapas a seguir. É necessário também ter um Dockerfile.

Preparar seu ambiente se você tiver uma VM x86 e uma VM do Arm

Os comandos a seguir presumem que você tem uma VM de build do Arm e uma VM de build x86 no seu ambiente de build, e sua VM x86 pode usar o SSH como raiz na VM do Arm. Se você tem apenas uma VM x86 no seu ambiente de build, siga as instruções na próxima seção: Preparar seu ambiente se você tiver apenas uma VM x86.

Prepare o ambiente para criar imagens de várias arquiteturas:

1. Crie um contexto para o nó x86 usando o soquete local e um contexto para o nó do Arm usando SSH:

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

   Substitua NODE_IP pelo endereço IP do nó do Arm.

2. Crie um builder usando o nó 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
   

   Substitua BUILDER_NAME por um nome escolhido para o builder da Buildx.

Preparar seu ambiente se você tiver apenas uma VM x86

Se você tiver apenas uma VM x86 no seu ambiente de build, siga estas etapas para preparar seu ambiente para a criação de imagens de várias arquiteturas. Com essa opção, a etapa de build pode levar mais tempo.

1. Instale os pacotes QEMU:

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

2. Crie um builder de multiarquiteturas (o builder padrão não é compatível com várias arquiteturas):

   docker buildx create --name BUILDER_NAME --use
   

   Substitua BUILDER_NAME por um nome escolhido para o builder da Buildx.

Criar a imagem

Agora que o ambiente está pronto, execute o seguinte comando para criar uma imagem de várias arquiteturas:

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

Substitua PATH_TO_REGISTRY pelo caminho para seu registro, terminando com o nome da sua imagem de contêiner e uma tag (por exemplo, gcr.io/myproject/myimage:latest).

Se você receber uma mensagem de erro nesta etapa, consulte o guia do Docker e a documentação associada para resolver problemas.

Depois de criar uma imagem de várias arquiteturas, sua carga de trabalho estará pronta para ser executada no Arm. Prossiga para Preparar uma carga de trabalho do Arm para implantação.

A seguir

• Preparar uma carga de trabalho do Arm para implantação
• Migrar um aplicativo x86 no GKE para várias arquiteturas com Arm