Creare immagini multi-architettura per i carichi di lavoro Arm

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Questa pagina spiega cosa sono le immagini multi-architettura (multi-arco), perché le architetture di nodi e immagini container sono importanti e perché le immagini multi-arco semplificano il deployment dei carichi di lavoro nei cluster GKE. Questa pagina fornisce anche indicazioni su come verificare se i carichi di lavoro sono pronti per l'esecuzione su Arm e su come puoi creare immagini multi-arch.

Per un tutorial sul deployment tra architetture con immagini multi-arch, consulta Eseguire la migrazione dell'applicazione x86 su GKE in più archi con Arm.

Cos'è un'immagine multi-arco?

Un'immagine multi-arco è un'immagine che può supportare più architetture. Assomiglia a una singola immagine con un singolo tag, ma è un elenco di immagini che hanno come target più architetture organizzate da un elenco di manifest. Le immagini multi-arco sono compatibili con lo schema di immagine 2 di Docker 2 o con le specifiche dell'indice delle immagini OCI. Quando esegui il deployment di un'immagine multi-arch in un cluster, GKE sceglie automaticamente l'immagine giusta, compatibile con l'architettura del nodo in cui ne viene eseguito il deployment. Una volta che hai un'immagine multi-arco per un carico di lavoro, puoi eseguirne facilmente il deployment su più architetture.

Le immagini con più archi sono più utili quando vuoi utilizzare lo stesso carico di lavoro in più architetture. In alternativa, puoi utilizzare le immagini container con una singola architettura con qualsiasi tipo di nodi GKE. Se utilizzi un carico di lavoro solo su un'architettura e hai già un'immagine compatibile, non è necessario creare un'immagine multi-arch.

Se utilizzi un'immagine a un arco o più archi compatibile con il braccio e vuoi eseguirne il deployment su un nodo di gruppo, devi seguire le istruzioni per includere i campi necessari in modo che GKE pianifichi il carico di lavoro come previsto. Per saperne di più, vedi Preparare un carico di lavoro per il deployment. Non è necessario aggiungere questi campi per pianificare i carichi di lavoro se i carichi di lavoro verranno pianificati solo per nodi basati su x86.

Perché l'architettura di un nodo GKE è importante per i carichi di lavoro?

I nodi GKE sono singole istanze VM di Compute Engine, che GKE crea e gestisce per tuo conto. Ciascun nodo è di un tipo di macchina standard (ad esempio t2a-standard-1) che utilizza processori x86 (Intel o AMD) o Arm. Per scoprire di più, consulta Piattaforme CPU.

Devi utilizzare immagini container compatibili con l'architettura del nodo in cui intendi eseguire i carichi di lavoro. Ad esempio, se vuoi eseguire un'immagine container con l'architettura arm64, devi usare un tipo di macchina che supporti i carichi di lavoro Arm, come t2a-standard-1 della serie di macchine Tau T2A. Puoi utilizzare i nodi con più tipi di architettura in un unico cluster GKE. Se vuoi utilizzare un carico di lavoro su più tipi di architettura, devi tenere organizzate tutte le immagini container e i file di deployment per le immagini specifiche dell'architettura. Le immagini multi-arco semplificano il processo di deployment tra i tipi di architettura.

Crea un'immagine multi-arco da implementare sui nodi x86 e Arm

Le seguenti istruzioni sono rivolte agli sviluppatori di app che hanno già:

  • un ambiente di build con uno strumento container scaricato (ad esempio Docker).
  • un'immagine container esistente.

I seguenti comandi utilizzano Docker, ma potresti essere in grado di utilizzare altri strumenti container per eseguire le stesse attività.

Il mio carico di lavoro è pronto per il supporto?

Se disponi di un'immagine container esistente, puoi controllare se questo carico di lavoro è pronto per essere eseguito su un nodo Arm. Le sezioni seguenti spiegano come fare utilizzando docker run per tentare di eseguire il container con l'architettura Arm.

Prepara Docker nel tuo ambiente x86 per controllare un'immagine container

Se esegui Docker in un ambiente x86, devi scaricare i pacchetti aggiuntivi per eseguire un'immagine container arm64. Queste istruzioni utilizzano apt per la gestione dei pacchetti, ma puoi utilizzare il gestore di pacchetti del tuo ambiente per scaricare i pacchetti richiesti.

Se esegui Docker in un ambiente Arm, puoi saltare questa sezione.

I seguenti comandi scaricano i pacchetti e registrano QEMU come interprete binfmt per le architetture non supportate dalla tua macchina:

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

Dopo aver impostato gli interpreti binfmt, puoi eseguire l'immagine arm64 nel tuo ambiente x86.

Controlla il carico di lavoro per l'idoneità al supporto

Se esegui Docker in un ambiente Arm o hai preparato il tuo ambiente x86 per l'esecuzione delle immagini di Arm, esegui il comando seguente:

docker run --platform linux/arm64 IMAGE_NAME

Sostituisci IMAGE_NAME con il nome dell'immagine container.

Il seguente output indica che l'immagine container è pronta per l'esecuzione sui nodi di AR con il tuo cluster GKE:

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

Se il carico di lavoro è pronto per l'esecuzione sul gruppo, puoi preparare un carico di lavoro del gruppo per il deployment.

Il seguente output indica che l'immagine non è pronta per essere eseguita sul braccio:

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

Questo output indica che si tratta di un'immagine x86_64 o amd64 e devi creare un'immagine arm64. Passa alla sezione successiva, Crea un'immagine multi-arco, in cui puoi utilizzare un'immagine container non compatibile con Arm, un Dockerfile e un'immagine multi-arch che può essere eseguita su diversi tipi di architettura.

Crea un'immagine multi-arco

Se hai un Dockerfile, puoi usarlo per creare un'immagine multi-arch compatibile con Arm e compatibile con x86 che puoi distribuire su nodi con tipi di architettura diversi.

Devi scaricare Docker Buildx per completare i seguenti passaggi. Devi anche avere un Dockerfile esistente.

Prepara l'ambiente se hai una VM x86 e una VM arm

I comandi seguenti presuppongono che tu abbia una VM di build Arm e una VM build x86 nel tuo ambiente di build e che la VM x86 possa utilizzare SSH come root nella VM VM. Se nel tuo ambiente di build disponi solo di una VM x86, segui le istruzioni nella sezione successiva Preparare l'ambiente se hai solo una VM x86.

Prepara l'ambiente per creare immagini multi-arco:

  1. Crea un contesto per il nodo x86 utilizzando il socket locale e un contesto per il nodo Arm utilizzando SSH:

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

    Sostituisci NODE_IP con l'indirizzo IP del nodo del gruppo.

  2. Crea un generatore utilizzando il 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
    

    Sostituisci BUILDER_NAME con un nome a tua scelta per il builder Buildx.

Prepara l'ambiente se hai solo una VM x86

Se nel tuo ambiente di build è presente solo una VM x86, puoi seguire questi passaggi per preparare il tuo ambiente alla creazione di immagini multi-arch. Con questa opzione, il passaggio di creazione potrebbe richiedere più tempo.

  1. Installa i pacchetti QEMU:

    docker run --rm --privileged multiarch/qemu-user-static
    
  2. Crea un generatore a più archi (il generatore predefinito non supporta più archi):

    docker buildx create --name BUILDER_NAME --use
    

    Sostituisci BUILDER_NAME con un nome a tua scelta per il builder Buildx.

Crea l'immagine

Ora che il tuo ambiente è pronto, esegui il comando seguente per creare un'immagine multi-arch:

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

Sostituisci PATH_TO_REGISTRY con il percorso del registro, che termina con il nome dell'immagine container e un tag (ad esempio gcr.io/myproject/myimage:latest).

Se visualizzi un messaggio di errore in questo passaggio, fai riferimento alla guida di Docker e alla documentazione associata per risolvere ulteriormente i problemi.

Dopo aver creato un'immagine multi-arco, il carico di lavoro è pronto per essere eseguito su Arm. Procedi a Preparare un carico di lavoro di tipo Arm per il deployment.

Passaggi successivi