¿COPIA / AÑADIR condicional en Dockerfile?

Dentro de mis Dockerfiles, me gustaría COPIAR un archivo en mi imagen si existe, el archivo requirements.txt para pip parece un buen candidato, pero ¿cómo se lograría?

COPY (requirements.txt if test -e requirements.txt; fi) /destination
...
RUN  if test -e requirements.txt; then pip install -r requirements.txt; fi

o

if test -e requirements.txt; then
    COPY requiements.txt /destination;
fi
RUN  if test -e requirements.txt; then pip install -r requirements.txt; fi

Actualmente, esto no es compatible (ya que sospecho que conduciría a una imagen no reproducible, ya que el mismo Dockerfile copiaría o no el archivo, dependiendo de su existencia).

Esto todavía se solicita, en el número 13045 , utilizando comodines: " COPY foo/* bar/" not work if no file in foo" (mayo de 2015).
No se implementará por ahora (julio de 2015) en Docker, pero otra herramienta de compilación como bocker podría admitir esto.

Aquí hay una solución alternativa simple:

COPY foo file-which-may-exist* /target

Asegúrese de que fooexista, ya que COPYnecesita al menos una fuente válida.

Si file-which-may-existestá presente, también se copiará.

NOTA: Debe asegurarse de que su comodín no recoja otros archivos que no tenga la intención de copiar. Para tener más cuidado, puede usar file-which-may-exist?en su lugar ( ?coincide con un solo carácter).

O incluso mejor, use una clase de carácter como esta para asegurarse de que solo se pueda hacer coincidir un archivo:

COPY foo file-which-may-exis[t] /target

Como se indica en este comentario , la respuesta de Santhosh Hirekerur aún copia el archivo, para archivar una copia condicional verdadera, puede usar este método.

ARG BUILD_ENV=copy

FROM alpine as build_copy
ONBUILD COPY file /file

FROM alpine as build_no_copy
ONBUILD RUN echo "I don't copy"

FROM build_${BUILD_ENV}
# other stuff

Las ONBUILDinstrucciones aseguran que el archivo solo se copia si la "rama" es seleccionada por el BUILD_ENV. Configura esta var usando un pequeño script antes de llamardocker build

Trabajar alrededor de la solución

Tenía el requisito de copiar FOLDER al servidor basado en ENV Variables. Tomé la imagen del servidor vacía. creó la estructura de la carpeta de implementación requerida en la carpeta local. luego se agrega debajo de la línea a DockerFile, copie la carpeta al contenedor. En la última línea se agregó un punto de entrada para ejecutar init file.sh antes de que Docker inicie el servidor.

#below lines added to integrate testing framework
RUN mkdir /mnt/conf_folder
ADD install /mnt/conf_folder/install
ADD install_test /mnt/conf_folder/install_test
ADD custom-init.sh /usr/local/bin/custom-init.sh
ENTRYPOINT ["/usr/local/bin/custom-init.sh"]

Luego cree el archivo custom-init.sh en local con un script como el siguiente

#!/bin/bash
if [ "${BUILD_EVN}" = "TEST" ]; then
    cp -avr /mnt/conf_folder/install_test/* /mnt/wso2das-3.1.0/
else
    cp -avr /mnt/conf_folder/install/* /mnt/wso2das-3.1.0/
fi;

En el archivo docker-compose debajo de las líneas.

entorno: - BUILD_EVN = TEST

Estos cambios copian la carpeta al contenedor durante la compilación de Docker. cuando ejecutamos docker-compose , copie o implemente la carpeta requerida real en el servidor antes de que se inicie.

Copie todos los archivos en un directorio desechable, elija manualmente el que desee y descarte el resto.

COPY . /throwaway
RUN cp /throwaway/requirements.txt . || echo 'requirements.txt does not exist'
RUN rm -rf /throwaway

Puede lograr algo similar usando etapas de compilación, que se basan en la misma solución, usando cppara copiar condicionalmente. Al usar una etapa de construcción, su imagen final no incluirá todo el contenido de la inicial COPY.

FROM alpine as copy_stage
COPY . .
RUN mkdir /dir_for_maybe_requirements_file
RUN cp requirements.txt /dir_for_maybe_requirements_file &>- || true

FROM alpine
# Must copy a file which exists, so copy a directory with maybe one file
COPY --from=copy_stage /dir_for_maybe_requirements_file /
RUN cp /dir_for_maybe_requirements_file/* . &>- || true
CMD sh

Probé las otras ideas, pero ninguna cumplió con nuestro requisito. La idea es crear una imagen nginx base para aplicaciones web estáticas secundarias. Por razones de seguridad, optimización y estandarización, la imagen base debe poder RUNejecutar comandos en directorios agregados por imágenes secundarias. La imagen base no controla qué directorios agregan las imágenes secundarias. La suposición es que las imágenes de los niños serán COPYrecursos en algún lugar debajo COMMON_DEST_ROOT.

Este enfoque es un truco, pero la idea es que la imagen base admitirá la COPYinstrucción para 1 a N directorios agregados por la imagen secundaria. ARG PLACEHOLDER_FILEy ENV UNPROVIDED_DESTse utilizan para satisfacer <src>y <dest>requisitos para cualquier COPYno necesitan instrucción.

#
# base-image:01
#
FROM nginx:1.17.3-alpine
ENV UNPROVIDED_DEST=/unprovided
ENV COMMON_DEST_ROOT=/usr/share/nginx/html
ONBUILD ARG PLACEHOLDER_FILE
ONBUILD ARG SRC_1
ONBUILD ARG DEST_1
ONBUILD ARG SRC_2
ONBUILD ARG DEST_2
ONBUILD ENV SRC_1=${SRC_1:-PLACEHOLDER_FILE}
ONBUILD ENV DEST_1=${DEST_1:-${UNPROVIDED_DEST}}
ONBUILD ENV SRC_2=${SRC_2:-PLACEHOLDER_FILE}
ONBUILD ENV DEST_2=${DEST_2:-${UNPROVIDED_DEST}}

ONBUILD COPY ${SRC_1} ${DEST_1}
ONBUILD COPY ${SRC_2} ${DEST_2}

ONBUILD RUN sh -x \
    #
    # perform operations on COMMON_DEST_ROOT
    #
    && chown -R limited:limited ${COMMON_DEST_ROOT} \
    #
    # remove the unprovided dest
    #
    && rm -rf ${UNPROVIDED_DEST}

#
# child image
#
ARG PLACEHOLDER_FILE=dummy_placeholder.txt
ARG SRC_1=app/html
ARG DEST_1=/usr/share/nginx/html/myapp
FROM base-image:01

Esta solución tiene deficiencias obvias como el número ficticio PLACEHOLDER_FILEy codificado de instrucciones COPY que son compatibles. Además, no hay forma de deshacerse de las variables ENV que se utilizan en la instrucción COPY.