Wie man den docker manifest inspect-Befehl verwendet, um Image-Manifeste anzuzeigen

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 manifest inspect verwenden, um Image-Manifeste anzuzeigen. Wir beginnen damit, ein Docker-Image mit Unterstützung für mehrere Architekturen, konkret das alpine-Image, herunterzuladen, um zu verstehen, wie Docker Images für verschiedene Architekturen verarbeitet.

Nachdem das Image heruntergeladen wurde, verwenden Sie docker manifest inspect, um die Manifestliste des Docker-Images mit Unterstützung für mehrere Architekturen zu untersuchen. Anschließend gehen Sie tiefer in die Details ein, indem Sie ein bestimmtes Image-Manifest innerhalb dieser Liste untersuchen. Abschließend erkunden Sie die ausführliche Ausgabeoption des docker manifest inspect-Befehls, um einen umfassenden Überblick über die Details der Image-Manifeste zu erhalten.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL docker(("Docker")) -.-> docker/ImageOperationsGroup(["Image Operations"]) docker(("Docker")) -.-> docker/ContainerOperationsGroup(["Container Operations"]) docker/ContainerOperationsGroup -.-> docker/inspect("Inspect Container") docker/ImageOperationsGroup -.-> docker/pull("Pull Image from Repository") subgraph Lab Skills docker/inspect -.-> lab-555170{{"Wie man den docker manifest inspect-Befehl verwendet, um Image-Manifeste anzuzeigen"}} docker/pull -.-> lab-555170{{"Wie man den docker manifest inspect-Befehl verwendet, um Image-Manifeste anzuzeigen"}} end

Ein Docker-Image mit Unterstützung für mehrere Architekturen herunterladen

In diesem Schritt lernen wir, wie man ein Docker-Image mit Unterstützung für mehrere Architekturen herunterlädt. Ein solches Image ist ein einzelner Image-Tag, der auf verschiedenen Architekturen (z. B. amd64, arm64 usw.) verwendet werden kann. Wenn Sie ein solches Image herunterladen, wählt Docker automatisch die richtige Image-Schicht für die Architektur Ihres Systems aus.

Wir werden das alpine-Image herunterladen, eine leichte Linux-Distribution, die häufig in Docker-Containern verwendet wird. Das alpine-Image ist als Docker-Image mit Unterstützung für mehrere Architekturen verfügbar.

Um das alpine-Image herunterzuladen, öffnen Sie Ihr Terminal und führen Sie den folgenden Befehl aus:

docker pull alpine

Dieser Befehl weist Docker an, die neueste Version des alpine-Images von Docker Hub herunterzuladen. Da alpine ein Docker-Image mit Unterstützung für mehrere Architekturen ist, wird Docker die für die Architektur Ihrer LabEx-VM geeigneten Image-Schichten herunterladen.

Sie sollten eine Ausgabe ähnlich der folgenden sehen, die anzeigt, dass Docker das Image herunterlädt:

Using default tag: latest
latest: Pulling from library/alpine
... (output showing download progress)
Digest: sha256:...
Status: Downloaded newer image for alpine:latest
docker.io/library/alpine:latest

Die Zeile Digest zeigt den eindeutigen Bezeichner für das spezifische Image-Manifest an, das für Ihre Architektur heruntergeladen wurde.

Nachdem der Befehl abgeschlossen ist, ist das alpine-Image auf Ihrer LabEx-VM verfügbar und kann zum Starten von Containern verwendet werden.

Die Manifestliste des Docker-Images mit Unterstützung für mehrere Architekturen untersuchen

Im vorherigen Schritt haben wir das alpine-Image heruntergeladen. Da alpine ein Docker-Image mit Unterstützung für mehrere Architekturen ist, bezieht sich der Tag alpine:latest tatsächlich auf eine Manifestliste. Eine Manifestliste ist eine Liste von Image-Manifesten, wobei jedes für eine andere Architektur bestimmt ist. Wenn Sie ein Docker-Image mit Unterstützung für mehrere Architekturen herunterladen, verwendet Docker die Manifestliste, um das richtige Image-Manifest für Ihr System zu finden.

Um die Manifestliste für das alpine:latest-Image anzuzeigen, können wir den Befehl docker manifest inspect verwenden. Mit diesem Befehl können Sie die Details eines Image-Manifests oder einer Manifestliste anzeigen.

Führen Sie den folgenden Befehl in Ihrem Terminal aus:

docker manifest inspect alpine:latest

Dieser Befehl gibt ein JSON-Dokument aus, das die Manifestliste für das alpine:latest-Image darstellt. Die Ausgabe zeigt eine Liste von manifests, wobei jedes Manifest einer anderen Architektur entspricht (z. B. amd64, arm64, arm/v7 usw.). Jedes Manifest in der Liste enthält Details wie die platform (Architektur und Betriebssystem) und den digest (ein eindeutiger Bezeichner für das Image-Manifest dieser speziellen Architektur).

Sie sollten eine Ausgabe ähnlich der folgenden sehen (die genauen Digests und die Anzahl der Manifeste können variieren):

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

Diese Ausgabe bestätigt, dass alpine:latest tatsächlich eine Manifestliste ist, die Manifeste für verschiedene Architekturen enthält. So weiß Docker, welches spezifische Image es für Ihr System herunterladen soll, wenn Sie einen Tag für ein Docker-Image mit Unterstützung für mehrere Architekturen verwenden.

Ein spezifisches Image-Manifest in der Liste untersuchen

Im vorherigen Schritt haben wir die Manifestliste für alpine:latest untersucht. Diese Liste enthielt mehrere Einträge, die jeweils auf ein spezifisches Image-Manifest für eine andere Architektur verweisen. Jetzt wollen wir eines dieser spezifischen Image-Manifeste untersuchen.

Um ein spezifisches Manifest zu untersuchen, benötigen wir seinen Digest. Aus der Ausgabe von docker manifest inspect alpine:latest suchen Sie den digest für die Architektur, die mit Ihrer LabEx-VM übereinstimmt (dies ist amd64). Der Digest sieht in etwa so aus: sha256:....

Sobald Sie den Digest für das amd64-Manifest haben, können Sie es mit dem Befehl docker manifest inspect untersuchen. Danach geben Sie den Image-Namen und den Digest an, getrennt durch ein @-Symbol.

Ersetzen Sie YOUR_AMD64_DIGEST durch den tatsächlichen Digest, den Sie für die amd64-Plattform in der Ausgabe des vorherigen Schritts gefunden haben.

docker manifest inspect alpine@YOUR_AMD64_DIGEST

Beispielsweise, wenn der amd64-Digest sha256:f70734b6a266dcb51c52a820c34f3204cc6897445f6510b7a5be74d30a72f227 war, würde der Befehl lauten:

docker manifest inspect alpine@sha256:f70734b6a266dcb51c52a820c34f3204cc6897445f6510b7a5be74d30a72f227

Dieser Befehl gibt ein JSON-Dokument aus, das das spezifische Image-Manifest für die amd64-Architektur darstellt. Dieses Manifest enthält Details über die Image-Schichten (identifiziert durch ihre Digests) und die Image-Konfiguration (ebenfalls identifiziert durch einen Digest).

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

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

Diese Ausgabe zeigt die Struktur eines einzelnen Image-Manifests, das die Konfiguration und die Schichten auflistet, aus denen das Image für diese spezifische Architektur besteht.

Das Manifest mit ausführlicher Ausgabe untersuchen

In den vorherigen Schritten haben wir die Manifestliste und ein spezifisches Image-Manifest untersucht. Die Standardausgabe von docker manifest inspect bietet eine Zusammenfassung des Manifests oder der Manifestliste. Um detailliertere Informationen, einschließlich der vollständigen Konfiguration des Images, zu erhalten, können wir die Option --verbose verwenden.

Lassen Sie uns erneut die Manifestliste für alpine:latest untersuchen, diesmal jedoch mit der Option --verbose. Dadurch wird die Manifestliste angezeigt, und für jedes Manifest in der Liste werden auch die vollständigen Konfigurationsdetails angezeigt.

Führen Sie den folgenden Befehl in Ihrem Terminal aus:

docker manifest inspect --verbose alpine:latest

Dieser Befehl gibt ein umfangreicheres JSON-Dokument aus. Für jeden Eintrag in der manifests-Liste wird jetzt ein zusätzliches Feld namens Config angezeigt. Dieses Config-Feld enthält die vollständige Konfiguration des Images für diese spezifische Architektur, einschließlich Details wie Eintrittspunkt, Befehl, Umgebungsvariablen, Arbeitsverzeichnis und mehr.

Sie sollten eine Ausgabe ähnlich der folgenden sehen (die genauen Details im Config-Abschnitt können variieren):

{
   "schemaVersion": 2,
   "mediaType": "application/vnd.docker.distribution.manifest.list.v2+json",
   "manifests": [
      {
         "mediaType": "application/vnd.docker.distribution.manifest.v2+json",
         "size": 528,
         "digest": "sha256:...",
         "platform": {
            "architecture": "amd64",
            "os": "linux"
         },
         "Config": {
            "Env": [
               "PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
            ],
            "Entrypoint": [
               "/bin/sh"
            ],
            "Cmd": null,
            "WorkingDir": "/",
            ...
         }
      },
      ...
   ]
}

Die Verwendung der Option --verbose ist nützlich, wenn Sie die detaillierte Konfiguration der Images in einer Manifestliste sehen müssen. Dies kann hilfreich sein, um Probleme zu beheben oder zu verstehen, wie ein bestimmtes Image eingerichtet ist.

Zusammenfassung

In diesem Lab haben wir gelernt, wie man den Befehl docker manifest inspect verwendet, um Image-Manifeste anzuzeigen. Wir haben begonnen, indem wir ein Multi-Architektur-Image, alpine, heruntergeladen haben und verstanden haben, dass ein einzelner Tag Images für verschiedene Architekturen repräsentieren kann.

Anschließend haben wir docker manifest inspect verwendet, um die Manifestliste anzuzeigen, die mit dem Multi-Architektur-Image verknüpft ist. Diese Liste enthält Details zu den verfügbaren Image-Manifesten für verschiedene Architekturen. Schließlich haben wir untersucht, wie man ein spezifisches Image-Manifest in der Liste untersucht und wie man detailliertere Informationen mit der Option für ausführliche Ausgabe erhält.