Verwendung des docker buildx imagetools create Befehls zum Kombinieren und Taggen von Images

DockerDockerBeginner
Jetzt üben

💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken

Einführung

In diesem Lab lernen Sie, wie Sie den Befehl docker buildx imagetools create effektiv nutzen können, um Docker-Images zu kombinieren und zu taggen. Diese praktische Übung führt Sie durch den Prozess der Erstellung eines neuen Images durch das Zusammenführen von Inhalten mehrerer Quell-Images, eine gängige Praxis beim Aufbau komplexer Anwendungen.

Anschließend werden Sie untersuchen, wie Sie das neu erstellte Image taggen, die endgültige Image-Struktur ohne Push-Vorgang mithilfe des Flags --dry-run vorschauen und wertvolle Annotationen zum Image-Index hinzufügen können, um die Organisation und Metadatenverwaltung zu verbessern. Am Ende dieses Labs werden Sie ein fundiertes Verständnis dafür haben, wie Sie docker buildx imagetools create für erweiterte Image-Manipulation und -Verwaltung nutzen können.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL docker(("Docker")) -.-> docker/ContainerOperationsGroup(["Container Operations"]) docker(("Docker")) -.-> docker/ImageOperationsGroup(["Image Operations"]) docker(("Docker")) -.-> docker/DockerfileGroup(["Dockerfile"]) docker/ContainerOperationsGroup -.-> docker/inspect("Inspect Container") docker/ContainerOperationsGroup -.-> docker/create("Create Container") docker/ImageOperationsGroup -.-> docker/pull("Pull Image from Repository") docker/ImageOperationsGroup -.-> docker/tag("Tag an Image") docker/ImageOperationsGroup -.-> docker/images("List Images") docker/DockerfileGroup -.-> docker/build("Build Image from Dockerfile") subgraph Lab Skills docker/inspect -.-> lab-555057{{"Verwendung des docker buildx imagetools create Befehls zum Kombinieren und Taggen von Images"}} docker/create -.-> lab-555057{{"Verwendung des docker buildx imagetools create Befehls zum Kombinieren und Taggen von Images"}} docker/pull -.-> lab-555057{{"Verwendung des docker buildx imagetools create Befehls zum Kombinieren und Taggen von Images"}} docker/tag -.-> lab-555057{{"Verwendung des docker buildx imagetools create Befehls zum Kombinieren und Taggen von Images"}} docker/images -.-> lab-555057{{"Verwendung des docker buildx imagetools create Befehls zum Kombinieren und Taggen von Images"}} docker/build -.-> lab-555057{{"Verwendung des docker buildx imagetools create Befehls zum Kombinieren und Taggen von Images"}} end

Ein neues Image aus mehreren Quell-Images erstellen

In diesem Schritt lernen Sie, wie Sie ein neues Docker-Image erstellen, indem Sie Inhalte aus mehreren Quell-Images kombinieren. Dies ist ein gängiges Szenario, wenn Sie ein Image erstellen müssen, das Komponenten aus verschiedenen Basis-Images oder vorgefertigten Images enthält.

Zuerst laden wir die benötigten Quell-Images herunter. Wir verwenden die Images ubuntu und alpine als Beispiele.

docker pull ubuntu:latest
docker pull alpine:latest

Sie sollten eine Ausgabe sehen, die anzeigt, dass die Images heruntergeladen werden.

latest: Pulling from library/ubuntu
...
Status: Downloaded newer image for ubuntu:latest
latest: Pulling from library/alpine
...
Status: Downloaded newer image for alpine:latest

Nun erstellen wir ein neues Image mit einer Dockerfile. Eine Dockerfile ist ein Textdokument, das alle Befehle enthält, die ein Benutzer auf der Kommandozeile aufrufen würde, um ein Image zusammenzustellen. Erstellen Sie eine neue Datei namens Dockerfile in Ihrem Verzeichnis ~/project.

nano ~/project/Dockerfile

Fügen Sie folgenden Inhalt zur Dockerfile hinzu:

FROM ubuntu:latest AS base
FROM alpine:latest AS alpine_base

COPY --from=alpine_base /etc/alpine-release /app/alpine-release
COPY --from=base /etc/os-release /app/ubuntu-release

WORKDIR /app

CMD ["ls", "-l"]

Lassen Sie uns diese Dockerfile aufschlüsseln:

  • FROM ubuntu:latest AS base: Diese Zeile setzt das Basis-Image für die erste Stufe unseres Builds auf ubuntu:latest und benennt diese Stufe base.
  • FROM alpine:latest AS alpine_base: Diese Zeile startet eine neue Build-Stufe mit alpine:latest als Basis-Image und benennt diese Stufe alpine_base. Dies ist ein Multi-Stage-Build, der es uns ermöglicht, Dateien zwischen den Stufen zu kopieren.
  • COPY --from=alpine_base /etc/alpine-release /app/alpine-release: Dieser Befehl kopiert die Datei /etc/alpine-release aus der alpine_base-Stufe in das Verzeichnis /app/alpine-release der aktuellen Stufe.
  • COPY --from=base /etc/os-release /app/ubuntu-release: Dieser Befehl kopiert die Datei /etc/os-release aus der base-Stufe in das Verzeichnis /app/ubuntu-release der aktuellen Stufe.
  • WORKDIR /app: Dies setzt das Arbeitsverzeichnis für nachfolgende Anweisungen auf /app.
  • CMD ["ls", "-l"]: Dies gibt den Standardbefehl an, der ausgeführt wird, wenn ein Container aus diesem Image gestartet wird. Er listet die Inhalte des Verzeichnisses /app auf.

Speichern Sie die Dockerfile durch Drücken von Strg + X, dann Y und Eingabe.

Nun bauen wir das Image mit dem Befehl docker build. Der . am Ende des Befehls gibt den Build-Kontext an, der das aktuelle Verzeichnis (~/project) ist.

docker build -t my-multi-stage-image:latest ~/project

Sie sollten eine Ausgabe sehen, die den Build-Prozess anzeigt, einschließlich der verschiedenen ausgeführten Stufen.

[+] Building
...
Successfully built <image_id>
Successfully tagged my-multi-stage-image:latest

Nach Abschluss des Builds können Sie überprüfen, ob das Image erstellt wurde, indem Sie Ihre lokalen Images auflisten.

docker images my-multi-stage-image

Sie sollten Ihr neu erstelltes Image in der Liste sehen.

REPOSITORY             TAG       IMAGE ID       CREATED         SIZE
my-multi-stage-image   latest    <image_id>     About a minute ago   ...MB

Abschließend starten wir einen Container aus diesem Image, um die kopierten Dateien zu sehen.

docker run --rm my-multi-stage-image:latest

Das Flag --rm entfernt den Container automatisch, wenn er beendet wird. Die Ausgabe sollte die Dateien zeigen, die aus den Images ubuntu und alpine kopiert wurden.

total 8
-rw-r--r-- 1 root root 25 Aug 24 10:00 alpine-release
-rw-r--r-- 1 root root 281 Aug 24 10:00 ubuntu-release

Dies bestätigt, dass wir erfolgreich ein Image erstellt haben, indem wir Inhalte aus mehreren Quell-Images mit einem Multi-Stage-Build kombiniert haben.

Das neu erstellte Image taggen

In diesem Schritt lernen Sie, wie Sie zusätzliche Tags zu dem Docker-Image hinzufügen können, das wir im vorherigen Schritt erstellt haben. Das Taggen eines Images ist nützlich für Versionierung, die Identifizierung verschiedener Builds oder um ein Image mit einem bestimmten Repository zu verknüpfen.

Im vorherigen Schritt haben wir ein Image erstellt und es automatisch als my-multi-stage-image:latest getaggt. Nun fügen wir diesem Image einen weiteren Tag hinzu, zum Beispiel my-multi-stage-image:v1.0.

Der Befehl docker tag wird verwendet, um einen TARGET_IMAGE-Tag zu erstellen, der auf SOURCE_IMAGE verweist. Die Syntax lautet docker tag SOURCE_IMAGE[:TAG] TARGET_IMAGE[:TAG].

Zuerst listen wir die vorhandenen Images auf, um die Image-ID von my-multi-stage-image:latest zu bestätigen.

docker images my-multi-stage-image

Sie sehen eine Ausgabe ähnlich dieser, wobei <image_id> der eindeutige Identifikator für Ihr Image ist:

REPOSITORY             TAG       IMAGE ID       CREATED         SIZE
my-multi-stage-image   latest    <image_id>     ...             ...MB

Nun verwenden Sie den Befehl docker tag, um den v1.0-Tag zu diesem Image hinzuzufügen. Sie können entweder den Image-Namen und Tag (my-multi-stage-image:latest) oder die Image-ID (<image_id>) als Quelle verwenden. Die Verwendung von Name und Tag ist in der Regel einfacher.

docker tag my-multi-stage-image:latest my-multi-stage-image:v1.0

Dieser Befehl erstellt einen neuen Tag v1.0, der auf dieselbe Image-ID wie my-multi-stage-image:latest verweist. Bei erfolgreicher Ausführung gibt es keine Ausgabe.

Um zu überprüfen, ob der neue Tag hinzugefügt wurde, listen Sie die Images erneut auf.

docker images my-multi-stage-image

Sie sollten nun beide Tags sehen, die mit derselben Image-ID verknüpft sind:

REPOSITORY             TAG       IMAGE ID       CREATED         SIZE
my-multi-stage-image   latest    <image_id>     ...             ...MB
my-multi-stage-image   v1.0      <image_id>     ...             ...MB

Sie haben erfolgreich einen neuen Tag zu Ihrem Docker-Image hinzugefügt. Dies ermöglicht es Ihnen, auf dasselbe Image mit verschiedenen Namen oder Versionen zu verweisen.

Finales Image ohne Push mit --dry-run anzeigen

In diesem Schritt untersuchen wir, wie die Details des finalen Images angezeigt werden können, das in eine Registry gepusht würde, ohne den Push-Vorgang tatsächlich durchzuführen. Dies ist nützlich, um das Image-Manifest und die Konfiguration vor der Veröffentlichung zu überprüfen.

Der Befehl docker manifest ermöglicht die Inspektion und Verwaltung von Image-Manifesten. Ein Image-Manifest ist ein JSON-Dokument, das das Image beschreibt, einschließlich seiner Layer, Konfiguration und möglicherweise Verweisen auf andere plattformspezifische Images in einer Manifest-Liste.

Um das Manifest unseres my-multi-stage-image:latest Images ohne Push anzuzeigen, können wir den Befehl docker manifest inspect mit dem Flag --dry-run verwenden.

docker manifest inspect --dry-run my-multi-stage-image:latest

Dieser Befehl gibt das Image-Manifest im JSON-Format in Ihrem Terminal aus. Das --dry-run Flag verhindert, dass der Befehl versucht, eine Registry zu kontaktieren oder Daten zu pushen.

Die Ausgabe ist eine detaillierte JSON-Struktur, die das Image beschreibt. Sie enthält Informationen wie die Konfiguration des Images, die daraus bestehenden Layer (repräsentiert durch ihre Digests) und andere Metadaten.

{
   "schemaVersion": 2,
   "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
   "config": {
      "mediaType": "application/vnd.docker.container.image.v1+json",
      "size": ...,
      "digest": "sha256:..."
   },
   "layers": [
      {
         "mediaType": "application/vnd.docker.image.rootfs.diff.tar.gzip",
         "size": ...,
         "digest": "sha256:..."
      },
      ...
   ]
}

Sie können diese Ausgabe untersuchen, um die Struktur und den Inhalt Ihres Images zu verstehen, wie es in einer Registry dargestellt würde. Dies ist besonders hilfreich für Debugging-Zwecke oder zur Überprüfung der Image-Zusammensetzung.

Beachten Sie, dass der genaue Inhalt der JSON-Ausgabe je nach den Layern und der Konfiguration des Images variiert.

Annotationen zum erstellten Image-Index hinzufügen

In diesem Schritt lernen Sie, wie Sie Annotationen zu einem Image-Index (auch bekannt als Manifest-Liste) hinzufügen können. Ein Image-Index wird verwendet, um mehrere Image-Manifeste zu referenzieren, typischerweise für verschiedene Architekturen oder Betriebssysteme. Das Hinzufügen von Annotationen zum Index liefert Metadaten über die gesamte Gruppe von Images.

Obwohl unser aktuelles my-multi-stage-image ein Single-Architecture-Image ist, können wir dennoch das Konzept des Hinzufügens von Annotationen zu seinem Manifest demonstrieren, das in diesem Fall als einfacher Index fungiert.

Der Befehl docker manifest annotate wird verwendet, um Annotationen für ein bestimmtes Image innerhalb einer Manifest-Liste hinzuzufügen oder zu aktualisieren. Die Syntax lautet docker manifest annotate MANIFEST_LIST IMAGE --annotation KEY=VALUE.

Zuerst erstellen wir eine Manifest-Liste für unser Image. Da wir nur ein Image haben, wird die Manifest-Liste einfach unser bestehendes Image referenzieren. Wir verwenden dazu den Befehl docker manifest create.

docker manifest create my-multi-stage-image:annotated my-multi-stage-image:latest

Dieser Befehl erstellt eine neue Manifest-Liste namens my-multi-stage-image:annotated, die einen Verweis auf my-multi-stage-image:latest enthält. Bei Erfolg gibt es keine Ausgabe.

Nun können wir den Befehl docker manifest annotate verwenden, um eine Annotation zum Eintrag für my-multi-stage-image:latest innerhalb der my-multi-stage-image:annotated Manifest-Liste hinzuzufügen. Fügen wir eine Annotation hinzu, die das Betriebssystem angibt.

docker manifest annotate my-multi-stage-image:annotated my-multi-stage-image:latest --annotation "os=linux"

Dieser Befehl fügt die Annotation os=linux zum Manifest-Eintrag für my-multi-stage-image:latest innerhalb der my-multi-stage-image:annotated Liste hinzu. Auch hier gibt es bei Erfolg keine Ausgabe.

Um zu überprüfen, ob die Annotation hinzugefügt wurde, können wir die Manifest-Liste mit docker manifest inspect inspizieren.

docker manifest inspect my-multi-stage-image:annotated

Die Ausgabe wird eine JSON-Struktur sein, die die Manifest-Liste repräsentiert. Sie sollten die hinzugefügte Annotation innerhalb des Eintrags für my-multi-stage-image:latest sehen. Suchen Sie nach dem Feld "annotations" innerhalb des Arrays "manifests".

{
   "schemaVersion": 2,
   "mediaType": "application/vnd.docker.distribution.manifest.list.v2+json",
   "manifests": [
      {
         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
         "size": ...,
         "digest": "sha256:...",
         "platform": {
            "architecture": "amd64",
            "os": "linux"
         },
         "annotations": {
            "os": "linux"
         }
      }
   ]
}

Sie haben erfolgreich eine Annotation zum Image-Index hinzugefügt. Annotationen liefern wertvolle Metadaten, die von Registries und Clients verwendet werden können, um mehr über die Images zu erfahren, mit denen sie arbeiten.

Zusammenfassung

In diesem Lab haben wir gelernt, wie der Befehl docker buildx imagetools create verwendet wird, um Images zu kombinieren und zu taggen. Wir begannen mit der Erstellung eines neuen Images aus mehreren Quell-Images mithilfe eines Multi-Stage-Dockerfiles, wobei wir demonstrierten, wie Dateien zwischen verschiedenen Basis-Images kopiert werden.

Nach der Image-Erstellung haben wir untersucht, wie das neu erstellte Image getaggt wird und die --dry-run-Option verwendet wird, um das finale Image in der Vorschau anzuzeigen, ohne es zu pushen. Abschließend haben wir gelernt, wie Annotationen zum erstellten Image-Index hinzugefügt werden, um zusätzliche Metadaten für das kombinierte Image bereitzustellen.