Dockerfile if else condizione con argomenti esterni

Ho dockerfile

FROM centos:7
ENV foo=42

poi lo costruisco

docker build -t my_docker .

ed eseguilo.

docker run -it -d  my_docker

È possibile passare argomenti dalla riga di comando e usarlo con if else in Dockerfile? Intendo qualcosa di simile

FROM centos:7
if (my_arg==42)
     {ENV=TRUE}
else:
     {ENV=FALSE}

e costruire con questo argomento.

 docker build -t my_docker . --my_arg=42

Potrebbe non sembrare così pulito ma puoi avere il tuo Dockerfile (condizionale) come segue:

FROM centos:7
ARG arg
RUN if [ "x$arg" = "x" ] ; then echo Argument not provided ; else echo Argument is $arg ; fi

e quindi crea l'immagine come:

docker build -t my_docker . --build-arg arg=45

o

docker build -t my_docker .

Per qualche motivo la maggior parte delle risposte qui non mi ha aiutato (forse è correlato alla mia immagine FROM nel Dockerfile)

Quindi ho preferito creare un bash scriptnel mio spazio di lavoro combinato con --build-argper gestire l'istruzione if mentre Docker creava controllando se l'argomento è vuoto o meno

Script Bash:

#!/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
....

Build Docker:

docker build --pull -f "Dockerfile" -t $SERVICE_NAME --build-arg arg="yes" .

Nota: questo andrà a else (false) nello script bash

docker build --pull -f "Dockerfile" -t $SERVICE_NAME .

Nota: questo andrà al if (true)

Modifica 1:

Dopo diversi tentativi ho trovato il seguente articolo e questo uno che mi ha aiutato a capire 2 cose:

1) ARG prima di FROM è al di fuori della build

2) La shell predefinita è / bin / sh, il che significa che if else funziona in modo leggermente diverso nella build docker. ad esempio è necessario un solo "=" invece di "==" per confrontare le stringhe.

Quindi puoi farlo all'interno del file Dockerfile

ARG argname=false   #default argument when not provided in the --build-arg
RUN if [ "$argname" = "false" ] ; then echo 'false'; else echo 'true'; fi

e in docker build:

docker build --pull -f "Dockerfile" --label "service_name=${SERVICE_NAME}" -t $SERVICE_NAME --build-arg argname=true .

Secondo il documento per il docker buildcomando , c'è un parametro chiamato --build-arg.

Utilizzo di esempio:

docker build --build-arg HTTP_PROXY=http://10.20.30.2:1234 .

IMO è quello di cui hai bisogno :)

Esiste un'interessante alternativa alle soluzioni proposte, che funziona con un singolo Dockerfile , richiede solo una singola chiamata a docker build per build condizionale ed evita bash .

Soluzione:

Quanto segue Dockerfilerisolve il problema. Copia-incolla e prova tu stesso.

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}"

Spiegazione di Dockerfile:

Per prima cosa otteniamo baseun'immagine ( centos:7nel tuo caso) e la inseriamo nella sua fase. Lo basestage dovrebbe contenere le cose che vuoi fare prima della condizione. Dopodiché, abbiamo altre due fasi, che rappresentano i rami della nostra condizione: branch-version-1e branch-version-2. Li costruiamo entrambi. La finalfase che sceglie una di queste fasi, basata su my_arg. Dockerfile condizionale. Ecco qua.

Uscita durante l'esecuzione:

(L'ho abbreviato un po '...)

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_var==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

Grazie a Tõnis per questa fantastica idea!

Basta usare direttamente il binario "test" per farlo. Dovresti anche usare il comando noop ":" se non vuoi specificare una condizione "else", così docker non si ferma con un errore di valore di ritorno diverso da zero.

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" && :

Esattamente come altri hanno detto, lo script di shell sarebbe stato d'aiuto.

Solo un caso aggiuntivo, IMHO vale la pena menzionare (per qualcun altro che si imbatte qui, alla ricerca di un caso più semplice), che è la sostituzione dell'ambiente .

Le variabili d'ambiente (dichiarate con l' ENVistruzione) possono anche essere utilizzate in alcune istruzioni come variabili da interpretare dal Dockerfile.

La ${variable_name}sintassi supporta anche alcuni dei modificatori bash standard come specificato di seguito:

• ${variable:-word}indica che se variableè impostato, il risultato sarà quel valore. Se variablenon è impostato, wordsarà il risultato.

• ${variable:+word}indica che se variableè impostato allora wordsarà il risultato, altrimenti il ​​risultato è una stringa vuota.

La risposta accettata può risolvere la domanda, ma se desideri ifcondizioni su più righe nel dockerfile, puoi farlo posizionando \alla fine di ogni riga (simile a come faresti in uno script di shell) e terminando ogni comando con ;. Puoi anche definire qualcosa come set -euxil primo comando.

Esempio:

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

Nel tuo caso:

FROM centos:7
ARG arg
RUN if [ -z "$arg" ] ; then \
    echo Argument not provided; \
  else \
    echo Argument is $arg; \
  fi

Quindi crea con:

docker build -t my_docker . --build-arg arg=42

Utilizzando lo script Bash e 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

Passaggio 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

Senza 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
....