So verwenden Sie den Befehl docker manifest create, um Multi-Architektur-Images zu erstellen

Einführung

In diesem Lab erfahren Sie, wie Sie mit dem Befehl docker manifest create Docker-Images für mehrere Architekturen erstellen und verwalten können. Multi-Architektur-Images sind unerlässlich für die Bereitstellung von Anwendungen in verschiedenen Umgebungen mit unterschiedlichen CPU-Architekturen wie amd64 und arm64.

Das Lab führt Sie durch den Prozess der Vorbereitung von Multi-Architektur-Images, indem es Ihnen zeigt, wie Sie experimentelle Funktionen aktivieren und eine Multi-Architektur-Builder-Instanz erstellen. Anschließend erstellen Sie eine Manifestliste, die diese Images zusammenfasst, überprüfen die erstellte Manifestliste, um deren Inhalt zu verifizieren, und schieben schließlich die Manifestliste in ein Registry, sodass Ihr Multi-Architektur-Image für die Bereitstellung auf verschiedenen Plattformen verfügbar ist.

Skills Graph

Vorbereitung von Multi-Architektur-Images

In diesem Schritt werden wir Multi-Architektur-Images vorbereiten. Multi-Architektur-Images ermöglichen es Ihnen, Images zu erstellen und hochzuladen, die auf verschiedenen Architekturen wie amd64 und arm64 laufen können. Dies ist nützlich für die Bereitstellung von Anwendungen in verschiedenen Umgebungen, einschließlich Cloud-Servern, Edge-Geräten und lokalen Maschinen.

Zunächst müssen wir die experimentellen Funktionen in Docker aktivieren. Dadurch können wir den buildx-Befehl verwenden, der für das Erstellen von Multi-Architektur-Images erforderlich ist. Wir können dies tun, indem wir die Docker-Konfigurationsdatei erstellen oder ändern.

Öffnen Sie die Docker-Konfigurationsdatei mit nano:

nano ~/.docker/config.json

Wenn die Datei nicht existiert, wird nano sie erstellen. Fügen Sie den folgenden Inhalt zur Datei hinzu. Wenn die Datei bereits existiert, fügen Sie die Zeile "experimental": "enabled" innerhalb des Haupt-JSON-Objekts hinzu.

{
  "experimental": "enabled"
}

Speichern Sie die Datei, indem Sie Strg + X, dann Y und Enter drücken.

Als Nächstes müssen wir eine neue Builder-Instanz erstellen, die mehrere Architekturen unterstützt. Eine Builder-Instanz ist eine Docker-Komponente, die den Build-Prozess verwaltet.

Erstellen Sie eine neue Builder-Instanz namens mybuilder:

docker buildx create --name mybuilder --use

Dieser Befehl erstellt eine neue Builder-Instanz namens mybuilder und setzt sie als Standard-Builder für nachfolgende Build-Vorgänge. Die Ausgabe sollte anzeigen, dass der Builder erstellt und verwendet wird.

Jetzt erstellen wir ein einfaches Multi-Architektur-Image. Wir verwenden eine einfache Dockerfile, die ein Image auf Basis von Alpine Linux erstellt.

Erstellen Sie ein Verzeichnis für unser Projekt und navigieren Sie dorthin:

mkdir ~/project/multiarch-demo
cd ~/project/multiarch-demo

Erstellen Sie eine Dockerfile in diesem Verzeichnis:

nano Dockerfile

Fügen Sie den folgenden Inhalt zur Dockerfile hinzu:

FROM alpine:latest
CMD ["echo", "Hello from multi-architecture image!"]

Speichern Sie die Dockerfile, indem Sie Strg + X, dann Y und Enter drücken.

Jetzt erstellen wir das Image für die Architekturen linux/amd64 und linux/arm64 und laden es in ein Test-Registry hoch. Wir verwenden localhost:5000 als Platzhalter für das Registry. In einem realen Szenario würden Sie dies durch Ihre tatsächliche Registry-Adresse ersetzen.

Erstellen und laden Sie das Multi-Architektur-Image hoch:

docker buildx build --platform linux/amd64,linux/arm64 -t localhost:5000/multiarch-demo:latest --push .

Dieser Befehl erstellt das Image für die angegebenen Plattformen (linux/amd64 und linux/arm64), markiert es als localhost:5000/multiarch-demo:latest und lädt es in das localhost:5000-Registry hoch. Die Ausgabe zeigt den Build-Prozess für jede Architektur und den Push-Vorgang an.

Erstellung einer Manifestliste für die Images

In diesem Schritt werden wir eine Manifestliste für die Multi-Architektur-Images erstellen, die wir im vorherigen Schritt erstellt haben. Eine Manifestliste ist eine Liste von Image-Manifesten, jeweils für eine andere Architektur. Wenn Sie ein Image mithilfe einer Manifestliste abrufen, wählt Docker automatisch das richtige Image für Ihre Architektur aus.

Wir verwenden den Befehl docker manifest create, um die Manifestliste zu erstellen. Dieser Befehl erwartet den Namen der zu erstellenden Manifestliste, gefolgt von den Namen der Images, die Sie in die Liste aufnehmen möchten.

Erstellen Sie eine Manifestliste namens localhost:5000/multiarch-demo:latest:

docker manifest create localhost:5000/multiarch-demo:latest \
  localhost:5000/multiarch-demo:latest@sha256:$(docker buildx imagetools inspect localhost:5000/multiarch-demo:latest | grep 'Digest:' | awk '{print $2}' | head -n 1) \
  localhost:5000/multiarch-demo:latest@sha256:$(docker buildx imagetools inspect localhost:5000/multiarch-demo:latest | grep 'Digest:' | awk '{print $2}' | tail -n 1)

Lassen Sie uns diesen Befehl analysieren:

• docker manifest create localhost:5000/multiarch-demo:latest: Dies gibt den Namen der zu erstellenden Manifestliste an.
• localhost:5000/multiarch-demo:latest@sha256:...: Dies sind die Images, die wir der Manifestliste hinzufügen. Wir verwenden den Image-Namen, gefolgt von @sha256: und dem Digest des Images. Der Digest identifiziert eindeutig eine bestimmte Image-Schicht.
• $(docker buildx imagetools inspect localhost:5000/multiarch-demo:latest | grep 'Digest:' | awk '{print $2}' | head -n 1): Diese Befehlskette ruft den Digest des ersten von docker buildx imagetools inspect aufgeführten Images ab.
• $(docker buildx imagetools inspect localhost:5000/multiarch-demo:latest | grep 'Digest:' | awk '{print $2}' | tail -n 1): Diese Befehlskette ruft den Digest des zweiten von docker buildx imagetools inspect aufgeführten Images ab.

Die Ausgabe des docker manifest create-Befehls wird der Digest der neu erstellten Manifestliste sein.

Prüfen der erstellten Manifestliste

In diesem Schritt werden wir die Manifestliste prüfen, die wir im vorherigen Schritt erstellt haben. Durch die Prüfung der Manifestliste können wir sehen, welche Images in der Liste enthalten sind und welche Details sie haben, wie z. B. die Architektur und das Betriebssystem.

Wir verwenden den Befehl docker manifest inspect, um die Details der Manifestliste anzuzeigen.

Prüfen Sie die Manifestliste localhost:5000/multiarch-demo:latest:

docker manifest inspect localhost:5000/multiarch-demo:latest

Die Ausgabe dieses Befehls wird ein JSON-Dokument sein, das die Manifestliste beschreibt. Sie sollten ein Array von "manifests" sehen, wobei jedes ein Image für eine andere Architektur darstellt. Suchen Sie im "platform"-Feld jedes Manifest-Eintrags nach der Architektur und dem Betriebssystem. Sie sollten Einträge für sowohl linux/amd64 als auch linux/arm64 sehen.

Diese Prüfung bestätigt, dass unsere Manifestliste die Images für die verschiedenen Architekturen, die wir erstellt haben, korrekt enthält.

Pushen der Manifestliste in ein Registry

In diesem Schritt werden wir die von uns erstellte Manifestliste in ein Registry pushen. Durch das Pushen der Manifestliste wird es anderen möglich, das Multi-Architektur-Image herunterzuladen. Wenn jemand das Image mithilfe des Manifestlisten-Tags herunterlädt, wird Docker automatisch das richtige Image für die Architektur seines Systems herunterladen.

Wir verwenden den Befehl docker manifest push, um die Manifestliste zu pushen.

Pushen Sie die Manifestliste localhost:5000/multiarch-demo:latest in das Registry:

docker manifest push localhost:5000/multiarch-demo:latest

Dieser Befehl pusht die Manifestliste und alle von ihr referenzierten Images in das angegebene Registry (localhost:5000). Da wir in der ersten Stufe bereits die einzelnen Images mithilfe von docker buildx build --push gepusht haben, pusht dieser Befehl hauptsächlich die Manifestliste selbst.

Die Ausgabe zeigt den Fortschritt des Push-Vorgangs für die Manifestliste an.

Nachdem Sie die Manifestliste gepusht haben, können Sie überprüfen, ob sie im Registry verfügbar ist. Obwohl wir in dieser Lab-Umgebung kein laufendes Registry haben, um direkt abzufragen, zeigt die erfolgreiche Ausführung des docker manifest push-Befehls an, dass die Manifestliste für das Pushen vorbereitet ist.

Um das Herunterladen des Multi-Architektur-Images zu simulieren und zu überprüfen, ob Docker die richtige Architektur auswählt, könnten Sie versuchen, das Image auf einem System mit einer anderen Architektur (falls verfügbar) herunterzuladen. Innerhalb dieser Lab-Umgebung können wir uns jedoch auf den erfolgreichen Push-Befehl und den vorherigen Prüfungsschritt verlassen, um zu bestätigen, dass die Manifestliste bereit ist.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man Multi-Architektur-Images mit Docker vorbereitet. Dies umfasst das Aktivieren von experimentellen Funktionen in Docker, um den buildx-Befehl nutzen zu können, der für das Erstellen von Images, die mit verschiedenen Architekturen wie amd64 und arm64 kompatibel sind, unerlässlich ist. Wir haben den Docker-Client konfiguriert, indem wir die Datei config.json bearbeitet haben, um die experimentellen Funktionen zu aktivieren. Anschließend haben wir eine neue Builder-Instanz namens mybuilder mit docker buildx create --name mybuilder --use erstellt, die in der Lage ist, Multi-Architektur-Builds zu verwalten. Schließlich haben wir ein einfaches Projektverzeichnis eingerichtet und eine einfache Dockerfile auf Basis von Alpine Linux erstellt, die als Grundlage für das Erstellen unseres Multi-Architektur-Images dient.