Come impostare gli alias bash per i contenitori Docker in Dockerfile?

Sono nuovo in Docker. Ho scoperto che possiamo impostare le variabili d'ambiente usando l'istruzione ENV nel Dockerfile. Ma come si impostano gli alias bash per i comandi lunghi in Dockerfile?

Fondamentalmente come fai sempre, aggiungendolo all'utente .bashrc:

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

Come al solito questo funzionerà solo per le shell interattive:

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

Per le shell non interattive dovresti creare un piccolo script e inserirlo nel tuo percorso, cioè:

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

Se il tuo alias utilizza parametri (es. hi Jim-> hello Jim), aggiungi semplicemente "$@":

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

Per creare un alias di un comando esistente, potresti anche utilizzare ln -s:

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

Se vuoi usare gli alias solo in Dockerfile, ma non all'interno del container, il modo più breve è la ENVdichiarazione:

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

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

E per l'utilizzo in container come già descritto:

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

Il più delle volte utilizzo gli alias solo in fase di costruzione e non entro nei contenitori, quindi il primo esempio è più veloce, più chiaro e più semplice per l'uso quotidiano.

L'ho appena aggiunto al mio 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 all'interno del initbash_profile.shquale si aggiungono solo i miei alias personalizzati e non è necessario fornire il file .bashrc.

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

ha funzionato a meraviglia!

Un'altra opzione è usare semplicemente il "comando docker exec -it" dall'esterno del contenitore e usare semplicemente il tuo .bashrc o .bash_profile (come preferisci)

per esempio. docker exec -it docker_app_1 bash

Puoi usare l'entrypoint, ma non funzionerà per l'alias, nel tuo Dockerfile:

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

Il tuo entrypoint.sh

#!/bin/bash
set -e

function dev_run()
{

}

export -f dev_run

exec "$@"

(Copia / incolla veloce, scusa)

Penso che il modo più semplice sarebbe montare un file nel tuo contenitore contenente i tuoi alias e quindi specificare dove bash dovrebbe trovarlo:

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

Utilizzo del campione:

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

Ho utilizzato alcune delle soluzioni di cui sopra ma gli alias non vengono ancora riconosciuti.

Sto cercando di impostare gli alias e di utilizzarli sia nei passaggi successivi di Dockerfile che nel contenitore in fase di esecuzione.

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 soluzione per me era utilizzare le variabili ENV che contenevano i percorsi delle cartelle e quindi aggiungere l'eseguibile esatto. Avrei potuto usare anche ARG, ma per più dei miei scenari avevo bisogno degli alias sia nella fase di compilazione che successivamente nel runtime.

Ha usato le variabili ENV insieme a uno script bash che viene eseguito una volta che le dipendenze sono state postate e imposta la sorgente bash, imposta alcune altre variabili env e consente di eseguire il pipe attraverso ulteriori comandi.

Ecco una funzione Bash per avere i tuoi alias in ogni contenitore che usi in modo interattivo.

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
}

Passaggio richiesto prima:

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

1. modifica questo file ~ / .bash_aliases vi ~/.bash_aliases
2. fonte questo file ~ / .bash_aliases source ~/.bash_aliases
3. fatto.