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


85

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?


Se han considerado los alias esencialmente en desuso por un muy largo tiempo. Usa una función. Ya no hay ninguna necesidad de jamás utilizar un alias. ¿Cómo es que estos enfoques de finales de los 80 persisten durante tanto tiempo?
William Pursell

19
Porque son convenientes y simples, por supuesto.
Arthur

13
@WilliamPursell Quizás deberías explicar cómo usar funciones en su lugar.
Eric Dela Cruz

2
Los alias son simples, convenientes, frágiles y propensos a errores. Las funciones son igualmente fáciles de usar, pero brindan más flexibilidad y robustez. Hay muchos recursos disponibles sobre cómo usarlos.
William Pursell

Respuestas:


141

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

Gracias por esto, ¿puede proporcionar un ejemplo de shell no interactivo? Estaba buscando ENTRYPOINT y CMD para resolver esto
c24b

5
Bash alias solo funciona en shells interactivos. Simplemente crea un pequeño script de shell y ponlo en tu ruta, el mismo efecto que un alias. Actualizó la respuesta con un ejemplo simple.
Erik Dannenberg

1
Nota: desde stackoverflow.com/a/8467449 debería utilizar printf en lugar de echo para garantizar un comportamiento más consistente. Entonces printf '#! / Bin / bash \ necho hello'> / usr / bin / hi chmod + x / usr / bin / hi
barraq

2
Me encanta la idea del script de shell. Estaba buscando agregar alias pero esto es mucho mejor. Gracias.
Blizz

3
Debe utilizar "$ @" en lugar de $ * para el escape de varios argumentos. Ver unix.stackexchange.com/questions/248464/…
gnou

14

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

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


6
Yo no llamaría a esto un alias ... es un enlace suave / enlace simbólico. La conveniencia de los alias es que puede pasar parámetros al comando como lo alias ll='ls -lh'que no es posible con los enlaces simbólicos.
qwertz

3

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.


2

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


1

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)


Preste atención a que alguna imagen de Docker ya podría anular el punto de entrada predeterminado (como la imagen base de phusion).
Thomas Decaux

1

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

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

Esto está bien cada vez que gira el contenedor de la ventana acoplable, pero los alias no se mantendrán la próxima vez. si no le importa volver a agregarlos cada vez que esta solución está bien.
mikoop

0

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.


Cada RUNinstrucción se ejecuta en un nuevo shell, por lo que en su ejemplo, el archivo de alias ya no se carga cuando intenta usar el alias.
Erik Dannenberg

100% @ErikDannenberg, gracias por el comentario y también por recordarme que necesito publicar una actualización de esto. Descubrí una solución y es muy similar a lo que sugirió.
Alanionita

0

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
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.