Ошибка docker build requires exactly 1 argument

From the command run:

sudo docker build -t myrepo/redis

there are no «arguments» passed to the docker build command, only a single flag -t and a value for that flag. After docker parses all of the flags for the command, there should be one argument left when you’re running a build.

That argument is the build context. The standard command includes a trailing dot for the context:

sudo docker build -t myrepo/redis .

What’s the build context?

Every docker build sends a directory to the build server. Docker is a client/server application, and the build runs on the server which isn’t necessarily where the docker command is run. Docker uses the build context as the source for files used in COPY and ADD steps. When you are in the current directory to run the build, you would pass a . for the context, aka the current directory. You could pass a completely different directory, even a git repo, and docker will perform the build using that as the context, e.g.:

docker build -t sudobmitch/base:alpine --target alpine-base 
  'https://github.com/sudo-bmitch/docker-base.git#main'

For more details on these options to the build command, see the docker build documentation.

What if you included an argument?

If you are including the value for the build context (typically the .) and still see this error message, you have likely passed more than one argument. Typically this is from failing to parse a flag, or passing a string with spaces without quotes. Possible causes for docker to see more than one argument include:

• Missing quotes around a path or argument with spaces (take note using variables that may have spaces in them)

• Incorrect dashes in the command: make sure to type these manually rather than copy and pasting

• Incorrect quotes: smart quotes don’t work on the command line, type them manually rather than copy and pasting.

• Whitespace that isn’t white space, or that doesn’t appear to be a space.

Most all of these come from either a typo or copy and pasting from a source that modified the text to look pretty, breaking it for using as a command.

How do you figure out where the CLI error is?

The easiest way I have to debug this, run the command without any other flags:

docker build .

Once that works, add flags back in until you get the error, and then you’ll know what flag is broken and needs the quotes to be fixed/added or dashes corrected, etc.

I’ve been working on migrating my the remote jobs platform I built in the past months from weremote.ro to weremote.eu.

The platform’s backend is a GraphQL API built over Express.js which runs inside a Docker container. I was initially building the image myself, whenever I pushed some changes worth deploying to production, but I very quickly switched to GitHub Actions once I learned about this feature.

With this migration to .eu, I also added some features and most importantly, I moved a lot of config into env vars. So before I could actually deploy, I had to update main.workflow which is used by GitHub Actions to define the steps of the build process.

I went on and added the env vars, the secrets, and everything looked right. Except for the fact that I was getting this error when the build was running:

# [...] docker pull logs over here
"docker build" requires exactly 1 argument.
See 'docker build --help'.

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

Build an image from a Dockerfile

### FAILED Build Docker image 13:23:26Z (41.66s)

I thought it was because I had a lot of build args that I was passing at build time.

Basically this:

args = "build --build-arg db_host=${DATABASE_HOST} --build-arg db_user=${DATABASE_USER} --build-arg db_pass=${DATABASE_PASSWORD} --build-arg db_name=${DATABASE_NAME} --build-arg database_authentication_source=${DATABASE_AUTHENTICATION_SOURCE} --build-arg cookie_signing_secret=${COOKIE_SIGNING_SECRET} --build-arg jwt_sign_key=${JWT_SIGN_KEY} --build-arg netlify_build_hook_url=${NETLIFY_BUILD_HOOK_URL} --build-arg mailgun_api_key=${MAILGUN_API_KEY} --build-arg bt_environment=${BT_ENVIRONMENT} --build-arg bt_merchant_id=${BT_MERCHANT_ID} --build-arg bt_public_key=${BT_PUBLIC_KEY} --build-arg bt_private_key=${BT_PRIVATE_KEY} --build-arg bt_merchant_account_id=${BT_MERCHANT_ACCOUNT_ID} -t ${IMAGE_NAME} ."

But as it turns out, my brain works better at 12:30 AM than it works at 2:00 PM.

While I was looking at the values of my env vars, I realised that two variables were storing strings with spaces — bad move.

So here’s an example

$ SOME_ENV_VAR="This is a nice sentence!"
$ docker build --build-arg some_arg=${SOME_ENV_VAR} .

If this happens (and this is what happens when GitHub Actions set your env vars and secrets, you’ll get this error:

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

That’s because when interpreted the result is your sentence, but without the quotes:

echo $SOME_ENV_VAR
This is a nice sentence!

So when you run your docker build command, and pass the variable as a build argument, it looks like this:

docker build --build-arg some_arg=This is a nice sentence! .

That’s a lot of arguments for docker build which it cannot identify.

And that, folks, is why you get weird errors when running docker build in GitHub Actions.

The solution

1. You don’t use phrases in your environment variables
2. You add quotes around those variables
   • docker build --build-arg some_arg='${SOME_ENV_VAR}' .
   • Use single quotes because the whole “build” command is wrapped around with double quotes

Out!

Introduction

Docker build is a container image builder command. The command helps you to create your container image with some extra tweakable functionalities. While building the image using the “docker build” command beginners face
a very common and simple problem of arguments. In this article, we have discussed various ways of encountering that error and how to resolve the error. Different ways of executing the build are also mentioned in the
article.

Creation of Dockerfile

First of all, we will create a dockerfile. This dockerfile will help us to create a docker container image of the “apache-web-server”. The index page is stored as the default location /usr/local/apache2/htdocs/

Make a directory “TUTORIALSPOINT”.

$mkdir TUTORIALSPOINT

Get inside the “TUTORIALSPOINT” directory, create a file named “Dockerfile”, and open the file with any of the code editors. Here, we used Visual Studio code.

$cd TUTORIALSPOINT
$touch Dockerfile
$code .

Paste the below Dockerfile codel.

FROM httpd:latest

WORKDIR /usr/local/apache2/htdocs/

EXPOSE 80

Different Build Errors

Let us see different build errors we might encounter while creating a container image using the docker build command.

Example 1

If the command is executed inside the “TUTORIALSPOINT” directory where Dockerfile is present.

$pwd

Output

/home/hemant/TUTORIALSPOINT

Now see the build error.

$docker build

Output

"docker build" requires exactly 1 argument.
See 'docker build --help'.
Usage: docker build [OPTIONS] PATH | URL | -
Build an image from a Dockerfile




  


                       
  

Example 2

If the command is executed outside the “TUTORIALSPOINT” directory where no Dockerfile is present.

$pwd

Output

/home/hemant

Now see the error.

$docker build

Output

"docker build" requires exactly 1 argument.
See 'docker build --help'.
Usage: docker build [OPTIONS] PATH | URL | -
Build an image from a Dockerfile

Example 3

If the command is executed outside the “TUTORIALSPOINT” directory where no Dockerfile is present.

$pwd

Output

/home/hemant

Now see the error.

$docker build .

Output

unable to prepare context:
unable to evaluate symlinks in Dockerfile path: lstat
/home/hemant/Dockerfile: no such file or directory

Example 4

If the command is executed inside the “TUTORIALSPOINT” directory but the “Dockerfile” is renamed as any other file like “Dockerfile_2”.

$pwd

Output

/home/hemant/TUTORIALSPOINT

Now see the error.

$docker build .

Output

unable to prepare context:
unable to evaluate symlinks in Dockerfile path: lstat
/home/hemant/Dockerfile: no such file or directory

Understand the Build Command

Till now, different build errors are seen. Now understanding the “docker build” command will be best. Below we have a breakdown of all the parts of the command.

The general syntax of the command is −

$docker build [options] [local path or url]

Important options are listed below

File

The default filename of the dockerfile is “Dockerfile” but to change it you can use the “-f” flag. This flag requires the relative path of the dockerfile with the name you have saved it.

Tag

The “-t” flag is used when we want to rename the image that is going to be created using the docker build. This can also be written as “—tag”.

The general syntax to assign tag − name − version If you don’t define the version of the image then docker itself provides a “latest” version.

PATH or Context Directory

This path is a local relative path, it is going to be used by the dockerfile as a reference when executing the commands like COPY and ADD. This path is also known as the “context directory”. Docker daemon first gets the context directory and then finds the files that are required to be copied in the image while building.

URL

If the files that you want to copy are not present on your local system, Instead of the local path just mention the “URL” to the remote directory. For example, you can use a GitHub repository URL.

Implementation Cases

There are various circumstances when building a docker image. Some of the circumstances are mentioned below.

Case 1: Simplest implementation of the “docker build”

Step 1 − Create a directory “TUTORIALSPOINT”

$mkdir TUTORIALSPOINT

Step 2 − Create a dockerfile named “Dockerfile”

$cd TUTORIALSPOINT
$touch Dockerfile

Save the below code in it.

FROM httpd:latest

WORKDIR /usr/local/apache2/htdocs/

EXPOSE 80

Open this file and save the below code in it.

Step 3 − Build the docker image

Simplest implementation

$docker build .

Output

Sending build context to Docker daemon 3.072kB
Step 1/3 : FROM httpd:latest
---> fe8735c23ec5
Step 2/3 : WORKDIR /usr/local/apache2/htdocs/
---> Using cache
---> 933e884d81bc
Step 3/3 : EXPOSE 80
---> Using cache
---> a127ab71efab
Successfully built a127ab71efab

The image name will be none and it will get an ID. To name the image, use the below command.

$docker build –t image1:version1 .

Output

Sending build context to Docker daemon 3.072kB
Step 1/3 : FROM httpd:latest
---> fe8735c23ec5
Step 2/3 : WORKDIR /usr/local/apache2/htdocs/
---> Using cache
---> 933e884d81bc
Step 3/3 : EXPOSE 80
---> Using cache
---> a127ab71efab
Successfully built a127ab71efab
Successfully tagged image1:version1

To check the created image.

$docker images

Output

REPOSITORY        TAG         IMAGE ID           CREATED
SIZE
image1         version1      a127ab71efab       2 days ago
145MB




  


                       
  

Case 2: Change the name of the Dockerfile

Follow the below steps for using dockerfile instead of “Dockerfile”.

Step 1: Create a file name as “tutorialfile” with the same dockerfile code as above.

$touch tutorialfile

Step 2: Now build the image using this dockerfile

General syntax: docker build –f complete_path_of_dockerfile –t name:version .

$docker build -f /home/hemant/TUTORIALSPOINT/tutorialfile -t test2:v1 .

Output

Sending build context to Docker daemon 3.584kB
Step 1/3 : FROM httpd:latest
---> fe8735c23ec5
Step 2/3 : WORKDIR /usr/local/apache2/htdocs/
---> Using cache
---> 933e884d81bc
Step 3/3 : EXPOSE 80
---> Using cache
---> a127ab71efab
Successfully built a127ab71efab
Successfully tagged test2:v1

This will create a docker image from the “tutorialfile”. Check-in created image.

$docker images

Output

REPOSITORY        TAG         IMAGE ID          CREATED
SIZE
test2             v1          a127ab71efab         2 days ago
145MB

Case 3: Change the Context Directory

In the above examples, we have used the context directory as the “current working directory” by using “dot”.

Step 1: Create a new dockerfile named “newdockerfile”

$touch newdockerfile

Add the below code to the dockerfile.

FROM httpd:latest

WORKDIR /usr/local/apache2/htdocs/
RUN rm index.html

COPY . .

EXPOSE 80

Step 2: Get out of the TUTORIALSPOINT Directory.

First copy the path of the current working directory.

$pwd

Get out of the directory.

$cd ..

Step 3: Now execute the docker build command.

$docker build 
   -f /home/hemant/TUTORIALSPOINT/tutorialfile 
   -t test3:v1 
/home/hemant/TUTORIALSPOINT

Output

Sending build context to Docker daemon 2.56kB
Step 1/5 : FROM httpd:latest
   ---> fe8735c23ec5
Step 2/5 : WORKDIR /usr/local/apache2/htdocs/
   ---> Using cache
   ---> 933e884d81bc
Step 3/5 : RUN rm index.html
   ---> Using cache
   ---> 0775ee5efabc
Step 4/5 : COPY . .
   ---> ae8dd9f280da
Step 5/5 : EXPOSE 80
   ---> Running in bccffebf7db2
Removing intermediate container bccffebf7db2
   ---> 6261cc2ca031
Successfully built 6261cc2ca031
Successfully tagged test3:v1

Step 4: Now run the container and check if the context directory is set to “home/hemant/TUTORIALSPOINT”

$docker run -itd --name cont -p 8080:80 test3:v1

Step 5: Check if the Context directory is copied on the apache server. Visit the http://localhost:8080/

Hence, the context directory was copied and set well.

Conclusion

Here in this article, we learned the use of the “docker build” command. All the key features of implementing the command in various circumstances were covered. Most importantly, the “context” setting is a well-known doubt in the beginner community.

Background

Recently, we need to use dockerfile to build the image. The documents we found are as follows

https://yeasy.gitbooks.io/docker_ practice/content/image/build.html

$ docker build -t nginx:v3 .
Sending build context to Docker daemon 2.048 kB
Step 1 : FROM nginx
 ---> e43d811ce2f4
Step 2 : RUN echo '<h1>Hello, Docker!</h1>' > /usr/share/nginx/html/index.html
 ---> Running in 9cdc27646c7b
 ---> 44aa4490ce2c
Removing intermediate container 9cdc27646c7b
Successfully built 44aa4490ce2c

Press the prompt to report an error

$ docker build -t centos_base:v1
"docker build" requires exactly 1 argument.
See 'docker build --help'.

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

Build an image from a Dockerfile

It feels like there’s something fishy going on here~

Resolution

Following the standard process of problem solving  one word at a time, I found a point at the end . 

Followup

I found this description in the official documentation

https://docs.docker.com/engine/reference/commandline/build/ This example specifies that the PATH is ., and so all the files in the local directory get tard and sent to the Docker daemon. The PATH specifies where to find the files for the “context” of the build on the Docker daemon. Remember that the daemon could be running on a remote machine and that no parsing of the Dockerfile happens at the client side (where you’re running docker build). That means that all the files at PATH get sent, not just the ones listed to ADD in the Dockerfile.

# USAGE
docker build [OPTIONS] PATH | URL | -
# e.g.
docker build .

That is to say, in the official document example, Path indicates . , and then many files in the current directory are sent to the docker’s daemons, Path specifies the path to find files in context when building the image. For example, the first parameter of the Add instruction in dockerfile can be found from the context, that is, the file just sent to docker daemon

Similar Posts:

Вопрос:

FROM        ubuntu:14.04
RUN         apt-get update && apt-get install -y redis-server
EXPOSE      6379
ENTRYPOINT  ["/usr/bin/redis-server"]


sudo docker build -t myrepo/redis
docker: "build" requires 1 argument. See 'docker build --help'.

Лучший ответ:

Вам нужно добавить точку, например docker build -t mytag ., это означает, что вы используете файл Docker в локальном каталоге, а если вы используете docker 1.5, вы можете указать файл Docker otherwhere, извлечь из справки docker build -f, --file="" Name of the Dockerfile(Default is 'Dockerfile' at context root)

Ответ №1

Ответ №2

docker build -t mytag .

Ответ №3

Ответ №4

$ docker build -t <your username>/node-web-app .

Ответ №5

Ответ №6

docker build . -t <image_name>:latest

FROM busybox
RUN echo "hello world"

Ответ №7

C:UsersDanieleapp> docker build -t friendlyhello C:UsersDanieleapp

C:UsersDanieleapp> docker build -t friendlyhello:3.0 C:UsersDanieleapp

Ответ №8

chmod +x "Dockerfile"

Ответ №9

--build-arg VARIABLE_NAME=$VARIABLE_NAME

--build-arg VARIABLE_NAME="$VARIABLE_NAME"

Ответ №10

$ docker build -t friendlyhello:latest -f C:\TestDockerApp\Dockerfile.txt

$ docker build -t friendlyhello:latest -f C:\TestDockerApp\Dockerfile.txt .**