Jak przekazać argumenty do skryptu powłoki poprzez uruchomienie dockera

Jestem nowy w świecie dokerów. Muszę wywołać skrypt powłoki, który pobiera argumenty wiersza poleceń przez kontener Dockera. Np. Mój skrypt powłoki wygląda następująco:

#!bin/bash
echo $1

Dockerfile wygląda następująco:

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

Nie jestem pewien, jak przekazać argumenty podczas uruchamiania kontenera

Użyj tego samego file.sh

#!/bin/bash
echo $1

Zbuduj obraz, używając istniejącego pliku Dockerfile:

docker build -t test .

Uruchomić obraz z argumentów abclub xyzczy coś innego.

docker run -ti test /file.sh abc

docker run -ti test /file.sh xyz

z tym skryptem w formacie file.sh

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

i to Dockerfile

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

Powinieneś być w stanie:

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

W przypadku Dockera właściwym sposobem przekazywania tego rodzaju informacji są zmienne środowiskowe.

Więc z tym samym plikiem Dockerfile zmień skrypt na

#!/bin/bash
echo $FOO

Po zbudowaniu użyj następującego polecenia dokowanego:

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

Jest tu kilka rzeczy, które wchodzą w interakcje:

1. docker run your_image arg1 arg2zastąpi wartość CMDz arg1 arg2. To jest pełne zastąpienie CMD, bez dodawania do niego więcej wartości. Dlatego często widzisz docker run some_image /bin/bashuruchamianie powłoki bash w kontenerze.

2. Gdy masz zdefiniowane zarówno ENTRYPOINT, jak i CMD, docker uruchamia kontener, łącząc te dwa elementy i uruchamiając to połączone polecenie. Jeśli więc zdefiniujesz swój punkt wejścia file.sh, możesz teraz uruchomić kontener z dodatkowymi argumentami, które zostaną przekazane jako argumenty do file.sh.

3. Punkty wejścia i polecenia w dockerze mają dwie składnie, składnię ciągu, która uruchomi powłokę, oraz składnię json, która wykona polecenie exec. Powłoka jest przydatna do obsługi takich rzeczy jak przekierowanie IO, łączenie wielu poleceń razem (z takimi rzeczami &&), podstawianie zmiennych itp. Jednak powłoka ta przeszkadza w obsłudze sygnału (jeśli kiedykolwiek widziałeś 10-sekundowe opóźnienie zatrzymania kontenera, to jest często przyczyna) oraz z połączeniem punktu wejścia i polecenia razem. Jeśli zdefiniujesz swój punkt wejścia jako łańcuch, będzie działać /bin/sh -c "file.sh", co samo w sobie jest w porządku. Ale jeśli masz polecenie zdefiniowane również jako ciąg, zobaczysz coś takiego, /bin/sh -c "file.sh" /bin/sh -c "arg1 arg2"jak polecenie uruchamiane w twoim kontenerze, nie tak dobrze. Zobacz tabelę tutaj, aby uzyskać więcej informacji na temat interakcji tych dwóch opcji

4. Opcja powłoki -cprzyjmuje tylko jeden argument. Wszystko po to by uzyskać przekazany jako $1, $2itp, w tym jeden argument, ale nie w osadzonym skryptem powłoki, chyba że wyraźnie przeszły args. To znaczy /bin/sh -c "file.sh $1 $2" "arg1" "arg2"zadziała, ale /bin/sh -c "file.sh" "arg1" "arg2"od file.shtego czasu nie zostanie wywołany bez argumentów.

Podsumowując, wspólny projekt to:

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

Następnie uruchamiasz to z:

docker run your_image arg1 arg2

Jest o wiele więcej szczegółów na ten temat pod adresem:

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

To, co mam, to plik skryptu, który faktycznie uruchamia. Ten plik skryptu może być stosunkowo skomplikowany. Nazwijmy to „run_container”. Ten skrypt pobiera argumenty z wiersza poleceń:

run_container p1 p2 p3

Prostym run_container może być:

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

To, co chcę zrobić, to po "dokowaniu" tego chciałbym móc uruchomić ten kontener z parametrami w wierszu poleceń dockera, takimi jak:

docker run image_name p1 p2 p3

i uruchom skrypt run_container z parametrami p1 p2 p3.

To jest moje rozwiązanie:

Dockerfile:

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

Jeśli chcesz go uruchomić w czasie kompilacji:

CMD /bin/bash /file.sh arg1

jeśli chcesz go uruchomić @ run time:

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

Następnie w powłoce hosta

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

Inna opcja...

Aby to działało

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

w pliku dockerfile

ENTRYPOINT ["/entrypoint.sh"]

w 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