Come passare argomenti a Shell Script tramite la finestra mobile

Sono nuovo nel mondo delle docker. Devo invocare uno script di shell che accetta gli argomenti della riga di comando attraverso un contenitore finestra mobile. Esempio: il mio script shell ha il seguente aspetto:

#!bin/bash
echo $1

Il file Docker è simile al seguente:

FROM ubuntu:14.04
COPY ./file.sh /
CMD /bin/bash file.sh

Non sono sicuro di come passare gli argomenti durante l'esecuzione del contenitore

Usa lo stesso file.sh

#!/bin/bash
echo $1

Costruisci l'immagine usando il Dockerfile esistente:

docker build -t test .

Esegui l'immagine con argomenti abco xyzo qualcos'altro.

docker run -ti test /file.sh abc

docker run -ti test /file.sh xyz

con questo script in file.sh

#!/bin/bash
echo Your container args are: "$@"

e questo Dockerfile

FROM ubuntu:14.04
COPY ./file.sh /
ENTRYPOINT ["/file.sh"]

dovresti essere capace di:

% docker build -t test .
% docker run test hello world
Your container args are: hello world

Con Docker, il modo corretto di trasmettere questo tipo di informazioni è attraverso le variabili di ambiente.

Quindi, con lo stesso Dockerfile, cambia lo script in

#!/bin/bash
echo $FOO

Dopo la creazione, utilizzare il seguente comando finestra mobile:

docker run -e FOO="hello world!" test

Ci sono alcune cose che interagiscono qui:

1. docker run your_image arg1 arg2sostituirà il valore di CMDcon arg1 arg2. Questa è una sostituzione completa della CMD, senza aggiungere più valori ad essa. Questo è il motivo per cui si vede spesso docker run some_image /bin/basheseguire una shell bash nel contenitore.

2. Quando sono definiti sia un ENTRYPOINT che un valore CMD, la finestra mobile avvia il contenitore concatenando i due ed eseguendo quel comando concatenato. Quindi, se si definisce il proprio entrypoint file.sh, ora è possibile eseguire il contenitore con argomenti aggiuntivi che verranno passati come argomenti file.sh.

3. Entrypoints e comandi nella finestra mobile hanno due sintassi, una sintassi di stringa che avvierà una shell e una sintassi json che eseguirà un exec. La shell è utile per gestire cose come il reindirizzamento IO, concatenare più comandi insieme (con cose come &&), sostituzione di variabili, ecc. Tuttavia, quella shell si mette di mezzo con la gestione del segnale (se hai mai visto un ritardo di 10 secondi per fermarsi un contenitore, questa è spesso la causa) e con la concatenazione di un punto di accesso e comando insieme. Se definisci il tuo entrypoint come una stringa, verrebbe eseguito /bin/sh -c "file.sh", il che da solo va bene. Ma se hai anche un comando definito come una stringa, vedrai qualcosa come /bin/sh -c "file.sh" /bin/sh -c "arg1 arg2"il comando che viene lanciato nel tuo contenitore, non così bene. Vedi la tabella qui per ulteriori informazioni su come interagiscono queste due opzioni

4. L' -copzione shell accetta solo un singolo argomento. Tutto ciò che segue sarebbe passato come $1, $2ecc., A quel singolo argomento, ma non in uno script di shell incorporato a meno che tu non abbia esplicitamente passato gli arg. Vale a dire che /bin/sh -c "file.sh $1 $2" "arg1" "arg2"avrebbe funzionato, ma /bin/sh -c "file.sh" "arg1" "arg2"da allora non file.shsarebbe stato chiamato senza argomenti.

Mettendo tutto insieme, il design comune è:

FROM ubuntu:14.04
COPY ./file.sh /
RUN chmod 755 /file.sh
# Note the json syntax on this next line is strict, double quotes, and any syntax
# error will result in a shell being used to run the line.
ENTRYPOINT ["file.sh"]

E poi lo esegui con:

docker run your_image arg1 arg2

C'è un po 'più di dettagli su questo in:

• https://docs.docker.com/engine/reference/run/#cmd-default-command-or-options
• https://docs.docker.com/engine/reference/builder/#exec-form-entrypoint-example

Quello che ho è un file di script che esegue effettivamente le cose. Questo file script potrebbe essere relativamente complicato. Chiamiamolo "run_container". Questo script accetta argomenti dalla riga di comando:

run_container p1 p2 p3

Un semplice run_container potrebbe essere:

#!/bin/bash
echo "argc = ${#*}"
echo "argv = ${*}"

Quello che voglio fare è che, dopo "docking", vorrei poter avviare questo contenitore con i parametri sulla riga comandi docker in questo modo:

docker run image_name p1 p2 p3

e far eseguire lo script run_container con p1 p2 p3 come parametri.

Questa è la mia soluzione:

Dockerfile:

FROM docker.io/ubuntu
ADD run_container /
ENTRYPOINT ["/bin/bash", "-c", "/run_container \"$@\"", "--"]

Se vuoi eseguirlo @build time:

CMD /bin/bash /file.sh arg1

se vuoi eseguirlo @run time:

ENTRYPOINT ["/bin/bash"]
CMD ["/file.sh", "arg1"]

Quindi nella shell host

docker build -t test .
docker run -i -t test

Un'altra opzione...

Per farlo funzionare

docker run -d --rm $IMG_NAME "bash:command1&&command2&&command3"

nel file docker

ENTRYPOINT ["/entrypoint.sh"]

in entrypoint.sh

#!/bin/sh

entrypoint_params=$1
printf "==>[entrypoint.sh] %s\n" "entry_point_param is $entrypoint_params"

PARAM1=$(echo $entrypoint_params | cut -d':' -f1) # output is 1 must be 'bash' it     will be tested    
PARAM2=$(echo $entrypoint_params | cut -d':' -f2) # the real command separated by     &&

printf "==>[entrypoint.sh] %s\n" "PARAM1=$PARAM1"
printf "==>[entrypoint.sh] %s\n" "PARAM2=$PARAM2"

if [ "$PARAM1" = "bash" ];
then
    printf "==>[entrypoint.sh] %s\n" "about to running $PARAM2 command"
    echo $PARAM2 | tr '&&' '\n' | while read cmd; do
        $cmd
    done    
fi