Comment passer des arguments à Shell Script via l'exécution de docker

Je suis nouveau dans le monde des dockers. Je dois invoquer un script shell qui prend des arguments de ligne de commande via un conteneur docker. Ex: Mon script shell ressemble à:

#!bin/bash
echo $1

Dockerfile ressemble à ceci:

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

Je ne sais pas comment transmettre les arguments lors de l'exécution du conteneur

Utilisez le même file.sh

#!/bin/bash
echo $1

Créez l'image à l'aide du Dockerfile existant:

docker build -t test .

Exécutez l'image avec des arguments abcou xyzautre chose.

docker run -ti test /file.sh abc

docker run -ti test /file.sh xyz

avec ce script dans file.sh

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

et ça Dockerfile

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

tu devrais être capable de:

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

Avec Docker, la bonne façon de transmettre ce type d'informations consiste à utiliser des variables d'environnement.

Donc, avec le même Dockerfile, changez le script en

#!/bin/bash
echo $FOO

Après la construction, utilisez la commande docker suivante:

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

Il y a plusieurs choses qui interagissent ici:

1. docker run your_image arg1 arg2remplacera la valeur de CMDpar arg1 arg2. C'est un remplacement complet du CMD, sans lui ajouter plus de valeurs. C'est pourquoi vous voyez souvent docker run some_image /bin/bashexécuter un shell bash dans le conteneur.

2. Lorsque vous avez défini à la fois un ENTRYPOINT et une valeur CMD, docker démarre le conteneur en concaténant les deux et en exécutant cette commande concaténée. Donc, si vous définissez votre point d'entrée comme étant file.sh, vous pouvez maintenant exécuter le conteneur avec des arguments supplémentaires qui seront transmis en tant qu'arguments à file.sh.

3. Les points d'entrée et les commandes dans le menu fixe ont deux syntaxes, une syntaxe de chaîne qui lancera un shell et une syntaxe json qui exécutera un exec. Le shell est utile pour gérer des choses comme la redirection IO, l'enchaînement de plusieurs commandes (avec des choses comme &&), la substitution de variables, etc. un conteneur, c'est souvent la cause) et avec la concaténation d'un point d'entrée et d'une commande ensemble. Si vous définissez votre point d'entrée comme une chaîne, il s'exécuterait /bin/sh -c "file.sh", ce qui seul convient. Mais si vous avez également une commande définie comme une chaîne, vous verrez quelque chose comme /bin/sh -c "file.sh" /bin/sh -c "arg1 arg2"la commande lancée à l'intérieur de votre conteneur, pas si bon. Consultez le tableau ici pour en savoir plus sur l'interaction de ces deux options

4. L' -coption shell ne prend qu'un seul argument. Tout après qui se passé comme $1, $2, etc., à cet argument unique, mais pas dans un script shell intégré , sauf si vous avez passé explicitement les args. Ie /bin/sh -c "file.sh $1 $2" "arg1" "arg2"fonctionnerait, mais /bin/sh -c "file.sh" "arg1" "arg2"ne le ferait pas depuis file.shserait appelé sans argument.

En mettant tout cela ensemble, la conception commune est:

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

Et vous exécutez ensuite cela avec:

docker run your_image arg1 arg2

Il y a un peu plus de détails à ce sujet sur:

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

Ce que j'ai est un fichier de script qui exécute réellement les choses. Ce fichier script peut être relativement compliqué. Appelons cela "run_container". Ce script prend les arguments de la ligne de commande:

run_container p1 p2 p3

Un simple run_container pourrait être:

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

Ce que je veux faire, c'est qu'après "docker" ceci, je voudrais pouvoir démarrer ce conteneur avec les paramètres de la ligne de commande docker comme ceci:

docker run image_name p1 p2 p3

et faites exécuter le script run_container avec p1 p2 p3 comme paramètres.

Voici ma solution:

Dockerfile:

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

Si vous voulez l'exécuter à l'heure de construction:

CMD /bin/bash /file.sh arg1

si vous voulez l'exécuter à l'heure de l'exécution:

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

Puis dans le shell hôte

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

Une autre option...

Pour que cela fonctionne

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

dans dockerfile

ENTRYPOINT ["/entrypoint.sh"]

dans 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