Die Verwendung der Anweisung RUN in einer Dockerdatei mit 'source' funktioniert nicht

Habe ich ein Dockerfile, bin ich der Zusammenstellung zu installieren Vanille-python-Umgebung (in der ich die Installation einer app, aber zu einem späteren Zeitpunkt).

FROM ubuntu:12.04

# required to build certain python libraries
RUN apt-get install python-dev -y

# install pip - canonical installation instructions from pip-installer.org
# http://www.pip-installer.org/en/latest/installing.html
ADD https://bitbucket.org/pypa/setuptools/raw/bootstrap/ez_setup.py /tmp/ez_setup.py
ADD https://raw.github.com/pypa/pip/master/contrib/get-pip.py /tmp/get-pip.py
RUN python /tmp/ez_setup.py
RUN python /tmp/get-pip.py
RUN pip install --upgrade pip 

# install and configure virtualenv
RUN pip install virtualenv 
RUN pip install virtualenvwrapper
ENV WORKON_HOME ~/.virtualenvs
RUN mkdir -p $WORKON_HOME
RUN source /usr/local/bin/virtualenvwrapper.sh

Build läuft ok bis auf die Letzte Zeile, wo bekomme ich die folgende exception:

[previous steps 1-9 removed for clarity]
...
Successfully installed virtualenvwrapper virtualenv-clone stevedore
Cleaning up...
 ---> 1fc253a8f860
Step 10 : ENV WORKON_HOME ~/.virtualenvs
 ---> Running in 8b0145d2c80d
 ---> 0f91a5d96013
Step 11 : RUN mkdir -p $WORKON_HOME
 ---> Running in 9d2552712ddf
 ---> 3a87364c7b45
Step 12 : RUN source /usr/local/bin/virtualenvwrapper.sh
 ---> Running in c13a187261ec
/bin/sh: 1: source: not found

Wenn ich ls in diesem Verzeichnis (nur um zu testen, ob die vorherigen Schritte begangen wurden) ich kann sehen, dass die Dateien vorhanden sind wie erwartet:

$ docker run 3a87 ls /usr/local/bin
easy_install
easy_install-2.7
pip
pip-2.7
virtualenv
virtualenv-2.7
virtualenv-clone
virtualenvwrapper.sh
virtualenvwrapper_lazy.sh

Wenn ich es versuche läuft gerade die source Befehl bekomme ich die gleiche 'nicht gefunden' - Fehler wie oben. Wenn ich AUSFÜHREN einer interaktiven shell-Sitzung jedoch, source funktioniert:

$ docker run 3a87 bash
source
bash: line 1: source: filename argument required
source: usage: source filename [arguments]

Kann ich das Skript von hier, und dann fröhlich Zugang workonmkvirtualenv etc.

Habe ich getan einige Graben, und zunächst sah es aus, als wenn das problem liegen könnte, dass der Unterschied zwischen bash als Ubuntu login-shellund dash als Ubuntu system-shelldash nicht die Unterstützung der source Befehl.

Jedoch, die Antwort auf diese scheint zu sein, zu verwenden '.' statt sourceaber dies nur bewirkt, dass die Docker-runtime zu sprengen, mit einem go-Panik Ausnahme.

Was ist der beste Weg, ein shell-Skript von einem Dockerfile FÜHREN Sie die Anweisung zu bekommen, um diese (Uhr läuft aus der Standard-Basis-image für Ubuntu 12.04 LTS).

InformationsquelleAutor der Frage Hugo Rodger-Brown | 2013-12-17

183

RUN /bin/bash -c "source /usr/local/bin/virtualenvwrapper.sh"

InformationsquelleAutor der Antwort chobo
103

Ursprüngliche Antwort
```
FROM ubuntu:14.04
RUN rm /bin/sh && ln -s /bin/bash /bin/sh
```
Diese Arbeit sollte für jeden Ubuntu-docker Basis image. Ich in der Regel fügen Sie diese Zeile für jede Dockerfile ich Schreibe.

Bearbeiten, die von einem betroffenen Zuschauer

Wenn Sie möchten, um den Effekt von "verwenden bash statt sh während dieses gesamten Dockerfile", ohne verändern und möglicherweise schädlich* der OS im inneren des Behälters, kann man nur sagen Sie Ihre Absicht, Docker. Das geschieht etwa so:
```
SHELL ["/bin/bash", "-c"]
```
* Die möglichen Schäden, die viele - Skripte in Linux (auf einer frischen Ubuntu-Installation grep -rHInE '/bin/sh' / gibt über 2700 Ergebnisse) erwarten eine vollständig POSIX-shell /bin/sh. Die bash-shell ist nicht nur POSIX-plus extra gelieferten. Es gibt gelieferten (und mehr), die Verhalten sich völlig anders als die in POSIX. Ich unterstütze VOLL die Vermeidung von POSIX (und der Trugschluss, dass jedes Skript, dass du nicht den test auf einem anderen shell ist, zur Arbeit zu gehen, weil Sie denken, dass Sie vermieden basmisms) und nur mit bashism. Aber Sie tun das mit einer richtigen shebang in deinem Skript. Nicht durch ziehen der POSIX-shell aus dem gesamten OS. (Es sei denn, Sie haben Zeit, um zu überprüfen, alle 2700 plus-Skripte, die kommen mit Linux plus all diejenigen, die alle Pakete, die Sie installieren.)

Mehr detail in dieser Antwort weiter unten. https://stackoverflow.com/a/45087082/117471

InformationsquelleAutor der Antwort Anubhav Sinha

Ich hatte das gleiche problem und in der Ausführung pip-Installation im virtualenv ich hatte, um diesen Befehl zu verwenden:

RUN pip install virtualenv virtualenvwrapper
RUN mkdir -p /opt/virtualenvs
ENV WORKON_HOME /opt/virtualenvs
RUN /bin/bash -c "source /usr/local/bin/virtualenvwrapper.sh \
    && mkvirtualenv myapp \
    && workon myapp \
    && pip install -r /mycode/myapp/requirements.txt"

Ich hoffe, es hilft.

InformationsquelleAutor der Antwort Andrea Grandi

36

Einfachsten ist die Verwendung der Punkt-operator im Ort der Quelle, die die sh-entspricht der bash source Befehl:

Statt:
```
RUN source /usr/local/bin/virtualenvwrapper.sh
```
Verwenden:
```
RUN . /usr/local/bin/virtualenvwrapper.sh
```
InformationsquelleAutor der Antwort mixja
24

Überprüfen Sie die SHELL-Befehl. Die Standard-shell unter Linux ist ["/bin/sh", "-c"]
```
RUN "source file"      # translates to: RUN /bin/sh -c "source file"
```
Können Sie ändern der Standard-shell verwenden SHELL welche änderungen shell verwendet für nachfolgende RUN Anweisungen im Dockerfile
```
SHELL ["/bin/bash", "-c"]
```
Nun, die Standard-shell hat sich geändert und Sie müssen nicht explizit definieren, die in jedem RUN Anweisung
```
RUN "source file"    # now translates to: RUN /bin/bash -c "source file"
```
Zusätzlicher Hinweis: Sie könnten auch --login option starten einer login-shell. Dies bedeutet ~/.bachrc zum Beispiel würde gelesen werden, und Sie brauchen nicht zu Quelle es sich ausdrücklich vor, bevor Ihr den Befehl

InformationsquelleAutor der Antwort Ahmad Abdelghany
18

Aufbauend auf den Antworten auf dieser Seite möchte ich hinzufügen, dass Sie müssen sich bewusst sein, dass jede AUSFÜHRUNG der Anweisung wird unabhängig von den anderen mit /bin/sh -c und daher keine Umwelt vars, die normalerweise aus einer login-Shell.

Der beste Weg, den ich bis jetzt gefunden habe ist, um das Skript hinzuzufügen, um /etc/bash.bashrc und rufen Sie dann jedem Befehl als bash-login.
```
RUN echo "source /usr/local/bin/virtualenvwrapper.sh" >> /etc/bash.bashrc
RUN /bin/bash --login -c "your command"
```
Beispielsweise können Sie installieren und setup-virtualenvwrapper, erstellen Sie die virtuellen env, haben Sie es aktiviert, wenn Sie eine bash-login, und dann installieren Sie Ihre python-Module, die in diesem env:
```
RUN pip install virtualenv virtualenvwrapper
RUN mkdir -p /opt/virtualenvs
ENV WORKON_HOME /opt/virtualenvs
RUN echo "source /usr/local/bin/virtualenvwrapper.sh" >> /etc/bash.bashrc
RUN /bin/bash --login -c "mkvirtualenv myapp"
RUN echo "workon mpyapp" >> /etc/bash.bashrc
RUN /bin/bash --login -c "pip install ..."
```
Lesen Sie die Anleitung auf bash startup files hilft, zu verstehen, was gewonnen wird, wenn.

InformationsquelleAutor der Antwort TomDotTom
12

Wenn Sie das Andockfenster 1.12 oder neuer, verwenden Sie einfach SHELL !

Kurze Antwort:

allgemein:
```
SHELL ["/bin/bash", "-c"] 
```
python vituralenv:
```
SHELL ["/bin/bash", "-c", "source /usr/local/bin/virtualenvwrapper.sh"]
```
Lange Antwort:

vom https://docs.docker.com/engine/reference/builder/#/shell
```
SHELL ["executable", "parameters"]
```
Die SHELL-Anweisung können Sie die Standard-shell verwendet für die shell-form
Befehle außer Kraft gesetzt werden. Die Standard-shell unter Linux ist
["/bin/sh", "-c"], und unter Windows ist ["cmd", "/S", "/C"]. Die SHELL
Anweisung geschrieben werden müssen in JSON-form in einem Dockerfile.

Die SHELL-Anweisung ist besonders nützlich auf Windows, wo es
sind zwei Häufig verwendete und Recht unterschiedliche native shells: cmd und
powershell, als auch Alternative shells verfügbar, darunter sh.

Die SHELL-Anweisung kann mehrere Male angezeigt. Jede SCHALE
Anweisung überschreibt alle früheren SHELL-Anweisungen, und wirkt sich auf alle
die nachfolgenden Anweisungen. Zum Beispiel:
```
FROM microsoft/windowsservercore

# Executed as cmd /S /C echo default
RUN echo default

# Executed as cmd /S /C powershell -command Write-Host default
RUN powershell -command Write-Host default

# Executed as powershell -command Write-Host hello
SHELL ["powershell", "-command"]
RUN Write-Host hello

# Executed as cmd /S /C echo hello
SHELL ["cmd", "/S"", "/C"]
RUN echo hello
```
Den folgenden Anweisungen können beeinflusst werden durch die SHELL-Anweisung
wenn die shell-form, Sie ist in einem Dockerfile: AUSFÜHREN, CMD und
ENTRYPOINT.

Folgende Beispiel ist ein gemeinsames Muster festgestellt, die auf Windows kann
schlanker werden mithilfe der SHELL-Anweisung:
```
...
RUN powershell -command Execute-MyCmdlet -param1 "c:\foo.txt"
...
```
Den Befehl, die von docker werden:
```
cmd /S /C powershell -command Execute-MyCmdlet -param1 "c:\foo.txt"
```
Dies ist aus zwei Gründen nicht effizient. Erstens gibt es einen un-nötig
cmd.exe-Befehl-Prozessor (aka shell) aufgerufen wird. Zweitens, jede AUSFÜHRUNG
Anweisung in der shell-form erfordert eine zusätzliche powershell -Befehl
indem der Befehl.

Um diese effizienter zu gestalten, einer der beiden Mechanismen eingesetzt werden können.
Eine ist die Verwendung des JSON-form von " Befehl AUSFÜHREN wie:
```
...
RUN ["powershell", "-command", "Execute-MyCmdlet", "-param1 \"c:\\foo.txt\""]
...
```
Während der JSON-form ist eindeutig und nicht den un-nötig
cmd.exe-Datei, es erfordert mehr Ausführlichkeit durch doppelte Hochkommas und
Flucht. Die Alternative Methode ist die Verwendung der SHELL-Anweisung und
die shell-form, wodurch eine mehr Natürliche syntax für Windows-Benutzer,
vor allem, wenn in Kombination mit der escape parser-Richtlinie:
```
# escape=`

FROM microsoft/nanoserver
SHELL ["powershell","-command"]
RUN New-Item -ItemType Directory C:\Example
ADD Execute-MyCmdlet.ps1 c:\example\
RUN c:\example\Execute-MyCmdlet -sample 'hello world'
```
Ergibt:
```
PS E:\docker\build\shell> docker build -t shell .
Sending build context to Docker daemon 4.096 kB
Step 1/5 : FROM microsoft/nanoserver
 ---> 22738ff49c6d
Step 2/5 : SHELL powershell -command
 ---> Running in 6fcdb6855ae2
 ---> 6331462d4300
Removing intermediate container 6fcdb6855ae2
Step 3/5 : RUN New-Item -ItemType Directory C:\Example
 ---> Running in d0eef8386e97


    Directory: C:\


Mode                LastWriteTime         Length Name
----                -------------         ------ ----
d-----       10/28/2016  11:26 AM                Example


 ---> 3f2fbf1395d9
Removing intermediate container d0eef8386e97
Step 4/5 : ADD Execute-MyCmdlet.ps1 c:\example\
 ---> a955b2621c31
Removing intermediate container b825593d39fc
Step 5/5 : RUN c:\example\Execute-MyCmdlet 'hello world'
 ---> Running in be6d8e63fe75
hello world
 ---> 8e559e9bf424
Removing intermediate container be6d8e63fe75
Successfully built 8e559e9bf424
PS E:\docker\build\shell>
```
Die SHELL-Anweisung kann auch verwendet werden, um die Art und Weise ändern, in der ein
shell betreibt. Zum Beispiel, die Verwendung von SHELL cmd /S /C /V:ON/OFF auf
Windows, verzögerte umgebungsvariablenerweiterung Semantik sein könnte
geändert.

Den SHELL-Befehl kann auch verwendet werden, unter Linux soll eine Alternative
shell wie die zsh, csh, tcsh und andere.

Die SHELL-Funktion wurde Hinzugefügt im Andockfenster 1.12.
InformationsquelleAutor der Antwort Mithril
6

Laut Docker Dokumentation
Verwenden Sie eine andere shell, andere als '/bin/sh", verwenden Sie die exec-form übergehend in die gewünschte Schale. Zum Beispiel,
```
RUN ["/bin/bash", "-c", "echo hello"]
```
Sehen https://docs.docker.com/engine/reference/builder/#run

InformationsquelleAutor der Antwort Gianluca Casati
4

Laut https://docs.docker.com/engine/reference/builder/#run der Standard [Linux] shell für RUN ist /bin/sh -c. Sie scheinen zu erwarten, dass bashisms, so dass Sie verwenden die "exec " form" des RUN Angabe Ihrer shell.
```
RUN ["/bin/bash", "-c", "source /usr/local/bin/virtualenvwrapper.sh"]
```
Sonst, mit der "shell-form" LAUFEN und die Angabe einer anderen shell-Ergebnisse in verschachtelten Schalen.
```
# don't do this...
RUN /bin/bash -c "source /usr/local/bin/virtualenvwrapper.sh"
# because it is the same as this...
RUN ["/bin/sh", "-c", "/bin/bash" "-c" "source /usr/local/bin/virtualenvwrapper.sh"]
```
Wenn du mehr als 1 Befehl muss eine andere shell, die Sie Lesen sollten, https://docs.docker.com/engine/reference/builder/#shell und ändern Sie Ihre Standard-shell, indem Sie diesen, bevor Sie Ihre Befehle AUSFÜHREN:
```
SHELL ["/bin/sh", "-c"]
```
Hinweis: ich habe absichtlich die Tatsache ignoriert, dass es sinnlos ist, Quelle eine Schrift als die einzige Befehl, der in einen LAUF.

InformationsquelleAutor der Antwort Bruno Bronosky
3

Hatte ich auch Probleme im Laufenden source in einem Dockerfile

Läuft es bestens für den Bau von CentOS 6.6 Docker-container, aber es gab Probleme in der Debian-Container
```
RUN cd ansible && source ./hacking/env-setup
```
Dies ist, wie ich es angegangen ist, kann nicht werden, ein eleganter Weg, aber das ist was für mich gearbeitet
```
RUN echo "source /ansible/hacking/env-setup" >> /tmp/setup
RUN /bin/bash -C "/tmp/setup"
RUN rm -f /tmp/setup
```
InformationsquelleAutor der Antwort vikas027
2

Möchten Sie vielleicht zu laufen bash -v um zu sehen, was bezogen werden.

Ich würde Folgendes tun, anstatt zu spielen mit symlinks:

RUN echo "source /usr/local/bin/virtualenvwrapper.sh" >> /etc/bash.bashrc

InformationsquelleAutor der Antwort vimdude
1

Dies geschieht, weil source ist eine integrierte bash anstatt eine binäre irgendwo auf dem Dateisystem. Ist Ihre Absicht, für das Skript, das Sie suchen, zu ändern, den container hinterher?

InformationsquelleAutor der Antwort Paul Morie
0

Wenn Sie nur versuchen zu verwenden, pip zu installieren, etwas, das in der virtualenv, können Sie den PFAD ändern, env Blick in die virtualenv in den Ordner bin ersten

ENV PATH="/path/to/venv/bin:${PATH}"

Dann alle pip install Befehle, die Folgen im Dockerfile finden /Pfad/zu/venv/bin/pip-ersten und nutzen, die Installation in das virtualenv und nicht die system-python.

InformationsquelleAutor der Antwort shadfc

Landete ich setzen meinen env Zeug in .profile mutierte SHELL etwas wie

SHELL ["/bin/bash", "-c", "-l"]

# Install ruby version specified in .ruby-version
RUN rvm install $(<.ruby-version)

# Install deps
RUN rvm use $(<.ruby-version) && gem install bundler && bundle install

CMD rvm use $(<.ruby-version) && ./myscript.rb

InformationsquelleAutor der Antwort mattexx

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

Ursprüngliche Antwort

Bearbeiten, die von einem betroffenen Zuschauer

Kurze Antwort:

Lange Antwort: