So beheben Sie das Problem "Docker Buildx Build benötigt genau 1 Argument"

Einführung

Docker Buildx erweitert den Standard-Docker-Build-Befehl um erweiterte Funktionen zur Erstellung von Multi-Architektur-Images. Benutzer stoßen jedoch oft auf den Fehler "docker buildx build requires exactly 1 argument" (docker buildx build benötigt genau 1 Argument), wenn sie mit diesem Tool arbeiten. Dieses umfassende Tutorial führt Sie durch das Verständnis von Docker Buildx, die Diagnose dieses häufigen Fehlers und die Implementierung effektiver Lösungen.

Am Ende dieses Labs werden Sie praktische Erfahrungen mit der Einrichtung von Docker Buildx, der Erstellung von Docker-Images, der Fehlerbehebung des Fehlers "requires exactly 1 argument" und dem Erstellen von Images für mehrere Architekturen haben. Diese Fähigkeiten sind für die moderne containerisierte Anwendungsentwicklung und -bereitstellung unerlässlich.

Einrichten von Docker Buildx

Docker Buildx ist bereits mit Docker vorinstalliert, muss aber vor der Verwendung richtig eingerichtet werden. In diesem Schritt werden wir überprüfen, ob Docker installiert ist, Docker Buildx aktivieren und unsere erste Builder-Instanz erstellen.

Überprüfen der Docker-Installation

Lassen Sie uns zunächst bestätigen, dass Docker auf unserem System installiert ist und ausgeführt wird:

docker --version

Sie sollten eine ähnliche Ausgabe sehen:

Docker version 20.10.21, build baeda1f

Dies bestätigt, dass Docker installiert und einsatzbereit ist.

Docker Buildx verstehen

Docker Buildx ist ein CLI-Plugin, das die Funktionalität von Docker mit BuildKit erweitert. Es ermöglicht:

• Das gleichzeitige Erstellen von Images für mehrere Plattformen (z. B. AMD64, ARM64)
• Effizienteres Layer-Caching
• Verbesserte Build-Performance
• Erweiterte Build-Funktionen

Erstellen eines Docker Buildx Builders

Lassen Sie uns einen neuen Docker Buildx Builder erstellen und verwenden:

docker buildx create --name mybuilder --use

Die Ausgabe sollte ähnlich aussehen:

mybuilder

Überprüfen wir nun, ob unser Builder erstellt und als Standard festgelegt wurde:

docker buildx ls

Sie sollten eine ähnliche Ausgabe sehen:

NAME/NODE    DRIVER/ENDPOINT             STATUS  PLATFORMS
mybuilder *  docker-container
  mybuilder0 unix:///var/run/docker.sock inactive
default      docker
  default    default                     running  linux/amd64, linux/386

Das Sternchen (*) neben mybuilder zeigt an, dass es sich um den aktuell aktiven Builder handelt.

Untersuchen des Builders

Untersuchen wir die Details unseres Builders:

docker buildx inspect mybuilder

Dies zeigt Ihnen die Konfiguration des Builders, einschließlich der unterstützten Plattformen und seines aktuellen Status.

Nachdem wir Docker Buildx erfolgreich eingerichtet haben, können wir nun mit der Erstellung eines Dockerfiles fortfahren, das mit unserem Builder verwendet werden soll.

Erstellen eines einfachen Dockerfiles zum Testen

Bevor wir Docker Buildx zum Erstellen von Images verwenden, müssen wir ein einfaches Dockerfile erstellen. Dies dient als unser Testfall, um den Fehler "requires exactly 1 argument" (benötigt genau 1 Argument) zu verstehen.

Dockerfiles verstehen

Ein Dockerfile ist ein Textdokument, das Anweisungen zum Erstellen eines Docker-Images enthält. Es automatisiert den Prozess der Erstellung von Containern mit spezifischen Konfigurationen.

Lassen Sie uns ein Verzeichnis für unser Projekt erstellen:

mkdir -p ~/project/buildx-test
cd ~/project/buildx-test

Erstellen eines einfachen Dockerfiles

Erstellen wir nun ein einfaches Dockerfile mit dem Texteditor nano:

nano Dockerfile

Kopieren Sie den folgenden Inhalt und fügen Sie ihn in das Dockerfile ein:

FROM ubuntu:22.04

RUN apt-get update && apt-get install -y \
  curl \
  nginx \
  && rm -rf /var/lib/apt/lists/*

EXPOSE 80

CMD ["nginx", "-g", "daemon off;"]

Drücken Sie Ctrl+O gefolgt von Enter zum Speichern und dann Ctrl+X zum Beenden von nano.

Lassen Sie uns dieses Dockerfile aufschlüsseln:

• FROM ubuntu:22.04 - Verwendet Ubuntu 22.04 als Basis-Image
• RUN apt-get update... - Aktualisiert Paketlisten und installiert curl und nginx
• EXPOSE 80 - Gibt an, dass der Container auf Port 80 lauschen wird
• CMD ["nginx", "-g", "daemon off;"] - Führt nginx im Vordergrund aus, wenn der Container startet

Erstellen einer .dockerignore-Datei

Eine .dockerignore-Datei hilft dabei, Dateien und Verzeichnisse auszuschließen, die im Build-Kontext nicht benötigt werden, wodurch Builds schneller und effizienter werden:

nano .dockerignore

Fügen Sie den folgenden Inhalt hinzu:

.git
.gitignore
*.md

Drücken Sie Ctrl+O gefolgt von Enter zum Speichern und dann Ctrl+X zum Beenden von nano.

Überprüfen der Projektstruktur

Überprüfen wir, ob unsere Dateien korrekt erstellt wurden:

ls -la

Sie sollten eine ähnliche Ausgabe sehen:

total 16
drwxrwxr-x 2 labex labex 4096 Jan 1 00:00 .
drwxr-xr-x 3 labex labex 4096 Jan 1 00:00 ..
-rw-rw-r-- 1 labex labex   21 Jan 1 00:00 .dockerignore
-rw-rw-r-- 1 labex labex  159 Jan 1 00:00 Dockerfile

Nachdem wir nun ein einfaches Dockerfile haben, sind wir bereit, Docker Buildx zu testen und den Fehler "requires exactly 1 argument" im nächsten Schritt zu untersuchen.

Verstehen und Beheben des Fehlers "Requires Exactly 1 Argument"

In diesem Schritt werden wir absichtlich den Fehler "requires exactly 1 argument" (benötigt genau 1 Argument) auslösen, um seine Ursachen zu verstehen, und dann lernen, wie man ihn behebt.

Auslösen des Fehlers

Navigieren wir zunächst zu unserem Projektverzeichnis, falls wir uns nicht bereits dort befinden:

cd ~/project/buildx-test

Versuchen wir nun, ein Image mit Docker Buildx zu erstellen, ohne den Build-Kontext anzugeben:

docker buildx build

Sie sollten eine Fehlermeldung ähnlich der folgenden sehen:

"docker buildx build" requires exactly 1 argument.
See 'docker buildx build --help'.

Usage:  docker buildx build [OPTIONS] PATH | URL | -

Dieser Fehler tritt auf, weil der Befehl docker buildx build einen Build-Kontext (das Verzeichnis, das das Dockerfile enthält) als Argument benötigt.

Verstehen des Fehlers

Der Fehler "requires exactly 1 argument" bedeutet, dass Docker Buildx wissen muss, wo es die Dateien finden kann, die zum Erstellen des Images benötigt werden. Dieses Argument ist typischerweise ein Pfad zu dem Verzeichnis, das Ihr Dockerfile enthält (der Build-Kontext).

Häufige Szenarien, die diesen Fehler auslösen, sind:

1. Vergessen, den Build-Kontext anzugeben
2. Verwendung einer falschen Befehlssyntax
3. Platzieren von Optionen in der falschen Reihenfolge

Korrigieren des Fehlers

Korrigieren wir den Fehler, indem wir den Build-Kontext hinzufügen. Der einfachste Weg ist die Verwendung von . zur Angabe des aktuellen Verzeichnisses:

docker buildx build .

Dieses Mal startet Docker den Build-Prozess, aber wir werden feststellen, dass das Image nicht getaggt wird, was die spätere Referenzierung erschwert.

Lassen Sie uns den Build mit Ctrl+C stoppen, falls er noch läuft, und es erneut mit einem korrekten Tag versuchen:

docker buildx build -t nginx-test:latest .

Sie sollten eine Ausgabe sehen, die den Build-Fortschritt anzeigt:

[+] Building 12.8s (7/7) FINISHED
 => [internal] load build definition from Dockerfile                          0.0s
 => => transferring dockerfile: 203B                                          0.0s
 => [internal] load .dockerignore                                             0.0s
 => => transferring context: 34B                                              0.0s
 => [internal] load metadata for docker.io/library/ubuntu:22.04               0.5s
 => [1/3] FROM docker.io/library/ubuntu:22.04@sha256:...                      0.0s
 => CACHED [2/3] RUN apt-get update && apt-get install -y     curl     nginx  0.0s
 => CACHED [3/3] EXPOSE 80                                                    0.0s
 => exporting to image                                                        0.0s
 => => exporting layers                                                       0.0s
 => => writing image sha256:...                                               0.0s
 => => naming to docker.io/library/nginx-test:latest                          0.0s

Verwenden verschiedener Buildx-Optionen

Lassen Sie uns einige zusätzliche Optionen mit Docker Buildx erkunden:

1. Erstellen und Laden des Images in den lokalen Image-Store von Docker:

docker buildx build --load -t nginx-test:local .

2. Erstellen ohne Verwendung des Build-Cache (Erzwingen eines neuen Builds):

docker buildx build --no-cache -t nginx-test:nocache .

3. Erstellen und Ausgeben nur der finalen Image-ID:

docker buildx build -q -t nginx-test:quiet .

Überprüfen der erstellten Images

Überprüfen wir die Images, die wir erstellt haben:

docker images | grep nginx-test

Sie sollten eine ähnliche Ausgabe sehen:

nginx-test     quiet      abcdef123456   5 minutes ago   123MB
nginx-test     nocache    fedcba654321   5 minutes ago   123MB
nginx-test     local      123456abcdef   5 minutes ago   123MB
nginx-test     latest     abcdef123456   5 minutes ago   123MB

Jetzt verstehen Sie den häufigen Fehler "requires exactly 1 argument" mit Docker Buildx und wissen, wie man Images mit verschiedenen Optionen richtig erstellt.

Erstellen von Multi-Architektur-Images mit Docker Buildx

Eine der leistungsstärksten Funktionen von Docker Buildx ist die Fähigkeit, Images für mehrere Architekturen gleichzeitig zu erstellen. In diesem Schritt lernen wir, wie man Multi-Architektur-Images erstellt.

Multi-Architektur-Images verstehen

Multi-Architektur-Images ermöglichen es, dass derselbe Imagename auf verschiedenen Plattformen (wie AMD64, ARM64 usw.) funktioniert. Docker wählt automatisch die passende Version für die Host-Architektur aus, wenn das Image abgerufen wird.

Dies ist besonders nützlich für:

• Unterstützung von x86- und ARM-basierten Geräten
• Sicherstellen, dass Ihre Anwendungen auf verschiedenen Cloud-Anbietern ausgeführt werden
• Erstellen für IoT-Geräte mit unterschiedlichen Architekturen

Einrichten für Multi-Architektur-Builds

Docker Buildx muss für Multi-Architektur-Builds konfiguriert werden. Stellen wir zunächst sicher, dass unser Builder diese Funktion unterstützt:

docker buildx inspect --bootstrap mybuilder

Wenn Sie eine Fehlermeldung sehen, dass der Builder nicht verfügbar ist, erstellen wir ihn mit der richtigen Konfiguration neu:

docker buildx rm mybuilder
docker buildx create --name mybuilder --driver docker-container --bootstrap --use

Erstellen eines Multi-Architektur-Images

Erstellen wir nun unser Nginx-Image für mehrere Architekturen:

docker buildx build --platform linux/amd64,linux/arm64 -t nginx-test:multi .

Möglicherweise sehen Sie eine Fehlermeldung ähnlich der folgenden:

error: multiple platforms feature is currently not supported for docker driver. Please switch to a different driver (eg. "docker buildx create --use")

Dies geschieht, weil der Standard-Docker-Treiber keine Multi-Architektur-Builds unterstützt. Ändern wir unseren Ansatz.

Zu Demonstrationszwecken erstellen wir separat für bestimmte Plattformen:

docker buildx build --platform linux/amd64 -t nginx-test:amd64 --load .

Dies erstellt das Image speziell für die AMD64-Architektur und lädt es in den lokalen Image-Store von Docker.

Verwenden von Build-Argumenten

Docker Buildx ermöglicht es uns, Build-Argumente zu verwenden, um unsere Builds anzupassen. Ändern wir unser Dockerfile, um ein Build-Argument zu verwenden:

nano Dockerfile

Aktualisieren Sie den Dockerfile-Inhalt auf:

FROM ubuntu:22.04

ARG PACKAGE=nginx
RUN apt-get update && apt-get install -y \
  curl \
  ${PACKAGE} \
  && rm -rf /var/lib/apt/lists/*

EXPOSE 80

CMD ["nginx", "-g", "daemon off;"]

Drücken Sie Ctrl+O gefolgt von Enter zum Speichern und dann Ctrl+X zum Beenden von nano.

Jetzt können wir das Image mit einem benutzerdefinierten Paket erstellen:

docker buildx build --build-arg PACKAGE=nginx-extras -t nginx-extras:latest .

Pushen in eine Registry (Optional)

Um Multi-Architektur-Images vollständig zu nutzen, würden Sie diese typischerweise in eine Registry pushen. Dies erfordert Docker Hub-Anmeldeinformationen oder eine private Registry. In einem realen Szenario würde der Befehl wie folgt aussehen:

## Beispiel nur - nicht erforderlich für dieses Lab
## docker buildx build --platform linux/amd64,linux/arm64 -t username/nginx-test:multi --push .

Untersuchen von Images

Untersuchen wir die Images, die wir erstellt haben:

docker images | grep nginx

Sie sollten eine ähnliche Ausgabe sehen:

nginx-extras    latest     abcdef123456   1 minute ago    130MB
nginx-test      amd64      123456abcdef   2 minutes ago   123MB
nginx-test      latest     fedcba654321   10 minutes ago  123MB

Testen unseres Images

Lassen Sie uns abschließend einen Container mit unserem Image ausführen, um zu überprüfen, ob es funktioniert:

docker run -d --name test-nginx -p 8080:80 nginx-test:latest

Überprüfen Sie, ob der Container läuft:

docker ps

Sie sollten eine Ausgabe sehen, die anzeigt, dass Ihr Container läuft:

CONTAINER ID   IMAGE              COMMAND                  CREATED          STATUS          PORTS                  NAMES
abcdef123456   nginx-test:latest  "nginx -g 'daemon of…"   10 seconds ago   Up 10 seconds   0.0.0.0:8080->80/tcp   test-nginx

Lassen Sie uns den Nginx-Server mit curl aufrufen, um sicherzustellen, dass er antwortet:

curl http://localhost:8080

Sie sollten die HTML-Willkommensseite von Nginx sehen.

Wenn Sie fertig sind, bereinigen Sie den Container:

docker stop test-nginx
docker rm test-nginx

Herzlichen Glückwunsch! Sie haben erfolgreich mit Docker Buildx gearbeitet, den Fehler "requires exactly 1 argument" verstanden und behoben und gelernt, wie man spezielle Builds für verschiedene Architekturen erstellt.

Zusammenfassung

In diesem Lab haben Sie praktische Erfahrungen mit Docker Buildx gesammelt und gelernt, wie man den häufigen Fehler "requires exactly 1 argument" (benötigt genau 1 Argument) behebt. Folgendes haben Sie erreicht:

1. Einrichten von Docker Buildx und Erstellen einer Builder-Instanz
2. Erstellen eines einfachen Dockerfiles zum Testen
3. Auftreten, Verstehen und Beheben des Fehlers "requires exactly 1 argument"
4. Erstellen von Docker-Images mit verschiedenen Optionen und Konfigurationen
5. Erlernen der Grundlagen des Multi-Architektur-Image-Builds

Diese Fähigkeiten bieten eine solide Grundlage für die Arbeit mit Docker in modernen Entwicklungsumgebungen, in denen Anwendungen oft auf verschiedenen Hardwareplattformen ausgeführt werden müssen. Sie können jetzt Docker Buildx sicher verwenden, um effiziente, plattformspezifische Container-Images zu erstellen und gleichzeitig häufige Fehler zu vermeiden.

Wenn Sie Ihre Docker-Reise fortsetzen, sollten Sie in Erwägung ziehen, erweiterte Buildx-Funktionen zu erkunden, es in CI/CD-Pipelines zu integrieren und es zu verwenden, um wirklich portable Anwendungen zu erstellen, die überall ausgeführt werden können.