¿Cómo establecer alias de bash para contenedores de Docker en Dockerfile?

Soy nuevo en Docker. Descubrí que podemos establecer variables de entorno usando la instrucción ENV en el Dockerfile. Pero, ¿cómo se establecen los alias de bash para los comandos largos en Dockerfile?

Básicamente, como siempre lo hace, al agregarlo al usuario .bashrc:

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

Como de costumbre, esto solo funcionará para shells interactivos:

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 no interactivos, debe crear un pequeño script y ponerlo en su ruta, es decir:

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

Si su alias usa parámetros (es decir, hi Jim-> hello Jim), simplemente agregue "$@":

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

Para crear un alias de un comando existente, también puede usar ln -s:

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

Si desea usar alias solo en Dockerfile, pero no dentro del contenedor, la forma más corta es la ENVdeclaración:

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

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

Y para usar en contenedor de la manera ya descrita:

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

La mayoría de las veces uso alias solo en la etapa de construcción y no entro en contenedores, por lo que el primer ejemplo es más rápido, más claro y más simple para el uso diario.

Acabo de agregar esto a mi 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"

y dentro del initbash_profile.shcual solo agrega mis alias personalizados y no es necesario obtener el archivo .bashrc.

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

funcionó un placer!

Otra opción es simplemente usar el "comando docker exec -it" desde fuera del contenedor y usar su propio .bashrc o .bash_profile (lo que prefiera)

p.ej. docker exec -it docker_app_1 bash

Puede usar el punto de entrada, pero no funcionará para alias, en su Dockerfile:

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

Tu entrypoint.sh

#!/bin/bash
set -e

function dev_run()
{

}

export -f dev_run

exec "$@"

(Copiar / pegar rápido, lo siento)

Creo que la forma más fácil sería montar un archivo en su contenedor que contenga sus alias, y luego especificar dónde debe encontrarlo bash:

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

Uso de muestra:

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

1. editar este archivo ~ / .bash_aliases vi ~/.bash_aliases
2. fuente de este archivo ~ / .bash_aliases source ~/.bash_aliases
3. hecho.

Usé algunas de las soluciones anteriores pero los alias aún no se reconocen.

Estoy tratando de establecer alias y usarlos en los pasos posteriores de Dockerfile y en el contenedor en tiempo de ejecución.

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;

La solución para mí fue usar variables ENV que contenían rutas de carpeta y luego agregar el ejecutable exacto. También podría haber usado ARG, pero para más de mis escenarios necesitaba los alias tanto en la etapa de compilación como más adelante en el tiempo de ejecución.

Se utilizaron las variables ENV junto con un script bash que se ejecuta una vez que las dependencias se han puesto en contacto y establece el origen de bash, establece algunas variables env más y permite que se canalicen más comandos.

Aquí hay una función Bash para tener sus alias en cada contenedor que use de forma interactiva.

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
}

Paso requerido antes:

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