54

I am having trouble creating and using variables in a Dockerfile - I build a Docker image via a Dockerfile with this command:

$ docker build --build-arg s=scripts/a.sh -t a .

(So because I use --build-arg, $s will be an available argument in the Dockerfile, and this part works)

The Dockerfile is like so:

ARG s

RUN echo $s 

RUN useradd -ms /bin/bash newuser

USER newuser
WORKDIR /home/newuser

ENV fn=$(filename $s)  # fails on this line

COPY $s .

ENTRYPOINT ["/bin/bash", "/home/newuser/$fn"]

The problem I have is that the Docker build is failing on the line indicated above.

Error response from daemon: Syntax error - can't find = in "$s)". Must be of the form: name=value

If I change that line to this:

RUN fn=$(filename $s)

I get this error:

Error: Command failed: docker build --build-arg s=scripts/a.sh -t a .
The command '/bin/sh -c fn=$(filename $s)' returned a non-zero code: 127

Anyone know the correct way to

  1. Create a variable inside the docker file

  2. Use string interpolation with that variable so that I can reference the variable in the ENTRYPOINT arguments like so:

    ENTRYPOINT ["/bin/bash", "/home/newuser/$var"]

Even if I do this:

ARG s

ARG sname

RUN echo $s          # works as expected
RUN echo $sname      # works as expected

RUN useradd -ms /bin/bash newuser

USER newuser
WORKDIR /home/newuser


COPY $s .  # works as expected (I believe)

ENTRYPOINT /bin/bash /home/newuser/$sname  # does not work as expected

even though I am using the "non-JSON" version of ENTRYPOINT, it still doesn't seem to pick up the value for the $sname variable.

Improve this question

4 Answers 4

Reset to default
55

I would avoid using variable in ENTRYPOINT at all. It's tricky and requires a deep understanding of what is going on. And is easy to break it by accident. Just consider one of the following.

Create link with the known name to your start script.

RUN ln -s /home/newuser/$sname /home/newuser/docker_entrypoint.sh
ENTRYPOINT ["/home/newuser/docker_entrypoint.sh"]

or write standalone entrypoint script that runs what you need.

But if you want to know how and why solutions in your questions work just keep reading.

First some definitions.

  • ENV - is environment variable available during buildtime (docker build) and runtime (docker run)
  • ARG - is environment variable available only during buildtime

If you look at https://docs.docker.com/engine/reference/builder/#environment-replacement you see the list of dockerfile instructions that support those environment variables directly. This is why COPY "picks up the variable" as you said.

Please note that there is no RUN nor ENTRYPOINT. How does it work?

You need to dig into the documentation. First RUN (https://docs.docker.com/engine/reference/builder/#run). There are 2 forms. The first one executes command through the shell and this shell has access to buildtime environment variables.

# this works because it is called as /bin/sh -c 'echo $sname'
# the /bin/sh replace $sname for you      
RUN echo $sname 

# this does NOT work. There is no shell process to do $sname replacement 
# for you
RUN ["echo", "$sname"]

Same thing applies to the ENTRYPOINT and CMD except only runtime variables are available during container start.

# first you need to make some runtime variable from builtime one
ENV sname $sname

# Then you can use it during container runtime
# docker runs `/bin/sh -c '/bin/bash /home/newuser/$sname'` for you
# and this `/bin/sh` proces interprets `$sname`
ENTRYPOINT /bin/bash /home/newuser/$sname

# but this does NOT work. There is no process to interpolate `$sname`
# docker runs what you describe.
ENTRYPOINT ["/bin/bash", "/home/newuser/$sname"]

edit 2017-04-03: updated links to the docker documentations and slight rewording to avoid confusion that I sense from other answers and comments.

Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

So why isn't ARG, a build-time argument, available for interpolation into an ENTRYPOINT argument, also at build-time? I was just looking for some kind of variable for use in a Dockerfile, so I don't have to keep copying and pasting the same string all over the place, without resorting to some external templating tool. I'm wondering why this feature was added if it's inconsistently available.
This question should be pointed to the docker team. I have to look at the PR that added ARG again but if my memory is correct this possibility was not even discussed. Docker developers are very active on GitHub so ask there.
in <docs.docker.com/engine/reference/builder/#run> there is this bit: "Unlike the shell form, the exec form does not invoke a command shell. This means that normal shell processing does not happen. For example, RUN [ "echo", "$HOME" ] will not do variable substitution on $HOME. If you want shell processing then either use the shell form or execute a shell directly, for example: RUN [ "sh", "-c", "echo $HOME" ]. When using the exec form and executing a shell directly, as in the case for the shell form, it is the shell that is doing the environment variable expansion, not docker."
10

I spent a lot of time to find out that.

Don't works !

ARG install="bundle install --jobs=4"
FROM ruby:2.6.3-alpine

RUN eval $install

But this works...

FROM ruby:2.6.3-alpine

ARG install="bundle install --jobs=4"
RUN eval $install

Then to build the docker image:

docker build -t server --no-cache --build-arg install="bundle install --without development test" .`
Improve this answer

2 Comments

docs.docker.com/engine/reference/builder/…
Yes the second one works because ARG is in the same scope where you consume it. Please take look at this documentation: docs.docker.com/engine/reference/builder/#scope
9

I requested @Villem to answer, and his answer is much more definitive, but the following will work (just is not a stable solution). His answer is basically saying that this answer is not a good way to do it:

ARG s           # passed in via --build-arg s=foo
ARG sname       # passed in via --build-arg sname=bar

RUN echo $s       
RUN echo $sname  

ENV sname $sname   # this is the key part

RUN useradd -ms /bin/bash newuser

USER newuser
WORKDIR /home/newuser

COPY $s .

ENTRYPOINT /bin/bash /home/newuser/$sname   # works, but is not stable!

don't ask me why the COPY command picks up the variable that was declared via ARG, but that the ENTRYPOINT command does not seem to pick up the variable declared via ARG, but only picks up the variable declared via ENV. At least, this appears to be the case.

Improve this answer

3 Comments

Perhaps COPY (and ADD?) are shelling out to run the cp command, behind the scenes, and leaving the arguments to cp unescaped so they can expand bash variables?
I think your issue is related to github.com/moby/moby/issues/18492
Because ENTRYPOINT command is executed at runtime, when ARG does not exist, but ENV does
2

I wanted both variable substitution and arguments passing.

Let's say our Dockerfile has:

ENV VARIABLE=replaced

And we want to run this:

docker run <image> arg1 arg2

I obviously wanted this output:

replaced arg1 arg2

I eventually found this one:

ENTRYPOINT [ "sh", "-c", "echo $VARIABLE $0 $@" ]

It works!!! But I feel SOOOO dirty!

Obviously, in real life, I wanted to do something more useful:

docker run <image> --app.options.additional.second=true --app.options.additional.third=false

ENTRYPOINT [ "sh", "-c", "java -Xmx$XMX $0 $@", \
             "-jar", \
             "/my.jar", \
             "--app.options.first=true" ]

Why a so complicated answer?

  • "ENTRYPOINT java..." would not pass docker arguments to the entrypoint => "ENTRYPOINT [..." is mandatory for that
  • "ENTRYPOINT [..." will NOT call the shell, so no variable substitution is done at all => "sh -c" is mandatory for that
  • "sh -c" only take the FIRST argument passed to it and split it in command+arguments => so everything must be in the first argument of "sh -c" for variables to be visible by the command
  • Docker arguments are passed as extra array entries of "ENTRYPOINT [..." => so the "$@" is necessary to "copy" the remainings arguments of the "sh -c" into the "echo ..." command to be executed (and as a bonus, we can reuse the additional array entries of ENTRYPOINT[] to place forced arguments in a readable way in the Dockerfile)
  • "$@" removes the first argument => so explicit "$0" must be used before "$@"

Fiou...

I added a comment to this issue, for Docker developers to see what we are forced to do and perhaps change their mind to make ENTRYPOINT[] replace environment variables: https://github.com/moby/moby/issues/4783#issuecomment-442466609

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.