Images mit mehreren Architekturen für Arm-Arbeitslasten erstellen

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Auf dieser Seite wird erläutert, was Images für mehrere Architekturen sind, warum die Architekturen von Knoten und Container-Images wichtig sind und warum Images für mehrere Architekturen die Bereitstellung von Arbeitslasten in GKE-Clustern vereinfachen. Auf dieser Seite finden Sie auch eine Anleitung dazu, wie Sie prüfen können, ob Ihre Arbeitslasten für die Ausführung in Armor bereit sind und wie Sie Images für mehrere Architekturen erstellen können.

Eine Anleitung zum Bereitstellen von Architekturen mit Images für mehrere Architekturen finden Sie unter Anwendung „x86“ in GKE für mehrere Architekturen mit Arm migrieren.

Was ist ein Image für mehrere Architekturen?

Ein Image für mehrere Architekturen ist ein Image, das mehrere Architekturen unterstützen kann. Es sieht wie ein einzelnes Image mit einem einzelnen Tag aus, es ist jedoch eine Liste von Images, die auf mehrere Architekturen abzielen und nach einer Manifestliste organisiert sind. Images für mehrere Architekturen sind mit den Spezifikationen für Docker Image Manifest V2 Scheme 2 oder OCI Image Index kompatibel. Wenn Sie ein Image für mehrere Architekturen in einem Cluster bereitstellen, wählt GKE automatisch das richtige Image aus, das mit der Architektur des Knotens kompatibel ist, auf dem es bereitgestellt wird. Sobald Sie ein Image für mehrere Architekturen für eine Arbeitslast haben, können Sie diese Arbeitslast nahtlos über mehrere Architekturen hinweg bereitstellen.

Images für mehrere Architekturen sind besonders nützlich, wenn Sie dieselbe Arbeitslast für alle Architekturen verwenden möchten. Alternativ können Sie Container-Images mit einer einzigen Architektur mit beliebigen GKE-Knotentypen verwenden. Wenn Sie nur eine Arbeitslast für eine Architektur verwenden und bereits ein kompatibles Image haben, müssen Sie kein Image für mehrere Architekturen erstellen.

Wenn Sie ein Image für einzelne Architekturen oder Architekturen für mehrere Architekturen verwenden, das Arm-kompatibel ist, und es auf einem Arm-Knoten bereitstellen möchten, müssen Sie die Schritte zum Einbinden der erforderlichen Felder ausführen, damit GKE die Planung wie erwartet durchführt. Weitere Informationen finden Sie unter Arm-Arbeitslast für die Bereitstellung vorbereiten. Sie müssen diese Felder nicht hinzufügen, um Arbeitslasten zu planen, wenn die Arbeitslasten nur für x86-basierte Knoten geplant werden.

Warum ist die Architektur eines GKE-Knotens für Arbeitslasten wichtig?

GKE-Knoten sind einzelne Compute Engine-VM-Instanzen, die GKE in Ihrem Namen erstellt und verwaltet. Jeder Knoten hat den Standardmaschinentyp (z. B. t2a-standard-1), der entweder x86- (Intel oder AMD) oder ARM-Prozessoren verwendet. Weitere Informationen finden Sie unter CPU-Plattformen.

Sie müssen Container-Images verwenden, die mit der Architektur des Knotens kompatibel sind, auf dem Sie die Arbeitslasten ausführen möchten. Wenn Sie beispielsweise ein Container-Image mit der Architektur arm64 ausführen möchten, müssen Sie einen Maschinentyp verwenden, der Arm-Arbeitslasten unterstützt, z. B. t2a-standard-1 aus der Tau T2A-Maschinenreihe.. Sie können Knoten mit mehreren Architekturtypen in einem GKE-Cluster verwenden. Wenn Sie eine Arbeitslast für mehrere Architekturtypen verwenden möchten, müssen Sie alle Container-Images und Bereitstellungsdateien für die architekturspezifischen Images verwalten. Images für mehrere Architekturen vereinfachen die Bereitstellung in verschiedenen Architekturtypen.

Image für mehrere Architekturen erstellen, das auf x86- und Arm-Knoten bereitgestellt wird

Die folgende Anleitung richtet sich an App-Entwickler, die bereits:

  • Eine Build-Umgebung mit einem heruntergeladenen Container-Tool (z. B. Docker).
  • ein vorhandenes Container-Image.

Die folgenden Befehle verwenden Docker, aber Sie können auch andere Containertools verwenden, um dieselben Aufgaben zu erledigen.

Ist meine Arbeitslast bereit für Arm?

Wenn Sie bereits ein Container-Image haben, können Sie überprüfen, ob diese Arbeitslast auf einem Arm-Knoten ausgeführt werden kann. In den folgenden Abschnitten wird erläutert, wie Sie dies mithilfe von docker run tun, um zu versuchen, den Container mit der Arm-Architektur auszuführen.

Docker in der x86-Umgebung zum Prüfen eines Container-Images vorbereiten

Wenn Sie Docker in einer x86-Umgebung ausführen, müssen Sie zusätzliche Pakete herunterladen, um ein arm64-Container-Image auszuführen. In dieser Anleitung wird apt für die Paketverwaltung verwendet. Sie können jedoch die erforderlichen Pakete mit dem Paketmanager Ihrer Umgebung herunterladen.

Wenn Sie Docker in einer Arm-Umgebung ausführen, können Sie diesen Abschnitt überspringen.

Die folgenden Befehle laden Pakete herunter und registrieren QEMU als binären Interpretierer für Architekturen, die von Ihrem Computer nicht unterstützt werden:

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

Nachdem Sie die Binäreinstellungen verwendet haben, können Sie das Image arm64 in der x86-Umgebung ausführen.

Arbeitslast auf Arm-Bereitschaft prüfen

Führen Sie den folgenden Befehl aus, wenn Sie Docker in einer Arm-Umgebung ausführen oder Ihre x86-Umgebung für die Ausführung von Arm-Images vorbereitet haben.

docker run --platform linux/arm64 IMAGE_NAME

Ersetzen Sie IMAGE_NAME durch den Namen des Container-Image.

Die folgende Ausgabe zeigt an, dass Ihr Container-Image bereit für die Ausführung auf Arm-Knoten mit Ihrem GKE-Cluster ist:

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

Wenn Ihre Arbeitslast bereit für die Ausführung auf Arm ist, können Sie mit dem Abschnitt Arm-Arbeitslast für die Bereitstellung vorbereiten fortfahren.

Die folgende Ausgabe zeigt an, dass Ihr Image nicht bereit für die Ausführung auf Arm ist:

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

Diese Ausgabe gibt an, dass dies ein x86_64- oder amd64-Image ist und Sie ein arm64-Image erstellen müssen. Fahren Sie mit dem nächsten Abschnitt Image für mehrere Architekturen erstellen fort, in dem Sie ein nicht mit Arm kompatibles Container-Image, ein Dockerfile und ein Image für mehrere Architekturen erstellen können, das Kann für verschiedene Architekturtypen ausgeführt werden.

Image für mehrere Architekturen erstellen

Wenn Sie ein Dockerfile haben, können Sie damit ein Arm-kompatibles und x86-kompatibles Image für mehrere Architekturen erstellen, das Sie über Knoten mit verschiedenen Architekturtypen bereitstellen können.

Sie müssen Docker Buildx herunterladen, um die folgenden Schritte auszuführen. Außerdem muss ein Dockerfile vorhanden sein.

Umgebung vorbereiten, wenn Sie eine x86-VM und Arm-VM haben

Bei den folgenden Befehlen wird davon ausgegangen, dass Sie sowohl eine Arm-Build-VM als auch eine x86-Build-VM in Ihrer Build-Umgebung haben. Ihre x86-VM kann als Root in Ihre Arm-VM zugreifen. Wenn Sie in Ihrer Build-Umgebung nur eine x86-VM haben, folgen Sie der Anleitung im nächsten Abschnitt Umgebung vorbereiten, wenn Sie nur eine x86-VM haben.

Bereiten Sie Ihre Umgebung auf, um Images für mehrere Architekturen zu erstellen:

  1. Erstellen Sie einen Kontext für den x86-Knoten mithilfe des lokalen Sockets und einen Kontext für den Arm-Knoten mit SSH:

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

    Ersetzen Sie NODE_IP durch die IP-Adresse des Arm-Knotens.

  2. Erstellen Sie mit dem x86-Knoten einen Builder:

    docker buildx create --use --name BUILDER_NAME --platform linux/amd64 amd_node
    docker buildx create --append --name BUILDER_NAME --platform linux/arm64 arm_node
    

    Ersetzen Sie BUILDER_NAME durch einen Namen, den Sie für den Buildx-Builder auswählen.

Umgebung vorbereiten, wenn Sie nur eine x86-VM haben

Wenn Sie in Ihrer Build-Umgebung nur eine x86-VM haben, können Sie die Umgebung mit den folgenden Schritten erstellen, um Images für mehrere Architekturen zu erstellen. Bei dieser Option kann der Build-Schritt länger dauern.

  1. Installieren Sie die QEMU-Pakete:

    docker run --rm --privileged multiarch/qemu-user-static
    
  2. Erstellen Sie einen Builder für mehrere Architekturen (der Standard-Builder unterstützt keine Architekturen für mehrere Architekturen):

    docker buildx create --name BUILDER_NAME --use
    

    Ersetzen Sie BUILDER_NAME durch einen Namen, den Sie für den Buildx-Builder auswählen.

Image erstellen

Führen Sie jetzt die im Folgenden aufgeführte Befehl aus, um Ihre Umgebung zu erstellen und ein Image für mehrere Architekturen zu erstellen:

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

Ersetzen Sie PATH_TO_REGISTRY durch den Pfad zu Ihrer Registry, die mit dem Namen Ihres Container-Images und einem Tag endet (z. B. gcr.io/myproject/myimage:latest).

Lesen Sie die Informationen im Docker-Leitfaden und in der zugehörigen Dokumentation zur weiteren Fehlerbehebung, wenn Sie in diesem Schritt eine Fehlermeldung erhalten.

Nachdem Sie ein Image für mehrere Architekturen erstellt haben, kann Ihre Arbeitslast auf Arm ausgeführt werden. Fahren Sie mit Arm-Arbeitslast für die Bereitstellung vorbereiten fort.

Nächste Schritte