I have dockerfile
FROM centos:7 ENV foo=42 then I build it
docker build -t my_docker . and run it.
docker run -it -d my_docker Is it possible to pass arguments from command line and use it with if else in Dockerfile? I mean something like
FROM centos:7 if (my_arg==42) {ENV=TRUE} else: {ENV=FALSE} and build with this argument.
docker build -t my_docker . --my_arg=42 11 Answers
It might not look that clean but you can have your Dockerfile (conditional) as follow:
FROM centos:7 ARG arg RUN if [[ -z "$arg" ]] ; then echo Argument not provided ; else echo Argument is $arg ; fi and then build the image as:
docker build -t my_docker . --build-arg arg=45
or
docker build -t my_docker .
There is an interesting alternative to the proposed solutions, that works with a single Dockerfile, require only a single call to docker build per conditional build and avoids bash.
Solution:
The following Dockerfile solves that problem. Copy-paste it and try it yourself.
ARG my_arg FROM centos:7 AS base RUN echo "do stuff with the centos image" FROM base AS branch-version-1 RUN echo "this is the stage that sets VAR=TRUE" ENV VAR=TRUE FROM base AS branch-version-2 RUN echo "this is the stage that sets VAR=FALSE" ENV VAR=FALSE FROM branch-version-${my_arg} AS final RUN echo "VAR is equal to ${VAR}" Explanation of Dockerfile:
We first get a base image (centos:7 in your case) and put it into its own stage. The base stage should contain things that you want to do before the condition. After that, we have two more stages, representing the branches of our condition: branch-version-1 and branch-version-2. We build both of them. The final stage than chooses one of these stages, based on my_arg. Conditional Dockerfile. There you go.
Output when running:
(I abbreviated this a little...)
my_arg==2
docker build --build-arg my_arg=2 . Step 1/12 : ARG my_arg Step 2/12 : ARG ENV Step 3/12 : FROM centos:7 AS base Step 4/12 : RUN echo "do stuff with the centos image" do stuff with the centos image Step 5/12 : FROM base AS branch-version-1 Step 6/12 : RUN echo "this is the stage that sets VAR=TRUE" this is the stage that sets VAR=TRUE Step 7/12 : ENV VAR=TRUE Step 8/12 : FROM base AS branch-version-2 Step 9/12 : RUN echo "this is the stage that sets VAR=FALSE" this is the stage that sets VAR=FALSE Step 10/12 : ENV VAR=FALSE Step 11/12 : FROM branch-version-${my_arg} Step 12/12 : RUN echo "VAR is equal to ${VAR}" VAR is equal to FALSE my_arg==1
docker build --build-arg my_arg=1 . ... Step 11/12 : FROM branch-version-${my_arg} Step 12/12 : RUN echo "VAR is equal to ${VAR}" VAR is equal to TRUE Thanks to Tõnis for this amazing idea!
11Do not use build args described in other answers where at all possible. This is an old messy solution. Docker's target property solves for this issue.
Target Example
Dockerfile
FROM foo as base RUN ... # Build dev image FROM base as image-dev RUN ... COPY ... # Build prod image FROM base as image-prod RUN ... COPY ... docker build --target image-dev -t foo . version: '3.4' services: dev: build: context: . dockerfile: Dockerfile target: image-dev Real World
Dockerfiles get complex in the real world. Use buildkit & COPY --from for faster, more maintainable Dockerfiles:
- Docker builds every stage above the target, regardless of whether it is inherited or not. Use buildkit to build only inherited stages. Docker must by v19+. Hopefully this will be a default feature soon.
- Targets may share build stages. Use
COPY --fromto simplify inheritance.
FROM foo as base RUN ... WORKDIR /opt/my-proj FROM base as npm-ci-dev # invalidate cache COPY --chown=www-data:www-data ./package.json /opt/my-proj/package.json COPY --chown=www-data:www-data ./package-lock.json /opt/my-proj/package-lock.json RUN npm ci FROM base as npm-ci-prod # invalidate cache COPY --chown=www-data:www-data ./package.json /opt/my-proj/package.json COPY --chown=www-data:www-data ./package-lock.json /opt/my-proj/package-lock.json RUN npm ci --only=prod FROM base as proj-files COPY --chown=www-data:www-data ./ /opt/my-proj FROM base as image-dev # Will mount, not copy in dev environment RUN ... FROM base as image-ci COPY --from=npm-ci-dev /opt/my-proj . COPY --from=proj-files /opt/my-proj . RUN ... FROM base as image-stage COPY --from=npm-ci-prod /opt/my-proj . COPY --from=proj-files /opt/my-proj . RUN ... FROM base as image-prod COPY --from=npm-ci-prod /opt/my-proj . COPY --from=proj-files /opt/my-proj . RUN ... Enable experimental mode.
sudo echo '{"experimental": true}' | sudo tee /etc/docker/daemon.json Build with buildkit enabled. Buildkit builds without cache by default - enable with --build-arg BUILDKIT_INLINE_CACHE=1
CI build job.
DOCKER_BUILDKIT=1 \ docker build \ --build-arg BUILDKIT_INLINE_CACHE=1 \ --target image-ci\ -t foo:ci . Use cache from a pulled image with --cache-from
Prod build job
docker pull foo:ci docker pull foo:stage DOCKER_BUILDKIT=1 \ docker build \ --cache-from foo:ci,foo:stage \ --target image-prod \ -t prod . From some reason most of the answers here didn't help me (maybe it's related to my FROM image in the Dockerfile)
So I preferred to create a bash script in my workspace combined with --build-arg in order to handle if statement while Docker build by checking if the argument is empty or not
Bash script:
#!/bin/bash -x if test -z $1 ; then echo "The arg is empty" ....do something.... else echo "The arg is not empty: $1" ....do something else.... fi Dockerfile:
FROM ... .... ARG arg COPY bash.sh /tmp/ RUN chmod u+x /tmp/bash.sh && /tmp/bash.sh $arg .... Docker Build:
docker build --pull -f "Dockerfile" -t $SERVICE_NAME --build-arg arg="yes" . Remark: This will go to the else (false) in the bash script
docker build --pull -f "Dockerfile" -t $SERVICE_NAME . Remark: This will go to the if (true)
Edit 1:
After several tries I have found the following article and this one which helped me to understand 2 things:
1) ARG before FROM is outside of the build
2) The default shell is /bin/sh which means that the if else is working a little bit different in the docker build. for example you need only one "=" instead of "==" to compare strings.
So you can do this inside the Dockerfile
ARG argname=false #default argument when not provided in the --build-arg RUN if [ "$argname" = "false" ] ; then echo 'false'; else echo 'true'; fi and in the docker build:
docker build --pull -f "Dockerfile" --label "service_name=${SERVICE_NAME}" -t $SERVICE_NAME --build-arg argname=true . Just use the "test" binary directly to do this. You also should use the noop command ":" if you don't want to specify an "else" condition, so docker does not stop with a non zero return value error.
RUN test -z "$YOURVAR" || echo "var is set" && echo "var is not set" RUN test -z "$YOURVAR" && echo "var is not set" || : RUN test -z "$YOURVAR" || echo "var is set" && : The accepted answer may solve the question, but if you want multiline if conditions in the dockerfile, you can do that placing \ at the end of each line (similar to how you would do in a shell script) and ending each command with ;. You can even define someting like set -eux as the 1st command.
Example:
RUN set -eux; \ if [ -f /path/to/file ]; then \ mv /path/to/file /dest; \ fi; \ if [ -d /path/to/dir ]; then \ mv /path/to/dir /dest; \ fi In your case:
FROM centos:7 ARG arg RUN if [ -z "$arg" ] ; then \ echo Argument not provided; \ else \ echo Argument is $arg; \ fi Then build with:
docker build -t my_docker . --build-arg arg=42 According to the doc for the docker build command, there is a parameter called --build-arg.
Example usage:
docker build --build-arg HTTP_PROXY= . IMO it's what you need :)
Exactly as others told, shell script would help.
Just an additional case, IMHO it's worth mentioning (for someone else who stumble upon here, looking for an easier case), that is Environment replacement.
Environment variables (declared with the
ENVstatement) can also be used in certain instructions as variables to be interpreted by theDockerfile.The
${variable_name}syntax also supports a few of the standard bash modifiers as specified below:
${variable:-word}indicates that ifvariableis set then the result will be that value. Ifvariableis not set thenwordwill be the result.
${variable:+word}indicates that ifvariableis set thenwordwill be the result, otherwise the result is the empty string.
Using Bash script and Alpine/Centos
Dockerfile
FROM alpine #just change this to centos ARG MYARG="" ENV E_MYARG=$MYARG ADD . /tmp RUN chmod +x /tmp/script.sh && /tmp/script.sh script.sh
#!/usr/bin/env sh if [ -z "$E_MYARG" ]; then echo "NO PARAM PASSED" else echo $E_MYARG fi Passing arg: docker build -t test --build-arg MYARG="this is a test" .
.... Step 5/5 : RUN chmod +x /tmp/script.sh && /tmp/script.sh ---> Running in 10b0e07e33fc this is a test Removing intermediate container 10b0e07e33fc ---> f6f085ffb284 Successfully built f6f085ffb284 Without arg: docker build -t test .
.... Step 5/5 : RUN chmod +x /tmp/script.sh && /tmp/script.sh ---> Running in b89210b0cac0 NO PARAM PASSED Removing intermediate container b89210b0cac0 .... I had a similar issue for setting proxy server on a container.
The solution I'm using is an entrypoint script, and another script for environment variables configuration. Using RUN, you assure the configuration script runs on build, and ENTRYPOINT when you run the container.
--build-arg is used on command line to set proxy user and password.
As I need the same environment variables on container startup, I used a file to "persist" it from build to run.
The entrypoint script looks like:
#!/bin/bash # Load the script of environment variables . /root/configproxy.sh # Run the main container command exec "$@" configproxy.sh
#!/bin/bash function start_config { read u p < /root/proxy_credentials export HTTP_PROXY= export HTTPS_PROXY= /bin/cat <<EOF > /etc/apt/apt.conf Acquire::http::proxy ""; Acquire::https::proxy ""; EOF } if [ -s "/root/proxy_credentials" ] then start_config fi And in the Dockerfile, configure:
# Base Image FROM ubuntu:18.04 ARG user ARG pass USER root # -z the length of STRING is zero # [] are an alias for test command # if $user is not empty, write credentials file RUN if [ ! -z "$user" ]; then echo "${user} ${pass}">/root/proxy_credentials ; fi #copy bash scripts COPY configproxy.sh /root COPY startup.sh . RUN ["/bin/bash", "-c", ". /root/configproxy.sh"] # Install dependencies and tools #RUN apt-get update -y && \ # apt-get install -yqq --no-install-recommends \ # vim iputils-ping ENTRYPOINT ["./startup.sh"] CMD ["sh", "-c", "bash"] Build without proxy settings
docker build -t img01 -f Dockerfile . Build with proxy settings
docker build -t img01 --build-arg user=<USER> --build-arg pass=<PASS> -f Dockerfile . Take a look here.
You can just add a simple check:
RUN [ -z "$ARG" ] \ && echo "ARG argument not provided." \ && exit 1 || exit 0 
