Crea immagini multi-architettura per i carichi di lavoro ARM

Autopilot Standard

---

Questa pagina spiega che cosa sono le immagini multi-architettura (multi-arch), perché le architetture dei nodi e delle immagini container sono importanti e perché le immagini multi-arch semplificano il deployment dei carichi di lavoro nei cluster GKE. Questa pagina fornisce anche indicazioni su come verificare se i tuoi sono pronti per essere eseguiti su ARM e su come creare immagini multi-arch.

Per un tutorial sull'implementazione su più architetture con immagini multi-arch, consulta Esegui la migrazione dell'applicazione x86 su GKE a multi-arch con Arm.

Nota: le istruzioni riportate in questa pagina forniscono un solo percorso per verificare la presenza di Controlla l'idoneità e crea immagini multi-arco. Ti consigliamo di consultare la documentazione di questi strumenti e di sviluppare il tuo percorso per svolgere queste attività in base alle esigenze del tuo ambiente e del tuo carico di lavoro. Gli strumenti di terze parti utilizzati non sono supportati da GKE e potrebbero cambiare in qualsiasi momento senza preavviso.

Che cos'è un'immagine multi-arch?

Un'immagine multi-arch è un'immagine che può supportare più architetture. Sembra una singola immagine con un singolo tag, ma è un elenco di immagini che hanno come target più architetture organizzate da un elenco manifest. Le immagini multi-arch sono compatibili con lo schema 2 Docker Image Manifest V2 o le specifiche dell'indice di immagini OCI. Quando esegui il deployment di un'immagine multi-arch in un cluster, sceglie automaticamente l'immagine giusta che sia compatibile con l'architettura del nodo in cui viene eseguito il deployment. Una volta creata un'immagine multi-architettura per un carico di lavoro, puoi implementarlo senza problemi su più architetture.

Le immagini multi-arch sono più utili quando vuoi utilizzare lo stesso carico di lavoro su architetture. In alternativa, puoi utilizzare le immagini container con qualsiasi tipo di nodo GKE. Se stai utilizzando un carico di lavoro su un'architettura e hai già un'immagine compatibile, non devi creare un'immagine multi-arch.

Se utilizzi un'immagine a architettura singola o multipla compatibile con Arm e vuoi eseguirne il deployment su un nodo Arm, devi seguire le istruzioni per includere i campi necessari in modo che GKE pianifichi il carico di lavoro come previsto. Per scoprire di più, consulta Preparare un carico di lavoro ARM per il deployment. Non è necessario aggiungere questi campi per pianificare i carichi di lavoro verranno pianificati solo sui nodi basati su x86.

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

I nodi GKE sono singole istanze VM Compute Engine che GKE crea e gestisce per tuo conto. Ogni nodo è di un tipo di macchina standard (ad esempio t2a-standard-1) che utilizza processori x86 (Intel o AMD) o Arm. Per saperne di più, vedi 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 avere un tipo di macchina che supporti i carichi di lavoro ARM, ad esempio t2a-standard-1 della serie di macchine Tau T2A. Puoi utilizzare nodi con più tipi di architettura in un unico GKE in un cluster Kubernetes. Se vuoi utilizzare un carico di lavoro per più tipi di architettura, devono conservare tutte le immagini container e i file di deployment per l'architettura e immagini organizzate. Le immagini multi-architettura semplificano la procedura di implementazione su diversi tipi di architettura.

Crea un'immagine multi-arch da eseguire su nodi x86 e Arm

Avviso: le seguenti istruzioni forniscono indicazioni su come verificare la presenza di Controlla l'idoneità e crea immagini multi-arco. Questi esempi utilizzano strumenti di terze parti non supportati che potrebbero cambiare in qualsiasi momento senza preavviso da parte di GKE.

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

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

I seguenti comandi utilizzano Docker, ma potresti riuscire a utilizzare altri strumenti contenitori per svolgere le stesse attività.

Il mio carico di lavoro è pronto per Arm?

Se hai già un'immagine container, puoi verificare se questo carico di lavoro è pronto per essere eseguito su un nodo Arm. Le sezioni seguenti spiegano come eseguire questa operazione utilizzando docker run per tentare di eseguire il contenitore con l'architettura Arm.

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

Se esegui Docker in un ambiente x86, devi scaricare pacchetti aggiuntivi per eseguire un'immagine container arm64. Queste istruzioni utilizzano apt per ma puoi usare il gestore di pacchetti del tuo ambiente 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 l'idoneità del carico di lavoro per l'ARM

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

docker run --platform linux/arm64 IMAGE_NAME

Sostituisci IMAGE_NAME con il nome dell'immagine del contenitore.

Il seguente output indica che l'immagine container è pronta per essere eseguita su ARM nodi 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 essere eseguito su Arm, puoi procedere con la procedura per preparare un carico di lavoro Arm per l'implementazione.

L'output seguente indica che l'immagine non è pronta per l'esecuzione su 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

Questo output indica che si tratta di un'immagine x86_64 o amd64 e che devi creare un'immagine arm64. Passa alla sezione successiva, Creare un'immagine multi-arch, in cui puoi utilizzare un'immagine container non compatibile con Arm, un Dockerfile un'immagine a più archi che può essere applicata a più tipi di architetture.

Creare un'immagine multi-arch

Se hai un Dockerfile, puoi usarlo per creare un immagine multi-arch compatibile con x86 di cui puoi eseguire il deployment in nodi con diverse tipi di architettura.

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 sia una VM di build ARM sia un x86 di Cloud Build nel tuo ambiente di build e la tua VM x86 può utilizzare SSH come root Abilita VM. Se nel tuo ambiente di compilazione è presente solo una VM x86, segui le istruzioni riportate nella sezione successiva Preparare l'ambiente se hai solo una VM x86.

Prepara l'ambiente per creare immagini multi-arch:

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 ARM.

2. Crea un builder 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 di tua scelta il builder Buildx.

Prepara l'ambiente se hai solo una VM x86

Se nel tuo ambiente di compilazione hai solo una VM x86, puoi seguire questi passaggi per preparare l'ambiente alla compilazione di immagini multi-architettura. Con questa opzione, il passaggio di compilazione potrebbe richiedere più tempo.

1. Installa i pacchetti QEMU:

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

2. Crea un builder multi-arch (il builder predefinito non supporta più archi):

   docker buildx create --name BUILDER_NAME --use
   

   Sostituisci BUILDER_NAME con un nome scelto per il generatore Buildx.

Crea l'immagine

Ora che l'ambiente è pronto, esegui questo comando per creare 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 es. gcr.io/myproject/myimage:latest).

Se in questo passaggio ricevi un messaggio di errore, consulta la guida di Docker e la documentazione associata per ulteriori passaggi per la risoluzione dei problemi.

Dopo aver creato un'immagine multi-arch, il carico di lavoro è pronto per essere eseguito Gruppo. Vai a Preparare un carico di lavoro ARM per il deployment.

Passaggi successivi

• Preparare un carico di lavoro ARM per il deployment
• Esegui la migrazione di un'applicazione x86 su GKE a multi-arch con Arm