Crie imagens de várias arquiteturas para cargas de trabalho Arm

Esta página explica o que são imagens de várias arquiteturas (multi-arch), por que motivo as arquiteturas dos nós e das imagens de contentores são importantes e por que motivo as imagens multi-arch facilitam a implementação de cargas de trabalho em clusters do GKE. Esta página também fornece orientações sobre como pode verificar se as suas cargas de trabalho estão prontas para serem executadas no Arm e como pode criar imagens de várias arquiteturas.

Para ver um tutorial sobre a implementação em várias arquiteturas com imagens multi-arquitetura, consulte o artigo Migre a aplicação x86 no GKE para multi-arquitetura com Arm.

O que é uma imagem com vários arcos?

Uma imagem multi-arquitetura é uma imagem que pode suportar várias arquiteturas. Parece uma única imagem com uma única etiqueta, mas é uma lista de imagens que segmentam várias arquiteturas organizadas por uma lista de manifesto. As imagens multi-arquitetura são compatíveis com o esquema 2 do manifesto de imagens do Docker V2 ou as especificações do índice de imagens da OCI. Quando implementa uma imagem de várias arquiteturas num cluster, o GKE escolhe automaticamente a imagem certa que é compatível com a arquitetura do nó no qual está a ser implementada. Depois de ter uma imagem de várias arquiteturas para uma carga de trabalho, pode implementar esta carga de trabalho sem problemas em várias arquiteturas.

As imagens multi-arquitetura são mais úteis quando quer usar a mesma carga de trabalho em várias arquiteturas. Em alternativa, pode usar imagens de contentores com uma arquitetura única com qualquer tipo de nós do GKE. Se estiver a usar apenas uma carga de trabalho numa arquitetura e já tiver uma imagem compatível, não precisa de criar uma imagem de várias arquiteturas.

Se estiver a usar uma imagem de arquitetura única ou uma imagem de arquitetura múltipla compatível com Arm e quiser implementá-la num nó Arm, tem de seguir as instruções para incluir os campos necessários para que o GKE agende a carga de trabalho conforme esperado. Para saber mais, consulte o artigo Prepare uma carga de trabalho Arm para implementação. Não precisa de adicionar estes campos para agendar cargas de trabalho se as cargas de trabalho forem agendadas apenas para nós baseados em x86.

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

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

Tem de usar imagens de contentores compatíveis com a arquitetura do nó onde pretende executar as cargas de trabalho. Por exemplo, se quiser executar uma imagem de contentor com a arquitetura arm64, tem de usar um tipo de máquina que suporte cargas de trabalho Arm, como t2a-standard-1 da série de máquinas Tau T2A. Pode usar nós com vários tipos de arquitetura num cluster do GKE. Se quiser usar uma carga de trabalho em vários tipos de arquitetura, tem de manter todas as imagens de contentores e os ficheiros de implementação das imagens específicas da arquitetura organizados. As imagens multi-arquitetura simplificam o processo de implementação em vários tipos de arquitetura.

Crie uma imagem de várias arquiteturas para implementar em nós x86 e Arm

As instruções seguintes destinam-se a programadores de apps que já tenham:

  • Um ambiente de compilação com uma ferramenta de contentores transferida (por exemplo, o Docker).
  • Uma imagem de contentor existente.

Os seguintes comandos usam o Docker, mas pode usar outras ferramentas de contentores para realizar as mesmas tarefas.

A minha carga de trabalho está pronta para a arquitetura Arm?

Se tiver uma imagem de contentor existente, pode verificar se esta carga de trabalho está pronta para ser executada num nó Arm. As secções seguintes explicam como o fazer através do docker run para tentar executar o contentor com a arquitetura Arm.

Prepare o Docker no seu ambiente x86 para verificar uma imagem de contentor

Se estiver a executar o Docker num ambiente x86, tem de transferir pacotes adicionais para executar uma imagem de contentor arm64. Estas instruções usam o apt para a gestão de pacotes, mas pode usar o gestor de pacotes do seu ambiente para transferir os pacotes necessários.

Se estiver a executar o Docker num ambiente Arm, pode ignorar esta secção.

Os seguintes comandos transferem pacotes e registam o QEMU como o intérprete binfmt para arquiteturas que a sua máquina não suporta:

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 binfmt, pode executar a imagem arm64 no seu ambiente x86.

Verifique a prontidão da carga de trabalho para Arm

Se estiver a executar o Docker num ambiente Arm ou tiver preparado o seu ambiente x86 para executar imagens Arm, execute o seguinte comando:

docker run --platform linux/arm64 IMAGE_NAME

Substitua IMAGE_NAME pelo nome da imagem do contentor.

O resultado seguinte indica que a imagem do contentor está pronta para ser executada em nós Arm com o cluster do GKE:

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

Se a sua carga de trabalho estiver pronta para ser executada no Arm, pode avançar para Preparar uma carga de trabalho Arm para implementação.

A seguinte saída indica que a sua 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

Este resultado indica que se trata de uma imagem x86_64 ou amd64 e tem de criar uma imagem arm64. Avance para a secção seguinte, Crie uma imagem de várias arquiteturas, onde pode usar uma imagem de contentor não compatível com Arm, um Dockerfile e criar uma imagem de várias arquiteturas que pode ser executada em vários tipos de arquiteturas.

Crie uma imagem multiarquitetura

Se tiver um Dockerfile, pode usá-lo para criar uma imagem multi-arquitetura compatível com Arm e x86 que pode implementar em nós com diferentes tipos de arquitetura.

Tem de transferir o Docker Buildx para concluir os seguintes passos. Também tem de ter um Dockerfile existente.

Prepare o seu ambiente se tiver uma VM x86 e uma VM Arm

Os seguintes comandos pressupõem que tem uma VM de compilação Arm e uma VM de compilação x86 no seu ambiente de compilação, e que a sua VM x86 pode estabelecer uma ligação SSH como raiz à sua VM Arm. Se tiver apenas uma VM x86 no seu ambiente de compilação, siga as instruções na secção seguinte, Prepare o seu ambiente se tiver apenas uma VM x86.

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

  1. Crie um contexto para o nó x86 através do socket local e um contexto para o nó Arm através de 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 braço.

  2. Crie um criador com 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 que escolher para o criador do Buildx.

Prepare o seu ambiente se tiver apenas uma VM x86

Se tiver apenas uma VM x86 no seu ambiente de compilação, pode seguir estes passos para preparar o seu ambiente para criar imagens multi-arquitetura. Com esta opção, o passo de compilação pode demorar mais tempo.

  1. Instale os pacotes QEMU:

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

  2. Crie um criador de várias arquiteturas (o criador predefinido não suporta várias arquiteturas):

    docker buildx create --name BUILDER_NAME --use

    Substitua BUILDER_NAME por um nome que escolher para o criador do Buildx.

Crie a imagem

Agora que o seu 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 o seu registo, terminando com o nome da imagem do contentor e uma etiqueta (por exemplo, gcr.io/myproject/myimage:latest).

Se receber uma mensagem de erro neste passo, consulte o guia do Docker e a documentação associada para resolver mais problemas.

Depois de criar uma imagem multi-arquitetura, a sua carga de trabalho está pronta para ser executada no Arm. Continue para preparar uma carga de trabalho Arm para implementação.

O que se segue?