Como passar argumentos para o Shell Script por meio da janela de encaixe

Eu sou novo no mundo dos estivadores. Eu tenho que chamar um script de shell que leva argumentos de linha de comando através de um contêiner de janela de encaixe. Ex: Meu script shell se parece com:

#!bin/bash
echo $1

O Dockerfile fica assim:

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

Não sei como transmitir os argumentos enquanto estiver executando o contêiner

Use o mesmo file.sh

#!/bin/bash
echo $1

Crie a imagem usando o Dockerfile existente:

docker build -t test .

Executar a imagem com argumentos abcou xyzou qualquer outra coisa.

docker run -ti test /file.sh abc

docker run -ti test /file.sh xyz

com este script em file.sh

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

e isto Dockerfile

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

você deve ser capaz de:

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

Com o Docker, a maneira correta de passar esse tipo de informação é através de variáveis ​​de ambiente.

Portanto, com o mesmo Dockerfile, altere o script para

#!/bin/bash
echo $FOO

Após a construção, use o seguinte comando do docker:

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

Existem algumas coisas interagindo aqui:

1. docker run your_image arg1 arg2substituirá o valor de CMDcom arg1 arg2. Essa é uma substituição completa do CMD, não acrescentando mais valores a ele. É por isso que você costuma docker run some_image /bin/bashexecutar um shell bash no contêiner.

2. Quando você tem um valor ENTRYPOINT e um valor CMD definidos, a janela de encaixe inicia o contêiner concatenando os dois e executando esse comando concatenado. Portanto, se você definir seu ponto de entrada file.sh, agora poderá executar o contêiner com argumentos adicionais que serão passados ​​como argumentos para file.sh.

3. Pontos de entrada e comandos na janela de encaixe possuem duas sintaxes, uma sintaxe de cadeia que iniciará um shell e uma sintaxe json que executará um exec. O shell é útil para lidar com coisas como redirecionamento de E / S, encadear vários comandos juntos (com coisas como &&), substituição de variáveis ​​etc. No entanto, esse shell atrapalha a manipulação do sinal (se você já viu um atraso de 10 segundos para parar um contêiner, isso geralmente é a causa) e concatenar um ponto de entrada e um comando juntos. Se você definir seu ponto de entrada como uma sequência, ele será executado /bin/sh -c "file.sh", o que por si só é bom. Mas se você tiver um comando definido como uma sequência também, verá algo como /bin/sh -c "file.sh" /bin/sh -c "arg1 arg2"o comando sendo lançado dentro do seu contêiner, não tão bom. Veja a tabela aqui para mais informações sobre como essas duas opções interagem

4. A -copção shell usa apenas um único argumento. Tudo depois disso seria passado como $1, $2etc, para esse único argumento, mas não para um script de shell incorporado, a menos que você passasse explicitamente os argumentos. Ou seja /bin/sh -c "file.sh $1 $2" "arg1" "arg2", funcionaria, mas /bin/sh -c "file.sh" "arg1" "arg2"não file.shseria desde então chamado sem argumentos.

Juntando tudo isso, o design comum é:

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 você executa isso com:

docker run your_image arg1 arg2

Há um pouco mais de detalhes sobre isso em:

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

O que tenho é um arquivo de script que realmente executa as coisas. Esse arquivo de script pode ser relativamente complicado. Vamos chamá-lo de "run_container". Este script usa argumentos da linha de comando:

run_container p1 p2 p3

Um simples run_container pode ser:

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

O que eu quero fazer é que, depois de "encaixar" isso, eu gostaria de inicializar este contêiner com os parâmetros na linha de comando do docker, como este:

docker run image_name p1 p2 p3

e faça com que o script run_container seja executado com p1 p2 p3 como parâmetros.

Esta é a minha solução:

Dockerfile:

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

Se você deseja executá-lo em @build time:

CMD /bin/bash /file.sh arg1

se você quiser executá-lo em @run time:

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

Em seguida, no shell do host

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

Outra opção...

Para fazer isso funcionar

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

em dockerfile

ENTRYPOINT ["/entrypoint.sh"]

no 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