Como definir aliases de bash para contêineres do docker no Dockerfile?

Eu sou novo no docker. Descobri que podemos definir variáveis ​​de ambiente usando a instrução ENV no Dockerfile. Mas como definir aliases de bash para comandos longos no Dockerfile?

Basicamente, como você sempre faz, adicionando-o ao .bashrc:

FROM foo
RUN echo 'alias hi="echo hello"' >> ~/.bashrc

Como de costume, isso só funcionará para shells interativos:

docker build -t test .
docker run -it --rm --entrypoint /bin/bash test hi
/bin/bash: hi: No such file or directory
docker run -it --rm test bash
$ hi
hello

Para shells não interativos, você deve criar um pequeno script e colocá-lo em seu caminho, ou seja:

RUN echo -e '#!/bin/bash\necho hello' > /usr/bin/hi && \
    chmod +x /usr/bin/hi

Se o seu alias usar parâmetros (ou seja, hi Jim-> hello Jim), basta adicionar "$@":

RUN echo -e '#!/bin/bash\necho hello "$@"' > /usr/bin/hi && \
    chmod +x /usr/bin/hi

Para criar um alias de um comando existente, também pode usar ln -s:

ln -s $(which <existing_command>) /usr/bin/<my_command>

Se você quiser usar aliases apenas no Dockerfile, mas não dentro do contêiner, o caminho mais curto é a ENVdeclaração:

ENV update='apt-get update -qq'
ENV install='apt-get install -qq'

RUN $update && $install apt-utils \
    curl \
    gnupg \
    python3.6

E para uso em container da forma já descrita:

 RUN printf '#!/bin/bash \n $(which apt-get) install -qq $@' > /usr/bin/install
 RUN chmod +x /usr/bin/install

Na maioria das vezes eu uso aliases apenas no estágio de construção e não entro em contêineres, então o primeiro exemplo é mais rápido, claro e simples para o uso diário.

Acabei de adicionar isso ao meu app.dockerfile

# setup aliases
ADD ./bashrc_alias.sh /usr/sbin/bashrc_alias.sh
ADD ./initbash_profile.sh /usr/sbin/initbash_profile
RUN chmod +x /usr/sbin/initbash_profile
RUN /bin/bash -C "/usr/sbin/initbash_profile"

e dentro do initbash_profile.shque apenas anexa meus aliases personalizados e não há necessidade de fornecer o arquivo .bashrc.

# add the bash aliases
cat /usr/sbin/bashrc_alias.sh >> ~/.bashrc

funcionou um deleite!

Outra opção é apenas usar o "comando docker exec -it" de fora do contêiner e apenas usar seu próprio .bashrc ou .bash_profile (o que você preferir)

por exemplo. docker exec -it docker_app_1 bash

Você pode usar o entrypoint, mas não funcionará para o alias no seu Dockerfile:

ADD dev/entrypoint.sh /opt/entrypoint.sh
ENTRYPOINT ["/opt/entrypoint.sh"]

Seu entrypoint.sh

#!/bin/bash
set -e

function dev_run()
{

}

export -f dev_run

exec "$@"

(Copiar / colar rápido, desculpe)

Acho que a maneira mais fácil seria montar um arquivo em seu contêiner contendo seus aliases e, em seguida, especificar onde o bash deve encontrá-lo:

docker run \
    -it \
    --rm \
    -v ~/.bash_aliases:/tmp/.bash_aliases \
    [image] \
    /bin/bash --init-file /tmp/.bash_aliases

Uso de amostra:

user@cobalt:~$ echo 'alias what="echo it works"' > my_aliases
user@cobalt:~$ docker run -it --rm -v ~/my_aliases:/tmp/my_aliases ubuntu:18.04 /bin/bash --init-file /tmp/my_aliases
root@565e4a1bdcc0:/# alias
alias what='echo it works'
root@565e4a1bdcc0:/# what
it works

Usei algumas das soluções acima, mas os aliases ainda não são reconhecidos.

Estou tentando definir aliases e usá-los nas etapas posteriores do Dockerfile e no contêiner em tempo de execução.

RUN echo "alias model-downloader='python3 ${MODEL_DL_PATH}/downloader.py'" >> ~/.bash_aliases && \
    echo "alias model-converter='python3 ${MODEL_DL_PATH}/converter.py'" >> ~/.bash_aliases && \
    source ~/.bash_aliases

# Download the model
RUN model-downloader --name $MODEL_NAME -o $MODEL_DIR --precisions $MODEL_PRECISION;

A solução para mim foi usar variáveis ​​ENV que continham caminhos de pasta e, em seguida, adicionar o executável exato. Eu poderia ter usado ARG também, mas para mais dos meus cenários, eu precisava dos aliases tanto no estágio de construção quanto mais tarde no tempo de execução.

Usou as variáveis ​​ENV em conjunto com um script bash que é executado uma vez que as dependências foram acionadas e definiu a origem do bash, definiu mais algumas variáveis ​​env e permite que mais comandos sejam transmitidos.

Esta é uma função Bash para ter seus aliases em cada contêiner que você usa interativamente.

ducker_it() {
    docker cp ~/bin/alias.sh "$1":/tmp
    docker exec -it "$1" /bin/bash -c "[[ ! -f /tmp/alias.sh.done ]] \
        && [[ -w /root/.bashrc ]] \
        && cat /tmp/alias.sh >> /root/.bashrc \
        && touch /tmp/alias.sh.done"
    docker exec -it "$1" /bin/bash
}

Etapa necessária antes:

grep ^alias ~/.zshrc > ~/bin/alias.sh

1. edite este arquivo ~ / .bash_aliases vi ~/.bash_aliases
2. fonte deste arquivo ~ / .bash_aliases source ~/.bash_aliases
3. feito.