Wie man den docker buildx debug build-Befehl zum Erstellen und Untersuchen von Images verwendet

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 debug build effektiv nutzen können, um Docker-Images zu erstellen und zu untersuchen. Sie beginnen mit dem Erstellen eines einfachen Images mit Standardeinstellungen unter Verwendung einer Dockerfile.

Aufbauend auf den Grundlagen werden Sie dann fortgeschrittenere Build-Szenarien erkunden, einschließlich der Integration von Build-Argumenten und Labels in Ihre Images. Sie lernen außerdem, wie Sie während des Build-Prozesses bestimmte Plattformen anvisieren und das resultierende Image in eine Datei ausgeben können. Abschließend behandelt das Lab Techniken zur Steuerung des Build-Caches und zur sicheren Bereitstellung von Secrets während des Builds, um ein umfassendes Verständnis der Funktionalitäten des Befehls docker buildx debug build zu vermitteln.


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/run("Run a Container") docker/ContainerOperationsGroup -.-> docker/inspect("Inspect Container") docker/ImageOperationsGroup -.-> docker/images("List Images") docker/ImageOperationsGroup -.-> docker/save("Save Image") docker/DockerfileGroup -.-> docker/build("Build Image from Dockerfile") subgraph Lab Skills docker/run -.-> lab-555047{{"Wie man den docker buildx debug build-Befehl zum Erstellen und Untersuchen von Images verwendet"}} docker/inspect -.-> lab-555047{{"Wie man den docker buildx debug build-Befehl zum Erstellen und Untersuchen von Images verwendet"}} docker/images -.-> lab-555047{{"Wie man den docker buildx debug build-Befehl zum Erstellen und Untersuchen von Images verwendet"}} docker/save -.-> lab-555047{{"Wie man den docker buildx debug build-Befehl zum Erstellen und Untersuchen von Images verwendet"}} docker/build -.-> lab-555047{{"Wie man den docker buildx debug build-Befehl zum Erstellen und Untersuchen von Images verwendet"}} end

Ein einfaches Image mit Standardeinstellungen erstellen

In diesem Schritt lernen Sie, wie Sie ein einfaches Docker-Image mit einer Dockerfile erstellen. Eine Dockerfile ist ein Textdokument, das alle Befehle enthält, die ein Benutzer auf der Kommandozeile aufrufen würde, um ein Image zusammenzustellen. Docker kann Images automatisch erstellen, indem es die Anweisungen aus einer Dockerfile liest.

Navigieren Sie zunächst in das Verzeichnis ~/project, das Ihr Arbeitsverzeichnis für dieses Lab ist.

cd ~/project

Nun erstellen wir eine einfache Dockerfile. Wir legen eine Datei namens Dockerfile im Verzeichnis ~/project an. Diese Dockerfile definiert die Schritte zur Erstellung eines Images basierend auf dem Basis-Image ubuntu und installiert das Paket cowsay.

Verwenden Sie den nano-Editor, um die Dockerfile zu erstellen und zu bearbeiten:

nano Dockerfile

Fügen Sie folgenden Inhalt zur Dockerfile hinzu:

FROM ubuntu:latest
RUN apt-get update && apt-get install -y cowsay
CMD ["cowsay", "Hello, Docker!"]

Lassen Sie uns diese Dockerfile analysieren:

  • FROM ubuntu:latest: Diese Anweisung legt das Basis-Image für unser neues Image fest. Wir verwenden die neueste Version des offiziellen Ubuntu-Images von Docker Hub.
  • RUN apt-get update && apt-get install -y cowsay: Diese Anweisung führt Befehle in einer neuen Ebene über dem aktuellen Image aus und speichert die Ergebnisse. Hier aktualisieren wir die Paketliste und installieren das Paket cowsay. Das Flag -y beantwortet automatisch alle Prompts mit "Ja".
  • CMD ["cowsay", "Hello, Docker!"]: Diese Anweisung definiert Standardbefehle für einen ausgeführten Container. Wenn ein Container aus diesem Image ohne spezifischen Befehl gestartet wird, führt er cowsay "Hello, Docker!" aus.

Speichern Sie die Datei mit Strg + X, dann Y und Enter.

Nun, da wir unsere Dockerfile haben, können wir das Image erstellen. Verwenden Sie den Befehl docker build. Der Punkt . am Ende des Befehls weist Docker an, nach der Dockerfile im aktuellen Verzeichnis (~/project) zu suchen. Wir versehen das Image auch mit einem Tag, zum Beispiel my-cowsay-image.

docker build -t my-cowsay-image .

Dieser Befehl führt die Anweisungen in der Dockerfile Schritt für Schritt aus. Sie sehen eine Ausgabe, die jeden verarbeiteten Schritt anzeigt, einschließlich des Herunterladens des Basis-Images (falls noch nicht vorhanden) und der Installation von cowsay.

Nach Abschluss des Build-Prozesses können Sie überprüfen, ob das Image erfolgreich erstellt wurde, indem Sie die verfügbaren Images mit dem Befehl docker images auflisten:

docker images

Sie sollten my-cowsay-image in der Ausgabe sehen.

Abschließend starten wir einen Container aus dem soeben erstellten Image, um zu prüfen, ob es wie erwartet funktioniert.

docker run my-cowsay-image

Dieser Befehl erstellt und startet einen neuen Container basierend auf my-cowsay-image. Da wir in unserer Dockerfile eine CMD-Anweisung definiert haben, führt der Container automatisch cowsay "Hello, Docker!" aus, und Sie sollten die Kuh mit der Ausgabe "Hello, Docker!" in Ihrem Terminal sehen.

Ein Image mit Build-Argumenten und Labels erstellen

In diesem Schritt lernen Sie, wie Sie Build-Argumente (ARG) und Labels (LABEL) in Ihrer Dockerfile verwenden. Build-Argumente ermöglichen es Ihnen, Variablen an den Build-Prozess zu übergeben, wodurch Ihre Dockerfile flexibler wird. Labels sind Schlüssel-Wert-Paare, die Sie einem Image hinzufügen können, um Metadaten anzufügen.

Stellen Sie zunächst sicher, dass Sie sich im Verzeichnis ~/project befinden:

cd ~/project

Nun passen wir die Dockerfile aus dem vorherigen Schritt an. Wir fügen ein Build-Argument hinzu, um die von cowsay angezeigte Nachricht anzupassen, sowie ein Label zum Image.

Öffnen Sie die Dockerfile zur Bearbeitung:

nano Dockerfile

Ändern Sie den Inhalt, um ARG und LABEL Anweisungen einzufügen:

FROM ubuntu:latest
ARG MESSAGE="Hello, Docker!"
RUN apt-get update && apt-get install -y cowsay
LABEL maintainer="Your Name <[email protected]>"
CMD ["cowsay", "$MESSAGE"]

Betrachten wir die Änderungen:

  • ARG MESSAGE="Hello, Docker!": Diese Anweisung definiert ein Build-Argument namens MESSAGE mit dem Standardwert "Hello, Docker!". Dieser Wert kann während des Build-Prozesses überschrieben werden.
  • LABEL maintainer="Your Name <[email protected]>": Diese Anweisung fügt dem Image ein Label hinzu. Labels sind nützlich, um Informationen wie den Maintainer, die Version oder andere relevante Metadaten hinzuzufügen.
  • CMD ["cowsay", "$MESSAGE"]: Wir haben die CMD Anweisung geändert, um den Wert des MESSAGE Build-Arguments zu verwenden.

Speichern Sie die geänderte Dockerfile mit Strg + X, dann Y und Enter.

Nun bauen wir das Image erneut, diesmal übergeben wir jedoch einen Wert für das MESSAGE Build-Argument mit dem --build-arg Flag. Wir versehen es auch mit einem neuen Tag, my-custom-cowsay-image.

docker build --build-arg MESSAGE="Building with arguments!" -t my-custom-cowsay-image .

Beobachten Sie die Ausgabe während des Build-Prozesses. Sie sollten sehen, dass die ARG Anweisung verarbeitet wird und der Wert von MESSAGE auf "Building with arguments!" gesetzt wird.

Nach Abschluss des Builds starten wir einen Container aus diesem neuen Image:

docker run my-custom-cowsay-image

Diesmal sollte der Container die benutzerdefinierte Nachricht "Building with arguments!" ausgeben.

Sie können das Image auch inspizieren, um die hinzugefügten Labels zu sehen. Verwenden Sie den Befehl docker inspect gefolgt vom Image-Namen:

docker inspect my-custom-cowsay-image

Suchen Sie im Output nach dem Abschnitt "Labels". Dort sollten Sie das maintainer Label mit dem in der Dockerfile angegebenen Wert finden.

Ein Image für eine spezifische Plattform erstellen und in eine Datei exportieren

In diesem Schritt lernen Sie, wie Sie ein Docker-Image für eine bestimmte Plattform erstellen und das gebaute Image in eine Datei exportieren. Das Bauen für verschiedene Plattformen ist nützlich, wenn Sie Ihre Anwendung auf Systemen mit unterschiedlichen Architekturen (z.B. ARM vs. x86) bereitstellen müssen. Der Export in eine Datei ermöglicht es Ihnen, das Image als tar-Archiv zu speichern, das einfach übertragen und in einer anderen Docker-Umgebung geladen werden kann.

Stellen Sie zunächst sicher, dass Sie sich im Verzeichnis ~/project befinden:

cd ~/project

Wir verwenden dieselbe Dockerfile aus dem vorherigen Schritt. Sie können deren Inhalt mit dem cat-Befehl anzeigen:

cat Dockerfile

Die Ausgabe sollte sein:

FROM ubuntu:latest
ARG MESSAGE="Hello, Docker!"
RUN apt-get update && apt-get install -y cowsay
LABEL maintainer="Your Name <[email protected]>"
CMD ["cowsay", "$MESSAGE"]

Nun erstellen wir das Image speziell für die Plattform linux/arm64. Wir verwenden dazu das Flag --platform. Beachten Sie, dass das Bauen für eine andere Plattform Docker Buildx erfordert, das typischerweise in neueren Docker-Installationen enthalten ist.

docker build --platform linux/arm64 -t my-arm64-cowsay-image .

Dieser Befehl erstellt das Image für die ARM64-Architektur. Sie sehen eine ähnliche Ausgabe wie bei vorherigen Builds, aber der Build-Prozess zielt auf eine andere Architektur ab.

Nach Abschluss des Builds können Sie Ihre Images auflisten, um das neu erstellte Image zu sehen. Beachten Sie, dass die Spalte ARCHITECTURE für dieses Image arm64 anzeigt.

docker images

Als nächstes exportieren wir dieses Image in eine tar-Datei. Dies ist nützlich, um Images ohne Registry zu speichern und zu teilen. Wir verwenden das Flag --output mit der Option type=tar.

docker build --platform linux/arm64 -t my-arm64-cowsay-image . --output type=tar,dest=my-arm64-cowsay-image.tar

Dieser Befehl erstellt das Image erneut (ggf. unter Verwendung des Build-Caches) und speichert es dann als tar-Datei namens my-arm64-cowsay-image.tar im Verzeichnis ~/project.

Sie können überprüfen, ob die tar-Datei erstellt wurde, indem Sie den ls-Befehl verwenden:

ls -lh my-arm64-cowsay-image.tar

Sie sollten die Datei mit ihrer Größe aufgelistet sehen. Diese tar-Datei enthält alle Layer des my-arm64-cowsay-image. Sie könnten diese Datei dann auf einen anderen Rechner übertragen und mit docker load -i my-arm64-cowsay-image.tar laden.

Ein Image mit Cache-Kontrolle und sicherem Umgang mit Secrets erstellen

In diesem Schritt lernen Sie, wie Sie den Docker-Build-Cache kontrollieren und mit Secrets während des Build-Prozesses umgehen können, indem Sie den secret-Mount-Typ von BuildKit verwenden. Der Build-Cache kann Builds deutlich beschleunigen, aber manchmal müssen Sie ihn deaktivieren. Der sichere Umgang mit Secrets ist entscheidend, um sensible Informationen nicht in Ihren Image-Layern einzubetten.

Stellen Sie zunächst sicher, dass Sie sich im Verzeichnis ~/project befinden:

cd ~/project

Passen wir die Dockerfile an, um einen Schritt einzufügen, für den wir die Cache-Kontrolle demonstrieren wollen, sowie einen Platzhalter für die Verwendung eines Secrets.

Öffnen Sie die Dockerfile zur Bearbeitung:

nano Dockerfile

Ändern Sie den Inhalt, um einen RUN-Befehl hinzuzufügen, der eine Datei mit einem Zeitstempel erstellt, sowie einen Platzhalter für die Verwendung eines Secrets:

FROM ubuntu:latest
ARG MESSAGE="Hello, Docker!"
RUN apt-get update && apt-get install -y cowsay
LABEL maintainer="Your Name <[email protected]>"
RUN echo "Build time: $(date)" > /app/build_info.txt
## Dies ist ein Platzhalter für einen Befehl, der ein Secret verwenden würde
## RUN --mount=type=secret,id=mysecret cat /run/secrets/mysecret > /app/secret_info.txt
CMD ["cowsay", "$MESSAGE"]

Wir haben RUN echo "Build time: $(date)" > /app/build_info.txt hinzugefügt. Dieser Befehl erstellt eine Datei /app/build_info.txt mit dem Zeitstempel, wann dieses Layer gebaut wurde. Standardmäßig cached Docker Layers. Wenn Sie das Image mehrmals bauen, ohne die Anweisungen vor diesem RUN-Befehl zu ändern, könnte dieses Layer aus dem Cache kommen, und der Zeitstempel würde sich nicht aktualisieren.

Speichern Sie die geänderte Dockerfile mit Strg + X, dann Y und Enter.

Nun bauen wir das Image mit einem neuen Tag, my-cached-image:

docker build -t my-cached-image .

Beobachten Sie die Ausgabe. Wenn Sie das Image kürzlich gebaut haben, sehen Sie möglicherweise ---> Using cache für einige Schritte.

Um die Cache-Kontrolle zu demonstrieren, bauen wir das Image erneut, diesmal deaktivieren wir den Cache für den gesamten Build mit dem --no-cache-Flag:

docker build --no-cache -t my-no-cache-image .

Sie werden sehen, dass Docker jedes Layer neu baut, selbst wenn sich die Anweisungen nicht geändert haben. Dies ist nützlich, wenn Sie sicherstellen wollen, dass alle Abhängigkeiten frisch bezogen werden oder wenn ein vorheriger Build den Cache beschädigt hat.

Nun zum Umgang mit Secrets. Die auskommentierte Zeile ## RUN --mount=type=secret,id=mysecret cat /run/secrets/mysecret > /app/secret_info.txt zeigt, wie Sie ein Secret mit BuildKit verwenden würden. Um dies zu nutzen, müssten Sie BuildKit aktivieren (was in neueren Docker-Versionen oft standardmäßig aktiviert ist) und das Secret während des Builds mit dem --secret-Flag bereitstellen.

Zum Beispiel, wenn Sie eine Datei namens mysecret.txt mit Ihrem Secret hätten, würden Sie so bauen (dieser Befehl funktioniert nicht direkt, da wir keine mysecret.txt-Datei haben und die Zeile auskommentiert ist, aber er zeigt die Syntax):

## docker build --secret id=mysecret,src=mysecret.txt -t my-secret-image .

Die Anweisung RUN --mount=type=secret,id=mysecret macht den Inhalt des Secrets nur während des Build-Schritts unter /run/secrets/mysecret verfügbar. Das Secret wird nicht in den finalen Image-Layern gespeichert. Dies ist die sichere Methode, um sensible Informationen wie API-Keys oder Passwörter während des Builds zu handhaben.

Da wir keine Secret-Datei haben und die Zeile auskommentiert ist, werden wir den Secret-bezogenen Build-Befehl nicht ausführen. Dennoch ist das Verständnis von --no-cache und dem secret-Mount-Typ wichtig, um Ihre Builds zu kontrollieren und sensible Daten sicher zu handhaben.

Zusammenfassung

In diesem Lab haben Sie die Grundlagen des Erstellens von Docker-Images mit einer Dockerfile gelernt. Sie begannen mit dem Erstellen einer einfachen Dockerfile basierend auf Ubuntu, installierten ein Paket und definierten einen Standardbefehl. Dies führte Sie in die grundlegenden Anweisungen FROM, RUN und CMD ein, sowie in das Erstellen eines Images mit docker build und einem Tag.

Aufbauend auf den Grundlagen haben Sie fortgeschrittene Techniken zum Erstellen von Images erkundet. Sie lernten, wie Sie Build-Argumente und Labels in Ihre Dockerfile integrieren, um den Build-Prozess anzupassen und Metadaten zum Image hinzuzufügen. Sie übten auch das Erstellen von Images für spezifische Plattformen und das Exportieren des resultierenden Images in eine Datei, was demonstrierte, wie Sie die Build-Ausgabe kontrollieren können. Abschließend beschäftigten Sie sich mit der Verwaltung des Build-Caches und dem sicheren Umgang mit Secrets während des Build-Prozesses, wobei bewährte Methoden für effizientes und sicheres Image-Erstellen hervorgehoben wurden.