Verwendung des docker buildx bake Befehls zum Bauen mehrerer Targets

Einführung

In diesem Lab lernen Sie, wie Sie den Befehl docker buildx bake effektiv nutzen können, um mehrere Docker-Image-Targets aus einer einzigen Konfigurationsdatei zu verwalten und zu erstellen. Wir beginnen mit der Erstellung einer docker-bake.hcl-Datei, die verschiedene Build-Targets mit unterschiedlichen Konfigurationen definiert.

In praktischen Schritten üben Sie das Erstellen spezifischer Targets aus der Bake-Datei, das Auflisten verfügbarer Targets, das Überschreiben von Target-Konfigurationen über Befehlszeilenflags und das Vorschauen der Build-Konfiguration ohne tatsächliche Ausführung des Builds. Dieses Lab vermittelt Ihnen die Fähigkeiten, um Ihre Docker-Image-Build-Workflows für komplexe Projekte zu optimieren.

Skills Graph

Erstellen einer einfachen docker-bake.hcl-Datei mit mehreren Targets

In diesem Schritt erstellen wir eine grundlegende docker-bake.hcl-Datei. Diese Datei verwendet das HCL-Format (HashiCorp Configuration Language) und ermöglicht die Definition mehrerer Build-Targets für Docker-Images. Dies ist besonders nützlich, wenn Sie unterschiedliche Build-Konfigurationen haben oder mehrere verwandte Images aus einer einzigen Quelle erstellen möchten.

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

cd ~/project

Erstellen Sie nun eine neue Datei namens docker-bake.hcl mit dem nano-Editor.

nano docker-bake.hcl

Fügen Sie im nano-Editor folgenden Inhalt ein. Diese Datei definiert zwei Build-Targets: my-app-dev und my-app-prod. Jedes Target gibt das zu verwendende Dockerfile (Dockerfile), den Build-Kontext (.) und die Tags für das resultierende Image an.

target "my-app-dev" {
  dockerfile = "Dockerfile"
  context = "."
  tags = ["my-app:dev"]
}

target "my-app-prod" {
  dockerfile = "Dockerfile"
  context = "."
  tags = ["my-app:prod"]
  args = {
    BUILD_ENV = "production"
  }
}

In dieser Datei:

• target "my-app-dev" definiert ein Target namens my-app-dev.
• dockerfile = "Dockerfile" gibt an, dass der Build eine Datei namens Dockerfile im Kontext verwenden soll.
• context = "." setzt den Build-Kontext auf das aktuelle Verzeichnis.
• tags = ["my-app:dev"] weist dem resultierenden Image den Tag my-app:dev zu.
• target "my-app-prod" definiert ein weiteres Target namens my-app-prod.
• Es verwendet ebenfalls Dockerfile und das aktuelle Verzeichnis als Kontext.
• tags = ["my-app:prod"] weist diesem Image den Tag my-app:prod zu.
• args = { BUILD_ENV = "production" } übergibt ein Build-Argument BUILD_ENV mit dem Wert production an das Dockerfile während des Builds dieses Targets.

Speichern Sie die Datei mit Strg + S und beenden Sie nano mit Strg + X.

Als nächstes benötigen wir ein einfaches Dockerfile, auf das unsere Bake-Datei verweisen kann. Erstellen Sie eine Datei namens Dockerfile im gleichen Verzeichnis.

nano Dockerfile

Fügen Sie folgenden Inhalt in das Dockerfile ein:

FROM alpine:latest

ARG BUILD_ENV=development

RUN echo "Building for environment: $BUILD_ENV"

CMD ["echo", "Hello from $BUILD_ENV environment!"]

Dieses Dockerfile verwendet das Basis-Image alpine:latest. Es definiert ein Build-Argument BUILD_ENV mit dem Standardwert development. Die RUN-Anweisung gibt die Build-Umgebung während des Build-Prozesses aus, und die CMD-Anweisung setzt den Standardbefehl, der ausgeführt wird, wenn ein Container aus diesem Image gestartet wird.

Speichern Sie das Dockerfile und beenden Sie nano.

Sie haben nun erfolgreich eine docker-bake.hcl-Datei mit zwei Targets und ein einfaches Dockerfile für die Verwendung damit erstellt.

Ein spezifisches Target mit docker buildx bake erstellen

Im vorherigen Schritt haben wir eine docker-bake.hcl-Datei mit zwei Build-Targets erstellt: my-app-dev und my-app-prod. Nun werden wir den Befehl docker buildx bake verwenden, um ein spezifisches Target aus dieser Datei zu bauen.

Der Befehl docker buildx bake ermöglicht das Erstellen von Images basierend auf den Konfigurationen in einer Bake-Datei. Durch Angabe des Target-Namens nach dem Befehl weisen Sie Buildx an, nur dieses spezielle Target zu bauen.

Lassen Sie uns das Target my-app-dev bauen. Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden.

cd ~/project

Führen Sie nun folgenden Befehl aus:

docker buildx bake my-app-dev

Dieser Befehl liest die docker-bake.hcl-Datei im aktuellen Verzeichnis und baut das Target namens my-app-dev. Sie sollten eine Ausgabe sehen, die den Build-Prozess anzeigt, einschließlich der im Dockerfile definierten Schritte.

[+] Building 0.0s (0/0)
... (Build-Ausgabe) ...

Nach Abschluss des Builds können Sie überprüfen, ob das Image my-app:dev erstellt wurde, indem Sie Ihre lokalen Docker-Images auflisten.

docker images

Sie sollten my-app mit dem Tag dev in der Liste der Images sehen.

Nun bauen wir das Target my-app-prod. Dieses Target enthält ein Build-Argument BUILD_ENV, das auf production gesetzt ist.

docker buildx bake my-app-prod

Beobachten Sie die Ausgabe. Sie sollten während des Build-Prozesses die Zeile Building for environment: production sehen, was bestätigt, dass das Build-Argument korrekt übergeben wurde.

[+] Building 0.0s (0/0)
... (Build-Ausgabe mit "Building for environment: production") ...

Nach Abschluss dieses Builds listen Sie Ihre Images erneut auf.

docker images

Sie sollten nun sowohl my-app:dev als auch my-app:prod in Ihrer Image-Liste sehen.

Durch Verwendung von docker buildx bake gefolgt vom Target-Namen können Sie selektiv verschiedene in Ihrer Bake-Datei definierte Konfigurationen bauen.

Verfügbare Targets in der Bake-Datei auflisten

In den vorherigen Schritten haben wir eine docker-bake.hcl-Datei erstellt und spezifische Targets daraus gebaut. Manchmal möchten Sie möglicherweise alle verfügbaren Targets in einer Bake-Datei einsehen, ohne sie tatsächlich zu bauen. Der Befehl docker buildx bake bietet eine Möglichkeit dazu.

Um die verfügbaren Targets aufzulisten, können Sie einfach den Befehl docker buildx bake ohne Angabe von Target-Namen ausführen. Standardmäßig liest er die docker-bake.hcl-Datei im aktuellen Verzeichnis und zeigt die Namen aller definierten Targets an.

Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden, wo sich Ihre docker-bake.hcl-Datei befindet.

cd ~/project

Führen Sie nun folgenden Befehl aus:

docker buildx bake

Sie sollten eine ähnliche Ausgabe wie diese sehen, die die in Ihrer docker-bake.hcl-Datei definierten Targets auflistet:

my-app-dev
my-app-prod

Diese Ausgabe zeigt die Namen der beiden Targets, die wir in der docker-bake.hcl-Datei definiert haben: my-app-dev und my-app-prod. Dies ist eine schnelle Möglichkeit, einen Überblick über die in einer Bake-Datei verfügbaren Build-Konfigurationen zu erhalten.

Dieser Befehl ist nützlich, um die Struktur einer Bake-Datei zu verstehen und die Targets zu identifizieren, die Sie bauen können.

Target-Konfiguration mit dem --set-Flag überschreiben

In diesem Schritt lernen wir, wie man die Konfiguration eines spezifischen Targets in der docker-bake.hcl-Datei mit dem --set-Flag des docker buildx bake-Befehls überschreiben kann. Dies ist nützlich, wenn Sie kleinere Anpassungen an der Konfiguration eines Targets vornehmen müssen, ohne die Bake-Datei selbst zu ändern.

Das --set-Flag ermöglicht das Überschreiben spezifischer Attribute eines Targets. Die Syntax lautet target_name.attribute=wert.

Angenommen, wir möchten das my-app-dev-Target bauen, aber mit einem anderen Tag, zum Beispiel my-app:staging. Dies können wir mit dem --set-Flag erreichen.

Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden.

cd ~/project

Führen Sie nun folgenden Befehl aus:

docker buildx bake my-app-dev --set my-app-dev.tags=my-app:staging

In diesem Befehl:

• my-app-dev ist der Name des Targets, das wir bauen
• --set my-app-dev.tags=my-app:staging überschreibt das tags-Attribut des my-app-dev-Targets und setzt seinen Wert auf my-app:staging

Sie werden die Build-Prozessausgabe sehen.

[+] Building 0.0s (0/0)
... (Build-Ausgabe) ...

Nach Abschluss des Builds listen Sie Ihre lokalen Docker-Images auf, um zu überprüfen, ob das Image mit dem neuen Tag erstellt wurde.

docker images

Sie sollten nun my-app mit dem Tag staging in der Liste sehen, zusätzlich zu den Tags dev und prod aus den vorherigen Schritten.

Sie können auch andere Attribute überschreiben, wie Build-Argumente. Lassen Sie uns das my-app-prod-Target bauen, aber das BUILD_ENV-Argument auf qa überschreiben.

docker buildx bake my-app-prod --set my-app-prod.args.BUILD_ENV=qa

Beobachten Sie die Build-Ausgabe. Sie sollten Building for environment: qa sehen, was anzeigt, dass das Build-Argument erfolgreich überschrieben wurde.

[+] Building 0.0s (0/0)
... (Build-Ausgabe mit "Building for environment: qa") ...

Das --set-Flag bietet eine flexible Möglichkeit, Ihre Builds direkt über die Kommandozeile anzupassen, ohne die Bake-Datei zu verändern.

Resultierende Konfiguration ohne Build ausgeben

In diesem letzten Schritt untersuchen wir, wie die finale Konfiguration angezeigt werden kann, die docker buildx bake für ein bestimmtes Target verwenden würde - inklusive aller mit dem --set-Flag angewendeten Überschreibungen - ohne tatsächlich einen Build auszulösen. Dies ist nützlich zum Debuggen von Bake-Dateien und zum Verständnis der effektiven Konfiguration vor dem Build.

Das --print-Flag mit docker buildx bake ermöglicht die Ausgabe der aufgelösten Konfiguration im JSON-Format.

Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden.

cd ~/project

Lassen Sie uns die Konfiguration für das my-app-dev-Target ausgeben.

docker buildx bake my-app-dev --print

Dieser Befehl gibt eine JSON-Darstellung der my-app-dev-Target-Konfiguration aus, wie sie aus der docker-bake.hcl-Datei abgeleitet wird.

{
  "target": {
    "my-app-dev": {
      "dockerfile": "Dockerfile",
      "context": ".",
      "tags": ["my-app:dev"]
    }
  }
}

Nun sehen wir, wie das --set-Flag die ausgegebene Konfiguration beeinflusst. Wir geben die Konfiguration für my-app-dev aus, während wir den Tag auf my-app:testing überschreiben.

docker buildx bake my-app-dev --set my-app-dev.tags=my-app:testing --print

Beobachten Sie die Ausgabe. Das tags-Attribut in der JSON-Ausgabe sollte nun den überschriebenen Wert widerspiegeln.

{
  "target": {
    "my-app-dev": {
      "dockerfile": "Dockerfile",
      "context": ".",
      "tags": ["my-app:testing"]
    }
  }
}

Ebenso können Sie die Konfiguration für das my-app-prod-Target ausgeben und dessen Build-Argument überschreiben.

docker buildx bake my-app-prod --set my-app-prod.args.BUILD_ENV=staging --print

Die JSON-Ausgabe für das my-app-prod-Target zeigt die args mit dem überschriebenen BUILD_ENV-Wert.

{
  "target": {
    "my-app-prod": {
      "dockerfile": "Dockerfile",
      "context": ".",
      "tags": ["my-app:prod"],
      "args": {
        "BUILD_ENV": "staging"
      }
    }
  }
}

Das --print-Flag ist ein wertvolles Werkzeug, um Bake-Datei-Konfigurationen zu überprüfen und zu verstehen, wie Überschreibungen angewendet werden, bevor potenziell zeitaufwändige Builds initiiert werden.

Zusammenfassung

In diesem Lab haben wir gelernt, wie der Befehl docker buildx bake genutzt werden kann, um mehrere Docker-Image-Targets zu verwalten und zu bauen, die in einer einzelnen docker-bake.hcl-Datei definiert sind. Wir begannen mit der Erstellung einer grundlegenden docker-bake.hcl-Datei mit verschiedenen Targets, wobei jedes Target sein Dockerfile, Context, Tags und Build-Argumente spezifiziert.

Anschließend haben wir untersucht, wie man:

• Ein spezifisches Target aus der Bake-Datei mit docker buildx bake <target_name> baut
• Alle verfügbaren Targets innerhalb der Datei auflistet
• Target-Konfigurationen dynamisch mit dem --set-Flag überschreibt
• Die resultierende Build-Konfiguration mit dem --print-Flag einsehen kann, ohne den Build tatsächlich durchzuführen

Diese Schritte demonstrieren die Flexibilität und Leistungsfähigkeit von docker buildx bake zur Vereinfachung komplexer Multi-Image-Build-Workflows.