Dockerfile 的有条件环境影响评估

是否可以根据构建 ARG的值在 Dockerfile 中有条件地设置 ENV变量？

例如

ARG BUILDVAR=sad
ENV SOMEVAR=if $BUILDVAR -eq "SO"; then echo "hello"; else echo "world"; fi

更新: 根据马里奥的回答，目前的用法是:

ARG BUILD_ENV=prod
ENV NODE_ENV=production
RUN if [ "${BUILD_ENV}" = "test" ]; then export NODE_ENV=development; fi

但是，运行 --build-arg BUILD_ENV=test然后进入主机，我还是得到了

docker run -it mycontainer bin/bash
[root@brbqw1231 /]# echo $NODE_ENV
production
114993 次浏览
小开

You cannot run bash code in the Dockerfile directly, but you have to use the RUN command. So, for example, you can change ENV with RUN and export the variable in the if, like below:

ARG BUILDVAR=sad
RUN if [ "$BUILDVAR" = "SO" ]; \
then export SOMEVAR=hello; \
else export SOMEVAR=world; \
fi

I didn't try it but should work.

小开

While you can't set conditional ENV variables but you may be able to acomplish what you are after with the RUN command and a null-coalescing environment variable:

RUN node /var/app/current/index.js --env ${BUILD_ENV:-${NODE_ENV:-"development"}}
小开

Passing values to Dockerfile and then to entrypoint script

From the command line pass in your required value (TARG)

docker run --env TARG=T1_WS01 -i projects/msbob

Then in your Dockerfile put something like this

Dockerfile:
# if $TARG is not set then "entrypoint" defaults to Q0_WS01
CMD ./entrypoint.sh ${TARG} Q0_WS01

The entrypoint.sh script only reads the first argument 

entrypoint.sh:
#!/bin/bash
[ $1 ] || { echo "usage: entrypoint.sh <$TARG>" ; exit ; }
target_env=$1
小开

Your logic is actually correct. The problem here is that RUN export ... won't work in a Dockerfile because the export command won't persist across images. Dockerfiles create a temporary container in order to generate the image for it, therefore the environment variables won't exist.

ENV on the other hand as per the documentation states:

The environment variables set using ENV will persist when a container is run from the resulting image.

The only way to do this is during your docker run command when generating the container from your image, and wrap your logic around that:

if [ "${BUILD_ENV}" = "test" ]; then
docker run -e NODE_ENV=development myimage
else
docker run myimage
fi
小开
最佳答案

Yes, it is possible, but you need to use your build argument as flag. You can use parameter expansion feature of shell to check condition. Here is a proof-of-concept Docker file:

FROM debian:stable
ARG BUILD_DEVELOPMENT
# if --build-arg BUILD_DEVELOPMENT=1, set NODE_ENV to 'development' or set to null otherwise.
ENV NODE_ENV=${BUILD_DEVELOPMENT:+development}
# if NODE_ENV is null, set it to 'production' (or leave as is otherwise).
ENV NODE_ENV=${NODE_ENV:-production}

Testing build:

docker build --rm -t env_prod ./
...
docker run -it env_prod bash
root@2a2c93f80ad3:/# echo $NODE_ENV
production
root@2a2c93f80ad3:/# exit
docker build --rm -t env_dev --build-arg BUILD_DEVELOPMENT=1 ./
...
docker run -it env_dev bash
root@2db6d7931f34:/# echo $NODE_ENV
development
小开

If we are talking only about environment variable, then just set it with production

ENV NODE_ENV prod

And during container start in development, you may use -e NODE_ENV=dev.

This way image is always built-in production but the local container is launched in development.

小开

This answer is great if you only need to check whether a build-arg is present and you want to set a default value. To improve this solution, in case you want to use the data passed by the build-arg, you can do the following:

FROM debian:stable
ARG BUILD_DEVELOPMENT=production
ENV NODE_ENV=$BUILD_DEVELOPMENT

The magic comes from the default value for the ARG.

小开

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.

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=http://$u:$p@proxy.com:8080
export HTTPS_PROXY=https://$u:$p@proxy.com:8080


/bin/cat <<EOF > /etc/apt/apt.conf
Acquire::http::proxy "http://$u:$p@proxy.com:8080";
Acquire::https::proxy "https://$u:$p@proxy.com:8080";
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.


提交答案