Comment Résoudre le Problème "docker buildx build requires exactly 1 argument"

Introduction

Docker Buildx étend la commande standard docker build avec des fonctionnalités améliorées pour la création d'images multi-architectures. Cependant, les utilisateurs rencontrent souvent l'erreur "docker buildx build requires exactly 1 argument" (docker buildx build nécessite exactement 1 argument) lorsqu'ils travaillent avec cet outil. Ce tutoriel complet vous guidera à travers la compréhension de Docker Buildx, le diagnostic de cette erreur courante et la mise en œuvre de solutions efficaces.

À la fin de ce lab, vous aurez une expérience pratique de la configuration de Docker Buildx, de la création d'images Docker, du dépannage de l'erreur "requires exactly 1 argument" et de la construction d'images pour plusieurs architectures. Ces compétences sont essentielles pour le développement et le déploiement modernes d'applications conteneurisées.

Skills Graph

Configuration de Docker Buildx

Docker Buildx est pré-installé avec Docker, mais doit être correctement configuré avant utilisation. Dans cette étape, nous vérifierons que Docker est installé, activerons Docker Buildx et créerons notre première instance de builder.

Vérification de l'installation de Docker

Commençons par confirmer que Docker est installé et en cours d'exécution sur notre système :

docker --version

Vous devriez voir une sortie similaire à :

Docker version 20.10.21, build baeda1f

Cela confirme que Docker est installé et prêt à être utilisé.

Comprendre Docker Buildx

Docker Buildx est un plugin CLI qui étend les fonctionnalités de Docker avec BuildKit. Il permet :

• La construction d'images pour plusieurs plateformes (comme AMD64, ARM64) simultanément
• Une mise en cache des couches plus efficace
• Des performances de construction améliorées
• Des fonctionnalités de construction avancées

Création d'un Docker Buildx Builder

Créons et utilisons un nouveau builder Docker Buildx :

docker buildx create --name mybuilder --use

La sortie devrait ressembler à :

mybuilder

Vérifions maintenant que notre builder a été créé et qu'il est défini comme celui par défaut :

docker buildx ls

Vous devriez voir une sortie similaire à :

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

L'astérisque (*) à côté de mybuilder indique qu'il s'agit du builder actuellement actif.

Inspection du Builder

Examinons les détails de notre builder :

docker buildx inspect mybuilder

Cela vous montrera la configuration du builder, y compris les plateformes prises en charge et son état actuel.

Maintenant que nous avons configuré avec succès Docker Buildx, nous sommes prêts à passer à la création d'un Dockerfile à utiliser avec notre builder.

Création d'un Dockerfile simple pour les tests

Avant d'utiliser Docker Buildx pour construire des images, nous devons créer un Dockerfile simple. Cela servira de cas de test pour comprendre l'erreur "requires exactly 1 argument" (nécessite exactement 1 argument).

Comprendre les Dockerfiles

Un Dockerfile est un document texte contenant des instructions pour construire une image Docker. Il automatise le processus de création de conteneurs avec des configurations spécifiques.

Créons un répertoire pour notre projet :

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

Création d'un Dockerfile de base

Maintenant, créons un Dockerfile simple en utilisant l'éditeur de texte nano :

nano Dockerfile

Copiez et collez le contenu suivant dans le Dockerfile :

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;"]

Appuyez sur Ctrl+O suivi de Entrée pour enregistrer, puis Ctrl+X pour quitter nano.

Décomposons ce Dockerfile :

• FROM ubuntu:22.04 - Utilise Ubuntu 22.04 comme image de base
• RUN apt-get update... - Met à jour les listes de paquets et installe curl et nginx
• EXPOSE 80 - Indique que le conteneur écoutera sur le port 80
• CMD ["nginx", "-g", "daemon off;"] - Exécute nginx au premier plan lorsque le conteneur démarre

Création d'un fichier .dockerignore

Un fichier .dockerignore permet d'exclure les fichiers et répertoires qui ne sont pas nécessaires dans le contexte de construction, ce qui rend les constructions plus rapides et plus efficaces :

nano .dockerignore

Ajoutez le contenu suivant :

.git
.gitignore
*.md

Appuyez sur Ctrl+O suivi de Entrée pour enregistrer, puis Ctrl+X pour quitter nano.

Vérification de la structure du projet

Vérifions que nos fichiers sont créés correctement :

ls -la

Vous devriez voir une sortie similaire à :

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

Maintenant que nous avons un Dockerfile de base, nous sommes prêts à tester Docker Buildx et à explorer l'erreur "requires exactly 1 argument" à l'étape suivante.

Comprendre et résoudre l'erreur "Requires Exactly 1 Argument"

Dans cette étape, nous allons délibérément déclencher l'erreur "requires exactly 1 argument" (nécessite exactement 1 argument) pour comprendre ses causes, puis apprendre à la résoudre.

Déclenchement de l'erreur

Tout d'abord, accédons à notre répertoire de projet si nous ne sommes pas déjà dedans :

cd ~/project/buildx-test

Maintenant, essayons de construire une image en utilisant Docker Buildx sans spécifier le contexte de construction :

docker buildx build

Vous devriez voir un message d'erreur similaire à :

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

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

Cette erreur se produit car la commande docker buildx build nécessite un contexte de construction (le répertoire contenant le Dockerfile) comme argument.

Comprendre l'erreur

L'erreur "requires exactly 1 argument" signifie que Docker Buildx doit savoir où trouver les fichiers nécessaires à la construction de l'image. Cet argument est généralement un chemin d'accès au répertoire contenant votre Dockerfile (le contexte de construction).

Les scénarios courants qui déclenchent cette erreur incluent :

1. Oublier de spécifier le contexte de construction
2. Utiliser une syntaxe de commande incorrecte
3. Placer les options dans le mauvais ordre

Correction de l'erreur

Corrigeons l'erreur en ajoutant le contexte de construction. La méthode la plus simple consiste à utiliser . pour indiquer le répertoire courant :

docker buildx build .

Cette fois, Docker démarrera le processus de construction, mais nous remarquerons qu'il ne taggue pas l'image, ce qui rend difficile de s'y référer plus tard.

Arrêtons la construction avec Ctrl+C si elle est toujours en cours, et réessayons avec un tag approprié :

docker buildx build -t nginx-test:latest .

Vous devriez voir une sortie montrant la progression de la construction :

[+] 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

Utilisation de différentes options Buildx

Explorons quelques options supplémentaires avec Docker Buildx :

1. Construire et charger l'image dans le magasin d'images local de Docker :

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

2. Construire sans utiliser le cache de construction (forçant une nouvelle construction) :

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

3. Construire et afficher uniquement l'ID de l'image finale :

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

Vérification des images construites

Vérifions les images que nous avons construites :

docker images | grep nginx-test

Vous devriez voir une sortie similaire à :

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

Vous comprenez maintenant l'erreur courante "requires exactly 1 argument" avec Docker Buildx et savez comment construire correctement des images avec diverses options.

Construction d'images multi-architectures avec Docker Buildx

L'une des fonctionnalités les plus puissantes de Docker Buildx est sa capacité à construire des images pour plusieurs architectures simultanément. Dans cette étape, nous allons apprendre à créer des images multi-architectures.

Comprendre les images multi-architectures

Les images multi-architectures permettent au même nom d'image de fonctionner sur différentes plateformes (comme AMD64, ARM64, etc.). Docker sélectionne automatiquement la version appropriée pour l'architecture de l'hôte lorsque l'image est extraite.

Ceci est particulièrement utile pour :

• Prendre en charge les appareils x86 et ARM
• S'assurer que vos applications s'exécutent sur divers fournisseurs de cloud
• Construire pour les appareils IoT avec différentes architectures

Configuration pour les constructions multi-architectures

Docker Buildx doit être configuré pour les constructions multi-architectures. Tout d'abord, assurons-nous que notre builder prend en charge cette fonctionnalité :

docker buildx inspect --bootstrap mybuilder

Si vous voyez une erreur concernant l'indisponibilité du builder, recréons-le avec la bonne configuration :

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

Création d'une image multi-architecture

Construisons maintenant notre image Nginx pour plusieurs architectures :

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

Vous pourriez voir un message d'erreur similaire à :

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

Cela se produit car le pilote Docker par défaut ne prend pas en charge les constructions multi-architectures. Modifions notre approche.

À des fins de démonstration, nous allons construire pour des plateformes spécifiques séparément :

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

Cela construit l'image spécifiquement pour l'architecture AMD64 et la charge dans le magasin d'images local de Docker.

Utilisation des arguments de construction

Docker Buildx nous permet d'utiliser des arguments de construction pour personnaliser nos constructions. Modifions notre Dockerfile pour utiliser un argument de construction :

nano Dockerfile

Mettez à jour le contenu du Dockerfile avec :

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;"]

Appuyez sur Ctrl+O suivi de Entrée pour enregistrer, puis Ctrl+X pour quitter nano.

Maintenant, nous pouvons construire l'image avec un paquet personnalisé :

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

Pousser vers un registre (facultatif)

Pour utiliser pleinement les images multi-architectures, vous les pousseriez généralement vers un registre. Cela nécessite des identifiants Docker Hub ou un registre privé. Dans un scénario réel, la commande ressemblerait à :

## Exemple uniquement - non requis pour ce lab
## docker buildx build --platform linux/amd64,linux/arm64 -t username/nginx-test:multi --push .

Inspection des images

Examinons les images que nous avons créées :

docker images | grep nginx

Vous devriez voir une sortie similaire à :

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

Test de notre image

Enfin, exécutons un conteneur en utilisant notre image pour vérifier qu'elle fonctionne :

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

Vérifiez si le conteneur est en cours d'exécution :

docker ps

Vous devriez voir une sortie indiquant que votre conteneur est en cours d'exécution :

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

Faisons un curl sur le serveur nginx pour nous assurer qu'il répond :

curl http://localhost:8080

Vous devriez voir la page d'accueil HTML par défaut de Nginx.

Lorsque vous avez terminé, nettoyez le conteneur :

docker stop test-nginx
docker rm test-nginx

Félicitations ! Vous avez réussi à travailler avec Docker Buildx, à comprendre et à résoudre l'erreur "requires exactly 1 argument", et à apprendre à créer des constructions spécialisées pour différentes architectures.

Résumé

Dans ce lab, vous avez acquis une expérience pratique avec Docker Buildx et appris à dépanner l'erreur courante "requires exactly 1 argument" (nécessite exactement 1 argument). Voici ce que vous avez accompli :

1. Configuration de Docker Buildx et création d'une instance de builder
2. Création d'un Dockerfile de base pour les tests
3. Rencontre, compréhension et résolution de l'erreur "requires exactly 1 argument"
4. Construction d'images Docker avec diverses options et configurations
5. Apprentissage des bases de la construction d'images multi-architectures

Ces compétences fournissent une base solide pour travailler avec Docker dans les environnements de développement modernes, où les applications doivent souvent s'exécuter sur diverses plateformes matérielles. Vous pouvez désormais utiliser Docker Buildx en toute confiance pour créer des images de conteneurs efficaces et spécifiques à la plateforme, tout en évitant les erreurs courantes.

Au fur et à mesure que vous poursuivez votre parcours Docker, envisagez d'explorer des fonctionnalités Buildx plus avancées, de l'intégrer dans les pipelines CI/CD et de l'utiliser pour construire des applications véritablement portables qui peuvent s'exécuter n'importe où.