Docker/Image/best-practice/Dockerfile: Unterschied zwischen den Versionen

Aus Foxwiki
Wechseln zu:Navigation, Suche
Keine Bearbeitungszusammenfassung
 
(24 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 1: Zeile 1:
== Anweisungen für die Dockerfile-Datei ==
<noinclude>
Befolgen Sie diese Empfehlungen zur korrekten Verwendung der [https://docs.docker.com/reference/dockerfile/ Dockerfile-Anweisungen], um ein effizientes und wartungsfreundliches Dockerfile zu erstellen.
<!--
* https://docs.docker.com/build/building/best-practices/#dockerfile-instructions
----
{{Navigation|<zurück>|<nachste>}}
{{Navigation|BSI/200-3|BSI/200-3/Einleitung/Beispiele}}
----
-->
'''{{BASEPAGENAME}}''' - Empfehlungen zur Verwendung von Dockerfile-Anweisungen  
</noinclude>


; Tipp
== Beschreibung ==
: Um die Linting-Funktionen, die Code-Navigation und das Scannen Ihrer Dockerfiles auf Sicherheitslücken in Visual Studio Code zu verbessern, sehen Sie sich die Erweiterung [https://marketplace.visualstudio.com/items?itemName=docker.docker Docker DX] an
; Effiziente und wartungsfreundliche Dockerfiles erstellen
Empfehlungen zur korrekten Verwendung der Dockerfile-Anweisungen


=== VON ===
== FROM ==
* https://docs.docker.com/build/building/best-practices/#from
Verwenden Sie nach Möglichkeit aktuelle offizielle Images als Grundlage für Ihre Images
* Docker empfiehlt das [https://hub.docker.com/_/alpine/ Alpine-Image], da es streng kontrolliert wird und eine geringe Größe aufweist (unter 6 MB), dabei aber dennoch eine vollständige Linux-Distribution darstellt


Verwenden Sie nach Möglichkeit aktuelle offizielle Images als Grundlage für Ihre Images. Docker empfiehlt das [https://hub.docker.com/_/alpine/ Alpine-Image], da es streng kontrolliert wird und eine geringe Größe aufweist (unter 6 MB), dabei aber dennoch eine vollständige Linux-Distribution darstellt.
; Links
# https://docs.docker.com/reference/dockerfile/#from Dockerfile-Referenz zur FROM-Anweisung
# https://docs.docker.com/build/building/best-practices/#from


Weitere Informationen zur <tt>FROM</tt>-Anweisung finden Sie unter [https://docs.docker.com/reference/dockerfile/#from Dockerfile-Referenz zur FROM-Anweisung].
== LABEL ==
Sie können Ihrem Bild Beschriftungen hinzufügen, um Bilder nach Projekten zu ordnen, Lizenzinformationen zu erfassen, die Automatisierung zu unterstützen oder aus anderen Gründen
* Fügen Sie für jede Beschriftung eine Zeile ein, die mit <tt>LABEL</tt> beginnt und ein oder mehrere Schlüssel-Wert-Paare enthält
* Die folgenden Beispiele zeigen die verschiedenen zulässigen Formate
* Erläuternde Kommentare sind direkt im Text enthalten


=== LABEL ===
Zeichenketten mit Leerzeichen müssen in Anführungszeichen gesetzt oder die Leerzeichen müssen mit Escape-Zeichen versehen werden
* https://docs.docker.com/build/building/best-practices/#label
* Innere Anführungszeichen (<tt>"</tt>) müssen ebenfalls mit Escape-Zeichen versehen werden


Sie können Ihrem Bild Beschriftungen hinzufügen, um Bilder nach Projekten zu ordnen, Lizenzinformationen zu erfassen, die Automatisierung zu unterstützen oder aus anderen Gründen. Fügen Sie für jede Beschriftung eine Zeile ein, die mit <tt>LABEL</tt> beginnt und ein oder mehrere Schlüssel-Wert-Paare enthält. Die folgenden Beispiele zeigen die verschiedenen zulässigen Formate. Erläuternde Kommentare sind direkt im Text enthalten.
; Beispiel


Zeichenketten mit Leerzeichen müssen in Anführungszeichen gesetzt oder die Leerzeichen müssen mit Escape-Zeichen versehen werden. Innere Anführungszeichen (<tt>"</tt>) müssen ebenfalls mit Escape-Zeichen versehen werden. Zum Beispiel:
# Set one or more individual labels
[https://docs.docker.com/reference/dockerfile/#label LABEL] com.example.version="0.0.1-beta"
[https://docs.docker.com/reference/dockerfile/#label LABEL] vendor1="ACME Incorporated"
[https://docs.docker.com/reference/dockerfile/#label LABEL] vendor2=ZENITH\ Incorporated
[https://docs.docker.com/reference/dockerfile/#label LABEL] com.example.release-date="2015-02-12"
[https://docs.docker.com/reference/dockerfile/#label LABEL] com.example.version.is-production=""


# Set one or more individual labels
Ein Image kann mehr als ein Label haben
[https://docs.docker.com/reference/dockerfile/#label LABEL] com.example.version="0.0.1-beta"
* Vor Docker 1.10 wurde empfohlen, alle Labels in einer einzigen <tt>LABEL</tt>-Anweisung zusammenzufassen, um zu verhindern, dass zusätzliche Layer erstellt werden
[https://docs.docker.com/reference/dockerfile/#label LABEL] vendor1="ACME Incorporated"
* Dies ist nun nicht mehr erforderlich, die Zusammenfassung von Labels wird jedoch weiterhin unterstützt
[https://docs.docker.com/reference/dockerfile/#label LABEL] vendor2=ZENITH\ Incorporated
[https://docs.docker.com/reference/dockerfile/#label LABEL] com.example.release-date="2015-02-12"
[https://docs.docker.com/reference/dockerfile/#label LABEL] com.example.version.is-production=""


Ein Image kann mehr als ein Label haben. Vor Docker 1.10 wurde empfohlen, alle Labels in einer einzigen <tt>LABEL</tt>-Anweisung zusammenzufassen, um zu verhindern, dass zusätzliche Layer erstellt werden. Dies ist nun nicht mehr erforderlich, die Zusammenfassung von Labels wird jedoch weiterhin unterstützt. Beispiel:
; Beispiel
 
# Set multiple labels on one line
# Set multiple labels on one line
[https://docs.docker.com/reference/dockerfile/#label LABEL] com.example.version="0.0.1-beta" com.example.release-date="2015-02-12"
[https://docs.docker.com/reference/dockerfile/#label LABEL] com.example.version="0.0.1-beta" com.example.release-date="2015-02-12"


Das obige Beispiel lässt sich auch wie folgt schreiben:
Das obige Beispiel lässt sich auch wie folgt schreiben:
 
# Set multiple labels at once, using line-continuation characters to break long lines
# Set multiple labels at once, using line-continuation characters to break long lines
[https://docs.docker.com/reference/dockerfile/#label LABEL] vendor=ACME\ Incorporated \
[https://docs.docker.com/reference/dockerfile/#label LABEL] vendor=ACME\ Incorporated \
       com.example.is-beta= \
       com.example.is-beta= \
       com.example.is-production="" \
       com.example.is-production="" \
Zeile 41: Zeile 55:
       com.example.release-date="2015-02-12"
       com.example.release-date="2015-02-12"


Siehe [https://docs.docker.com/engine/manage-resources/labels/ Objekt-Labels verstehen] für Richtlinien zu zulässigen Label-Schlüsseln und -Werten. Informationen zum Abfragen von Labels finden Sie in den Abschnitten zum Filtern unter [https://docs.docker.com/engine/manage-resources/labels/#manage-labels-on-objects Labels für Objekte verwalten]. Siehe auch [https://docs.docker.com/reference/dockerfile/#label LABEL] in der Dockerfile-Referenz.
Siehe [https://docs.docker.com/engine/manage-resources/labels/ Objekt-Labels verstehen] für Richtlinien zu zulässigen Label-Schlüsseln und -Werten
* Informationen zum Abfragen von Labels finden Sie in den Abschnitten zum Filtern unter [https://docs.docker.com/engine/manage-resources/labels/#manage-labels-on-objects Labels für Objekte verwalten]
* Siehe auch [https://docs.docker.com/reference/dockerfile/#label LABEL] in der Dockerfile-Referenz


=== RUN ===
; Links
* https://docs.docker.com/build/building/best-practices/#run
* https://docs.docker.com/build/building/best-practices/#label
 
Teilen Sie lange oder komplexe <tt>RUN</tt>-Anweisungen auf mehrere Zeilen auf, getrennt durch Backslashes, um Ihr Dockerfile lesbarer, verständlicher und wartbarer zu machen.


Beispielsweise können Sie Befehle mit dem Operator <tt>&&</tt> verketten und Escape-Zeichen verwenden, um lange Befehle in mehrere Zeilen aufzuteilen.
== RUN ==
Teilen Sie lange oder komplexe <tt>RUN</tt>-Anweisungen auf mehrere Zeilen auf
* getrennt durch Backslashes
* Dockerfile lesbarer, verständlicher und wartbarer zu machen


[https://docs.docker.com/reference/dockerfile/#run RUN] apt-get update && apt-get install -y --no-install-recommends \
Befehle können mit dem Operator <tt>&&</tt> verkettet werden und Escape-Zeichen verwenden, um lange Befehle in mehrere Zeilen aufzuteilen
[https://docs.docker.com/reference/dockerfile/#run RUN] apt-get update && apt-get install -y --no-install-recommends \
     package-bar \
     package-bar \
     package-baz \
     package-baz \
     package-foo
     package-foo


Standardmäßig dient der Backslash als Escape-Zeichen für ein Zeilenumbruchzeichen, aber du kannst dies mit der [https://docs.docker.com/reference/dockerfile/#escape escape-Direktive] ändern.
Standardmäßig dient der Backslash als Escape-Zeichen für ein Zeilenumbruchzeichen, aber du kannst dies mit der [https://docs.docker.com/reference/dockerfile/#escape escape-Direktive] ändern


; Here-Dokumente
Sie können auch Here-Dokumente verwenden, um mehrere Befehle auszuführen, ohne sie mit einem Pipeline-Operator zu verketten:
Sie können auch Here-Dokumente verwenden, um mehrere Befehle auszuführen, ohne sie mit einem Pipeline-Operator zu verketten:
[https://docs.docker.com/reference/dockerfile/#run RUN]
  <<EOF
  <<EOF
  apt-get update
  apt-get update
Zeile 68: Zeile 85:
  EOF
  EOF


Weitere Informationen
; Links
: zu <tt>RUN</tt> finden Sie in der [https://docs.docker.com/reference/dockerfile/#run Dockerfile-Referenz zur RUN-Anweisung].
# https://docs.docker.com/build/building/best-practices/#run
 
# [https://docs.docker.com/reference/dockerfile/#run Dockerfile-Referenz zur RUN-Anweisung]
==== apt-get ====
* https://docs.docker.com/build/building/best-practices/#apt-get


Ein häufiger Anwendungsfall für <tt>RUN</tt>-Anweisungen in Debian-basierten Images ist die Installation von Software mithilfe von <tt>apt-get</tt>. Da <tt>apt-get</tt> Pakete installiert, weist der Befehl <tt>RUN apt-get</tt> einige nicht intuitiv erscheinende Verhaltensweisen auf, auf die man achten sollte.
=== apt-get ===
Ein häufiger Anwendungsfall für <tt>RUN</tt>-Anweisungen in Debian-basierten Images ist die Installation von Software mithilfe von <tt>apt-get</tt>
* Da <tt>apt-get</tt> Pakete installiert, weist der Befehl <tt>RUN apt-get</tt> einige nicht intuitiv erscheinende Verhaltensweisen auf, auf die man achten sollte


Kombinieren Sie <tt>RUN apt-get update</tt> immer mit <tt>apt-get install</tt> in derselben <tt>RUN</tt>-Anweisung.
Kombinieren Sie <tt>RUN apt-get update</tt> immer mit <tt>apt-get install</tt> in derselben <tt>RUN</tt>-Anweisung


; Beispiel
; Beispiel
* [https://docs.docker.com/reference/dockerfile/#run RUN]
  apt-get update && apt-get install -y --no-install-recommends \
  apt-get update && apt-get install -y --no-install-recommends \
     package-bar \
     package-bar \
Zeile 86: Zeile 101:
     package-foo
     package-foo


Die alleinige Verwendung von <tt>apt-get update</tt> in einer <tt>RUN</tt>-Anweisung führt zu Problemen mit dem Cache und dazu, dass nachfolgende <tt>apt-get install</tt>-Anweisungen fehlschlagen. Dieses Problem tritt beispielsweise im folgenden Dockerfile auf:
Die alleinige Verwendung von <tt>apt-get update</tt> in einer <tt>RUN</tt>-Anweisung führt zu Problemen mit dem Cache und dazu, dass nachfolgende <tt>apt-get install</tt>-Anweisungen fehlschlagen
 
* Dieses Problem tritt beispielsweise im folgenden Dockerfile auf:
# syntax=docker/dockerfile:1


# syntax=docker/dockerfile:1
  [https://docs.docker.com/reference/dockerfile/#from FROM] ubuntu:22.04
  [https://docs.docker.com/reference/dockerfile/#from FROM] ubuntu:22.04
  [https://docs.docker.com/reference/dockerfile/#run RUN] apt-get update
  [https://docs.docker.com/reference/dockerfile/#run RUN] apt-get update
  [https://docs.docker.com/reference/dockerfile/#run RUN] apt-get install -y --no-install-recommends curl
  [https://docs.docker.com/reference/dockerfile/#run RUN] apt-get install -y --no-install-recommends curl


Nach dem Erstellen des Images befinden sich alle Layer im Docker-Cache. Angenommen, Sie ändern später <tt>apt-get install</tt>, indem Sie ein zusätzliches Paket hinzufügen, wie im folgenden Dockerfile gezeigt:
Nach dem Erstellen des Images befinden sich alle Layer im Docker-Cache
* Angenommen, Sie ändern später <tt>apt-get install</tt>, indem Sie ein zusätzliches Paket hinzufügen, wie im folgenden Dockerfile gezeigt:


# syntax=docker/dockerfile:1
# syntax=docker/dockerfile:1
[https://docs.docker.com/reference/dockerfile/#from FROM] ubuntu:22.04
[https://docs.docker.com/reference/dockerfile/#run RUN] apt-get update
[https://docs.docker.com/reference/dockerfile/#run RUN] apt-get install -y --no-install-recommends curl nginx


[https://docs.docker.com/reference/dockerfile/#from FROM] ubuntu:22.04
Docker betrachtet die ursprünglichen und die geänderten Anweisungen als identisch und verwendet den Cache aus den vorherigen Schritten erneut
[https://docs.docker.com/reference/dockerfile/#run RUN] apt-get update
* Infolgedessen wird der Befehl <tt>apt-get update</tt> nicht ausgeführt, da der Build die zwischengespeicherte Version verwendet
[https://docs.docker.com/reference/dockerfile/#run RUN] apt-get install -y --no-install-recommends curl nginx
* Da der Befehl <tt>apt-get update</tt> nicht ausgeführt wird, kann es vorkommen, dass Ihr Build eine veraltete Version der Pakete <tt>curl</tt> und <tt>nginx</tt> erhält


Docker betrachtet die ursprünglichen und die geänderten Anweisungen als identisch und verwendet den Cache aus den vorherigen Schritten erneut. Infolgedessen wird der Befehl <tt>apt-get update</tt> nicht ausgeführt, da der Build die zwischengespeicherte Version verwendet. Da der Befehl <tt>apt-get update</tt> nicht ausgeführt wird, kann es vorkommen, dass Ihr Build eine veraltete Version der Pakete <tt>curl</tt> und <tt>nginx</tt> erhält.
Mit <tt>RUN apt-get update && apt-get install -y --no-install-recommends</tt> stellen Sie sicher, dass Ihr Dockerfile die neuesten Paketversionen installiert, ohne dass weitere Programmierarbeiten oder manuelle Eingriffe erforderlich sind
* Diese Technik wird als „Cache Busting“ bezeichnet
* Sie können Cache Busting auch erreichen, indem Sie eine bestimmte Paketversion angeben
* Dies wird als „Version Pinning“ bezeichnet


Mit <tt>RUN apt-get update && apt-get install -y --no-install-recommends</tt> stellen Sie sicher, dass Ihr Dockerfile die neuesten Paketversionen installiert, ohne dass weitere Programmierarbeiten oder manuelle Eingriffe erforderlich sind. Diese Technik wird als „Cache Busting“ bezeichnet. Sie können Cache Busting auch erreichen, indem Sie eine bestimmte Paketversion angeben. Dies wird als „Version Pinning“ bezeichnet. Beispiel:
; Beispiel
 
[https://docs.docker.com/reference/dockerfile/#run RUN] apt-get update && apt-get install -y --no-install-recommends \
[https://docs.docker.com/reference/dockerfile/#run RUN] apt-get update && apt-get install -y --no-install-recommends \
     package-bar \
     package-bar \
     package-baz \
     package-baz \
     package-foo=1.3.*
     package-foo=1.3.*


Durch die Versionsfestlegung wird der Build dazu gezwungen, eine bestimmte Version abzurufen, unabhängig davon, was sich im Cache befindet. Diese Technik kann zudem Fehler reduzieren, die durch unerwartete Änderungen an erforderlichen Paketen verursacht werden.
Durch die Versionsfestlegung wird der Build dazu gezwungen, eine bestimmte Version abzurufen, unabhängig davon, was sich im Cache befindet
* Diese Technik kann zudem Fehler reduzieren, die durch unerwartete Änderungen an erforderlichen Paketen verursacht werden


Im Folgenden finden Sie einen korrekt formatierten <tt>RUN</tt>-Befehl, der alle <tt>apt-get</tt>- Empfehlungen veranschaulicht.
Im Folgenden finden Sie einen korrekt formatierten <tt>RUN</tt>-Befehl, der alle <tt>apt-get</tt>- Empfehlungen veranschaulicht
* [https://docs.docker.com/reference/dockerfile/#run RUN]


[https://docs.docker.com/reference/dockerfile/#run RUN]
  apt-get update && apt-get install -y --no-install-recommends \
  apt-get update && apt-get install -y --no-install-recommends \
     aufs-tools \
     aufs-tools \
Zeile 131: Zeile 153:
     && rm -rf /var/lib/apt/lists/*
     && rm -rf /var/lib/apt/lists/*


Das <tt>s3cmd</tt>-Argument gibt eine Version <tt>1.1.*</tt> an. Wenn für das Image zuvor eine ältere Version verwendet wurde, führt die Angabe der neuen Version zu einem Cache-Bust von <tt>apt-get update</tt> und stellt sicher, dass die neue Version installiert wird. Die Auflistung der Pakete in jeder Zeile kann zudem Fehler durch doppelte Paketinstallationen verhindern.
Das <tt>s3cmd</tt>-Argument gibt eine Version <tt>1.1.*</tt> an
* Wenn für das Image zuvor eine ältere Version verwendet wurde, führt die Angabe der neuen Version zu einem Cache-Bust von <tt>apt-get update</tt> und stellt sicher, dass die neue Version installiert wird
* Die Auflistung der Pakete in jeder Zeile kann zudem Fehler durch doppelte Paketinstallationen verhindern


Wenn Sie zudem den apt-Cache durch Löschen von <tt>/var/lib/apt/lists</tt> bereinigen, verringert sich die Image-Größe, da der apt-Cache nicht in einer Layer gespeichert wird. Da die <tt>RUN</tt>-Anweisung mit <tt>apt-get update</tt> beginnt, wird der Paket-Cache immer vor <tt>apt-get install</tt> aktualisiert.
Wenn Sie zudem den apt-Cache durch Löschen von <tt>/var/lib/apt/lists</tt> bereinigen, verringert sich die Image-Größe, da der apt-Cache nicht in einer Layer gespeichert wird
* Da die <tt>RUN</tt>-Anweisung mit <tt>apt-get update</tt> beginnt, wird der Paket-Cache immer vor <tt>apt-get install</tt> aktualisiert


Offizielle Debian- und Ubuntu-Images führen [https://github.com/debuerreotype/debuerreotype/blob/c9542ab785e72696eb2908a6dbc9220abbabef39/scripts/debuerreotype-minimizing-config#L87-L109 automatisch apt-get clean] aus, sodass ein expliziter Aufruf nicht erforderlich ist.
Offizielle Debian- und Ubuntu-Images führen [https://github.com/debuerreotype/debuerreotype/blob/c9542ab785e72696eb2908a6dbc9220abbabef39/scripts/debuerreotype-minimizing-config#L87-L109 automatisch apt-get clean] aus, sodass ein expliziter Aufruf nicht erforderlich ist


==== Pipes ====
; Links
* https://docs.docker.com/build/building/best-practices/#using-pipes Verwendung von
* https://docs.docker.com/build/building/best-practices/#apt-get


=== Pipes ===
; Verwendung von Pipes
Einige <tt>RUN</tt>-Befehle setzen voraus, dass die Ausgabe eines Befehls mithilfe des Pipe-Zeichens (<tt>|</tt>) an einen anderen Befehl weitergeleitet werden kann, wie im folgenden Beispiel gezeigt:
Einige <tt>RUN</tt>-Befehle setzen voraus, dass die Ausgabe eines Befehls mithilfe des Pipe-Zeichens (<tt>|</tt>) an einen anderen Befehl weitergeleitet werden kann, wie im folgenden Beispiel gezeigt:
* [https://docs.docker.com/reference/dockerfile/#run RUN]
  wget -O - https://some.site | wc -l > /number
  wget -O - https://some.site | wc -l > /number


Docker führt diese Befehle mit dem Interpreter <tt>/bin/sh -c</tt> aus, der zur Feststellung des Erfolgs lediglich den Exit-Code der letzten Operation in der Pipe auswertet. Im obigen Beispiel ist dieser Build-Schritt erfolgreich und erzeugt ein neues Image, solange der Befehl <tt>wc -l</tt> erfolgreich ist, selbst wenn der Befehl <tt>wget</tt> fehlschlägt.
Docker führt diese Befehle mit dem Interpreter <tt>/bin/sh -c</tt> aus, der zur Feststellung des Erfolgs lediglich den Exit-Code der letzten Operation in der Pipe auswertet
* Im obigen Beispiel ist dieser Build-Schritt erfolgreich und erzeugt ein neues Image, solange der Befehl <tt>wc -l</tt> erfolgreich ist, selbst wenn der Befehl <tt>wget</tt> fehlschlägt


Wenn Sie möchten, dass der Befehl aufgrund eines Fehlers in einer beliebigen Phase der Pipe fehlschlägt, fügen Sie <tt>set -o pipefail &&</tt> am Anfang ein, um sicherzustellen, dass ein unerwarteter Fehler verhindert, dass der Build versehentlich erfolgreich abgeschlossen wird.
Wenn Sie möchten, dass der Befehl aufgrund eines Fehlers in einer beliebigen Phase der Pipe fehlschlägt, fügen Sie <tt>set -o pipefail &&</tt> am Anfang ein, um sicherzustellen, dass ein unerwarteter Fehler verhindert, dass der Build versehentlich erfolgreich abgeschlossen wird


; Beispiel
; Beispiel
* [https://docs.docker.com/reference/dockerfile/#run RUN]
  set -o pipefail && wget -O - https://some.site | wc -l > /number
  set -o pipefail && wget -O - https://some.site | wc -l > /number


; Beispiel
; Beispiel
* [https://docs.docker.com/reference/dockerfile/#run RUN]
  ["/bin/bash", "-c", "set -o pipefail && wget -O - https://some.site | wc -l > /number"]
  ["/bin/bash", "-c", "set -o pipefail && wget -O - https://some.site | wc -l > /number"]


=== CMD ===
; Links
* https://docs.docker.com/build/building/best-practices/#cmd
* [https://docs.docker.com/build/building/best-practices/#using-pipes Verwendung von Pipes]
Der Befehl <tt>CMD</tt> sollte verwendet werden, um die in Ihrem Image enthaltene Software zusammen mit etwaigen Argumenten auszuführen. <tt>CMD</tt> sollte fast immer in der Form <tt>CMD ["ausführbare Datei", "Parameter1", "Parameter2"]</tt> verwendet werden. Wenn das Image also für einen Dienst wie Apache und Rails bestimmt ist, würden Sie beispielsweise <tt>CMD ["apache2","-DFOREGROUND"]</tt> ausführen. Tatsächlich wird diese Form des Befehls für jedes dienstbasierte Image empfohlen.
* [https://docs.docker.com/reference/dockerfile/#run RUN]
 
In den meisten anderen Fällen sollte <tt>CMD</tt> eine interaktive Shell erhalten, wie beispielsweise bash, Python oder Perl. Zum Beispiel <tt>CMD ["perl", "-de0"]</tt>, <tt>CMD ["python"]</tt> oder <tt>CMD ["php", "-a"]</tt>. Wenn Sie diese Form verwenden, bedeutet das, dass Sie bei der Ausführung von beispielsweise <tt>docker run -it python</tt> direkt in eine einsatzbereite Shell gelangen. <tt>CMD</tt> sollte nur selten in der Form <tt>CMD ["param", "param"]</tt> in Verbindung mit [https://docs.docker.com/reference/dockerfile/#entrypoint ENTRYPOINT] verwendet werden, es sei denn, Sie und Ihre erwarteten Benutzer sind bereits gut mit der Funktionsweise von <tt>ENTRYPOINT</tt> vertraut.


Weitere Informationen zu <tt>CMD</tt> finden Sie in der [https://docs.docker.com/reference/dockerfile/#cmd Dockerfile-Referenz zur CMD-Anweisung].
== CMD ==
Der Befehl <tt>CMD</tt> sollte verwendet werden, um die in Ihrem Image enthaltene Software zusammen mit etwaigen Argumenten auszuführen
* <tt>CMD</tt> sollte fast immer in der Form <tt>CMD ["ausführbare Datei", "Parameter1", "Parameter2"]</tt> verwendet werden
* Wenn das Image also für einen Dienst wie Apache und Rails bestimmt ist, würden Sie beispielsweise <tt>CMD ["apache2","-DFOREGROUND"]</tt> ausführen
* Tatsächlich wird diese Form des Befehls für jedes dienstbasierte Image empfohlen


=== EXPOSE ===
In den meisten anderen Fällen sollte <tt>CMD</tt> eine interaktive Shell erhalten, wie bash, Python oder Perl
* https://docs.docker.com/build/building/best-practices/#expose
* Zum Beispiel <tt>CMD ["perl", "-de0"]</tt>, <tt>CMD ["python"]</tt> oder <tt>CMD ["php", "-a"]</tt>
* Wenn Sie diese Form verwenden, bedeutet das, dass Sie bei der Ausführung von beispielsweise <tt>docker run -it python</tt> direkt in eine einsatzbereite Shell gelangen. <tt>CMD</tt> sollte nur selten in der Form <tt>CMD ["param", "param"]</tt> in Verbindung mit [https://docs.docker.com/reference/dockerfile/#entrypoint ENTRYPOINT] verwendet werden, es sei denn, Sie und Ihre erwarteten Benutzer sind bereits gut mit der Funktionsweise von <tt>ENTRYPOINT</tt> vertraut


Die Anweisung <tt>EXPOSE</tt> gibt die Ports an, auf denen ein Container auf Verbindungen wartet. Daher sollten Sie den gängigen, herkömmlichen Port für Ihre Anwendung verwenden. Beispielsweise würde ein Image, das den Apache-Webserver enthält, <tt>EXPOSE 80</tt> verwenden, während ein Image, das MongoDB enthält, <tt>EXPOSE 27017</tt> verwenden würde und so weiter.
; Links
# [https://docs.docker.com/reference/dockerfile/#cmd Dockerfile-Referenz zur CMD-Anweisung]
# https://docs.docker.com/build/building/best-practices/#cmd


Für den externen Zugriff können Ihre Benutzer den Befehl <tt>docker run</tt> mit einem Flag ausführen, das angibt, wie der angegebene Port auf einen Port ihrer Wahl abgebildet werden soll. Für die Verknüpfung von Containern stellt Docker Umgebungsvariablen für den Pfad vom Zielcontainer zurück zum Quellcontainer bereit (zum Beispiel <tt>MYSQL_PORT_3306_TCP</tt>).
== EXPOSE ==
Die Anweisung <tt>EXPOSE</tt> gibt die Ports an, auf denen ein Container auf Verbindungen wartet
* Daher sollten Sie den gängigen, herkömmlichen Port für Ihre Anwendung verwenden
* Beispielsweise würde ein Image, das den Apache-Webserver enthält, <tt>EXPOSE 80</tt> verwenden, während ein Image, das MongoDB enthält, <tt>EXPOSE 27017</tt> verwenden würde und so weiter


Weitere Informationen zu <tt>EXPOSE</tt> finden Sie in der [https://docs.docker.com/reference/dockerfile/#expose Dockerfile-Referenz zur EXPOSE-Anweisung].
Für den externen Zugriff können Ihre Benutzer den Befehl <tt>docker run</tt> mit einem Flag ausführen, das angibt, wie der angegebene Port auf einen Port ihrer Wahl abgebildet werden soll
* Für die Verknüpfung von Containern stellt Docker Umgebungsvariablen für den Pfad vom Zielcontainer zurück zum Quellcontainer bereit (zum Beispiel <tt>MYSQL_PORT_3306_TCP</tt>)


=== ENV ===
; Links
* https://docs.docker.com/build/building/best-practices/#env
# https://docs.docker.com/build/building/best-practices/#expose
# [https://docs.docker.com/reference/dockerfile/#expose Dockerfile-Referenz zur EXPOSE-Anweisung]


Um die Ausführung neuer Software zu vereinfachen, können Sie mit <tt>ENV</tt> die Umgebungsvariable <tt>PATH</tt> für die Software aktualisieren, die Ihr Container installiert. So stellt beispielsweise <tt>ENV PATH=/usr/local/nginx/bin:$PATH</tt> sicher, dass <tt>CMD ["nginx"]</tt> einfach funktioniert.
== ENV ==
Um die Ausführung neuer Software zu vereinfachen, können Sie mit <tt>ENV</tt> die Umgebungsvariable <tt>PATH</tt> für die Software aktualisieren, die Ihr Container installiert
* So stellt beispielsweise <tt>ENV PATH=/usr/local/nginx/bin:$PATH</tt> sicher, dass <tt>CMD ["nginx"]</tt> einfach funktioniert


Die Anweisung <tt>ENV</tt> ist ebenfalls nützlich, um die erforderlichen Umgebungsvariablen für die Dienste bereitzustellen, die Sie in Container verlagern möchten, wie beispielsweise die <tt>PGDATA</tt> von Postgres.
Die Anweisung <tt>ENV</tt> ist ebenfalls nützlich, um die erforderlichen Umgebungsvariablen für die Dienste bereitzustellen, die Sie in Container verlagern möchten, wie beispielsweise die <tt>PGDATA</tt> von Postgres


Schließlich kann <tt>ENV</tt> auch dazu verwendet werden, häufig verwendete Versionsnummern festzulegen, damit Versionserhöhungen einfacher zu verwalten sind, wie im folgenden Beispiel zu sehen ist:
Schließlich kann <tt>ENV</tt> auch dazu verwendet werden, häufig verwendete Versionsnummern festzulegen, damit Versionserhöhungen einfacher zu verwalten sind, wie im folgenden Beispiel zu sehen ist:
Zeile 187: Zeile 224:
[https://docs.docker.com/reference/dockerfile/#env ENV] PATH=/usr/local/postgres-$PG_MAJOR/bin:$PATH
[https://docs.docker.com/reference/dockerfile/#env ENV] PATH=/usr/local/postgres-$PG_MAJOR/bin:$PATH


Ähnlich wie bei der Verwendung von Konstanten in einem Programm – im Gegensatz zur festen Programmierung von Werten – können Sie mit diesem Ansatz durch Ändern einer einzigen <tt>ENV</tt>-Anweisung die Version der Software in Ihrem Container automatisch erhöhen.
Ähnlich wie bei der Verwendung von Konstanten in einem Programm – im Gegensatz zur festen Programmierung von Werten – können Sie mit diesem Ansatz durch Ändern einer einzigen <tt>ENV</tt>-Anweisung die Version der Software in Ihrem Container automatisch erhöhen


Jede <tt>ENV</tt>-Zeile erstellt eine neue Zwischenebene, genau wie <tt>RUN</tt>-Befehle. Das bedeutet, dass selbst wenn Sie die Umgebungsvariable in einer späteren Ebene zurücksetzen, sie in dieser Ebene weiterhin bestehen bleibt und ihr Wert ausgegeben werden kann. Sie können dies testen, indem Sie eine Dockerfile wie die folgende erstellen und diese anschließend kompilieren.
Jede <tt>ENV</tt>-Zeile erstellt eine neue Zwischenebene, genau wie <tt>RUN</tt>-Befehle
* Das bedeutet, dass selbst wenn Sie die Umgebungsvariable in einer späteren Ebene zurücksetzen, sie in dieser Ebene weiterhin bestehen bleibt und ihr Wert ausgegeben werden kann
* Sie können dies testen, indem Sie eine Dockerfile wie die folgende erstellen und diese anschließend kompilieren


# syntax=docker/dockerfile:1
# syntax=docker/dockerfile:1
Zeile 200: Zeile 239:
mark
mark


Um dies zu verhindern und die Umgebungsvariable zurückzusetzen, verwenden Sie einen <tt>RUN</tt>-Befehl mit Shell-Befehlen, um die Variable in einer einzigen Ebene zu setzen, zu verwenden und zurückzusetzen. Sie können Ihre Befehle mit <tt>;</tt> oder <tt>&&</tt> trennen. Wenn Sie die zweite Methode verwenden und einer der Befehle fehlschlägt, schlägt auch der Befehl <tt>docker build</tt> fehl. Dies ist in der Regel eine gute Idee. Die Verwendung von <tt>\</tt> als Zeichen für Zeilenfortsetzung in Linux-Dockerfiles verbessert die Lesbarkeit. Sie könnten auch alle Befehle in ein Shell-Skript einfügen und den <tt>RUN</tt>-Befehl so gestalten, dass er lediglich dieses Shell-Skript ausführt.
Um dies zu verhindern und die Umgebungsvariable zurückzusetzen, verwenden Sie einen <tt>RUN</tt>-Befehl mit Shell-Befehlen, um die Variable in einer einzigen Ebene zu setzen, zu verwenden und zurückzusetzen
* Sie können Ihre Befehle mit <tt>;</tt> oder <tt>&&</tt> trennen
* Wenn Sie die zweite Methode verwenden und einer der Befehle fehlschlägt, schlägt auch der Befehl <tt>docker build</tt> fehl
* Dies ist in der Regel eine gute Idee
* Die Verwendung von <tt>\</tt> als Zeichen für Zeilenfortsetzung in Linux-Dockerfiles verbessert die Lesbarkeit
* Sie könnten auch alle Befehle in ein Shell-Skript einfügen und den <tt>RUN</tt>-Befehl so gestalten, dass er lediglich dieses Shell-Skript ausführt


# syntax=docker/dockerfile:1
# syntax=docker/dockerfile:1
Zeile 210: Zeile 254:
  docker run --rm test sh -c 'echo $ADMIN_USER'
  docker run --rm test sh -c 'echo $ADMIN_USER'


Weitere Informationen zu <tt>ENV</tt> finden Sie unter [https://docs.docker.com/reference/dockerfile/#env Dockerfile-Referenz zur ENV-Anweisung].
; Links
# https://docs.docker.com/build/building/best-practices/#env
# [https://docs.docker.com/reference/dockerfile/#env Dockerfile-Referenz zur ENV-Anweisung]
 
== KOPIEREN ==
<tt>ADD</tt> und <tt>COPY</tt> sind funktional ähnlich.  


=== KOPIEREN ===
<tt>COPY</tt> unterstützt das einfache Kopieren von Dateien in den Container, entweder aus dem [https://docs.docker.com/build/concepts/context/ Build-Kontext] oder aus einer Stufe eines [https://docs.docker.com/build/building/multi-stage/ mehrstufigen Builds].
* https://docs.docker.com/build/building/best-practices/#add-or-copy HINZUFÜGEN oder


<tt>ADD</tt> und <tt>COPY</tt> sind funktional ähnlich. <tt>COPY</tt> unterstützt das einfache Kopieren von Dateien in den Container, entweder aus dem [https://docs.docker.com/build/concepts/context/ Build-Kontext] oder aus einer Stufe eines [https://docs.docker.com/build/building/multi-stage/ mehrstufigen Builds]. <tt>ADD</tt> bietet Funktionen zum Abrufen von Dateien von entfernten HTTPS- und Git-URLs sowie zum automatischen Entpacken von tar-Dateien beim Hinzufügen von Dateien aus dem Build-Kontext.
<tt>ADD</tt> bietet Funktionen zum Abrufen von Dateien von entfernten HTTPS- und Git-URLs sowie zum automatischen Entpacken von tar-Dateien beim Hinzufügen von Dateien aus dem Build-Kontext


Meistens werden Sie <tt>COPY</tt> verwenden wollen, um Dateien in einem mehrstufigen Build von einer Stufe in eine andere zu kopieren. Wenn Sie Dateien aus dem Build-Kontext vorübergehend in den Container einbinden müssen, um eine <tt>RUN</tt>-Anweisung auszuführen, können Sie die <tt>COPY</tt>-Anweisung oft stattdessen durch eine Bind-Mount-Verbindung ersetzen. Beispielsweise, um vorübergehend eine <tt>requirements.txt</tt>-Datei für eine <tt>RUN pip install</tt>-Anweisung hinzuzufügen:
Meistens werden Sie <tt>COPY</tt> verwenden wollen, um Dateien in einem mehrstufigen Build von einer Stufe in eine andere zu kopieren
* Wenn Sie Dateien aus dem Build-Kontext vorübergehend in den Container einbinden müssen, um eine <tt>RUN</tt>-Anweisung auszuführen, können Sie die <tt>COPY</tt>-Anweisung oft stattdessen durch eine Bind-Mount-Verbindung ersetzen


[https://docs.docker.com/reference/dockerfile/#run RUN] --mount=type=bind,source=requirements.txt,target=/tmp/requirements.txt \
; Beispiel
Vorübergehend eine <tt>requirements.txt</tt>-Datei für eine <tt>RUN pip install</tt>-Anweisung hinzufügen
[https://docs.docker.com/reference/dockerfile/#run RUN] --mount=type=bind,source=requirements.txt,target=/tmp/requirements.txt \
     pip install --requirement /tmp/requirements.txt
     pip install --requirement /tmp/requirements.txt


Bind-Mounts sind effizienter als <tt>COPY</tt>, wenn es darum geht, Dateien aus dem Build- Kontext in den Container einzubinden. Beachten Sie, dass per Bind-Mount eingebundene Dateien nur vorübergehend für eine einzelne <tt>RUN</tt>-Anweisung hinzugefügt werden und im endgültigen Image nicht erhalten bleiben. Wenn Sie Dateien aus dem Build-Kontext in das endgültige Image einbinden möchten, verwenden Sie <tt>COPY</tt>.
Bind-Mounts sind effizienter als <tt>COPY</tt>, wenn es darum geht, Dateien aus dem Build- Kontext in den Container einzubinden
 
* Beachten Sie, dass per Bind-Mount eingebundene Dateien nur vorübergehend für eine einzelne <tt>RUN</tt>-Anweisung hinzugefügt werden und im endgültigen Image nicht erhalten bleiben
Der Befehl <tt>ADD</tt> eignet sich am besten, wenn Sie im Rahmen Ihres Builds ein Remote-Artefakt herunterladen müssen. <tt>ADD</tt> ist besser als das manuelle Hinzufügen von Dateien mit Programmen wie <tt>wget</tt> und <tt>tar</tt>, da es einen präziseren Build-Cache gewährleistet. <tt>ADD</tt> bietet außerdem integrierte Unterstützung für die Prüfsummenüberprüfung der Remote- Ressourcen sowie ein Protokoll zum Parsen von Branches, Tags und Unterverzeichnissen aus [https://docs.docker.com/reference/cli/docker/buildx/build/ Git-URLs].
* Wenn Sie Dateien aus dem Build-Kontext in das endgültige Image einbinden möchten, verwenden Sie <tt>COPY</tt>


Im folgenden Beispiel wird <tt>ADD</tt> verwendet, um ein .NET-Installationsprogramm herunterzuladen. In Kombination mit mehrstufigen Builds verbleibt in der letzten Stufe nur die .NET-Laufzeitumgebung, keine Zwischen-Dateien.
Der Befehl <tt>ADD</tt> eignet sich am besten, wenn Sie im Rahmen Ihres Builds ein Remote-Artefakt herunterladen müssen.  
* <tt>ADD</tt> ist besser als das manuelle Hinzufügen von Dateien mit Programmen wie <tt>wget</tt> und <tt>tar</tt>, da es einen präziseren Build-Cache gewährleistet.  
* <tt>ADD</tt> bietet außerdem integrierte Unterstützung für die Prüfsummenüberprüfung der Remote- Ressourcen sowie ein Protokoll zum Parsen von Branches, Tags und Unterverzeichnissen aus [https://docs.docker.com/reference/cli/docker/buildx/build/ Git-URLs]


# syntax=docker/dockerfile:1
Im folgenden Beispiel wird <tt>ADD</tt> verwendet, um ein .NET-Installationsprogramm herunterzuladen
* In Kombination mit mehrstufigen Builds verbleibt in der letzten Stufe nur die .NET-Laufzeitumgebung, keine Zwischen-Dateien


[https://docs.docker.com/reference/dockerfile/#from FROM] scratch AS src
# syntax=docker/dockerfile:1
[https://docs.docker.com/reference/dockerfile/#arg ARG] DOTNET_VERSION=8.0.0-preview.6.23329.7
[https://docs.docker.com/reference/dockerfile/#from FROM] scratch AS src
[https://docs.docker.com/reference/dockerfile/#add ADD] --checksum=sha256:270d731bd08040c6a3228115de1f74b91cf441c584139ff8f8f6503447cebdbb \
[https://docs.docker.com/reference/dockerfile/#arg ARG] DOTNET_VERSION=8.0.0-preview.6.23329.7
[https://docs.docker.com/reference/dockerfile/#add ADD] --checksum=sha256:270d731bd08040c6a3228115de1f74b91cf441c584139ff8f8f6503447cebdbb \
     https://dotnetcli.azureedge.net/dotnet/Runtime/$DOTNET_VERSION/dotnet-runtime-$DOTNET_VERSION-linux-arm64.tar.gz /dotnet.tar.gz
     https://dotnetcli.azureedge.net/dotnet/Runtime/$DOTNET_VERSION/dotnet-runtime-$DOTNET_VERSION-linux-arm64.tar.gz /dotnet.tar.gz
[https://docs.docker.com/reference/dockerfile/#from FROM] mcr.microsoft.com/dotnet/runtime-deps:8.0.0-preview.6-bookworm-slim-arm64v8 AS installer


[https://docs.docker.com/reference/dockerfile/#from FROM] mcr.microsoft.com/dotnet/runtime-deps:8.0.0-preview.6-bookworm-slim-arm64v8 AS installer
# Retrieve .NET Runtime
 
[https://docs.docker.com/reference/dockerfile/#run RUN] --mount=from=src,target=/src <<EOF
# Retrieve .NET Runtime
mkdir -p /dotnet
[https://docs.docker.com/reference/dockerfile/#run RUN] --mount=from=src,target=/src <<EOF
tar -oxzf /src/dotnet.tar.gz -C /dotnet
mkdir -p /dotnet
EOF
tar -oxzf /src/dotnet.tar.gz -C /dotnet
EOF
[https://docs.docker.com/reference/dockerfile/#from FROM] mcr.microsoft.com/dotnet/runtime-deps:8.0.0-preview.6-bookworm-slim-arm64v8
 
[https://docs.docker.com/reference/dockerfile/#from FROM] mcr.microsoft.com/dotnet/runtime-deps:8.0.0-preview.6-bookworm-slim-arm64v8
[https://docs.docker.com/reference/dockerfile/#copy COPY] --from=installer /dotnet /usr/share/dotnet
 
[https://docs.docker.com/reference/dockerfile/#run RUN] ln -s /usr/share/dotnet/dotnet /usr/bin/dotnet
[https://docs.docker.com/reference/dockerfile/#copy COPY] --from=installer /dotnet /usr/share/dotnet
[https://docs.docker.com/reference/dockerfile/#run RUN] ln -s /usr/share/dotnet/dotnet /usr/bin/dotnet
 
Weitere Informationen zu <tt>ADD</tt> oder <tt>COPY</tt> finden Sie hier:* [https://docs.docker.com/reference/dockerfile/#add Dockerfile-Referenz für die Anweisung „ADD“]
* [https://docs.docker.com/reference/dockerfile/#copy Dockerfile-Referenz zur COPY-Anweisung]
 


; Links
# https://docs.docker.com/build/building/best-practices/#add-or-copy HINZUFÜGEN oder
# [https://docs.docker.com/reference/dockerfile/#add Dockerfile-Referenz für die Anweisung „ADD“]
# [https://docs.docker.com/reference/dockerfile/#copy Dockerfile-Referenz zur COPY-Anweisung]


=== ENTRYPOINT ===
== ENTRYPOINT ==
* https://docs.docker.com/build/building/best-practices/#entrypoint
Die beste Verwendung für <tt>ENTRYPOINT</tt> besteht darin, den Hauptbefehl des Images festzulegen, sodass das Image so ausgeführt wird, als wäre es dieser Befehl, und anschließend <tt>CMD</tt> als Standardoptionen zu verwenden
 
Die beste Verwendung für <tt>ENTRYPOINT</tt> besteht darin, den Hauptbefehl des Images festzulegen, sodass das Image so ausgeführt wird, als wäre es dieser Befehl, und anschließend <tt>CMD</tt> als Standardoptionen zu verwenden.


Im Folgenden finden Sie ein Beispiel für ein Bild für das Befehlszeilentool <tt>s3cmd</tt>:
Im Folgenden finden Sie ein Beispiel für ein Bild für das Befehlszeilentool <tt>s3cmd</tt>:
Zeile 271: Zeile 324:
  docker run s3cmd ls s3://mybucket
  docker run s3cmd ls s3://mybucket


Das ist nützlich, da der Bildname gleichzeitig als Verweis auf die Binärdatei dienen kann, wie im obigen Befehl gezeigt.
Das ist nützlich, da der Bildname gleichzeitig als Verweis auf die Binärdatei dienen kann, wie im obigen Befehl gezeigt


Die Anweisung <tt>ENTRYPOINT</tt> kann auch in Kombination mit einem Hilfsskript verwendet werden, wodurch sie ähnlich wie der obige Befehl funktioniert, selbst wenn der Start des Tools möglicherweise mehr als einen Schritt erfordert.
Die Anweisung <tt>ENTRYPOINT</tt> kann auch in Kombination mit einem Hilfsskript verwendet werden, wodurch sie ähnlich wie der obige Befehl funktioniert, selbst wenn der Start des Tools möglicherweise mehr als einen Schritt erfordert


Beispielsweise verwendet das [https://hub.docker.com/_/postgres/ offizielle Postgres-Image] das folgende Skript als <tt>ENTRYPOINT</tt>:
Beispielsweise verwendet das [https://hub.docker.com/_/postgres/ offizielle Postgres-Image] das folgende Skript als <tt>ENTRYPOINT</tt>:
Zeile 279: Zeile 332:
  #!/bin/sh
  #!/bin/sh
  set -e
  set -e
 
  if [ "$1" = 'postgres' ]; then
  if [ "$1" = 'postgres' ]; then
     chown -R postgres "$PGDATA"
     chown -R postgres "$PGDATA"
 
     if [ -z "$(ls -A "$PGDATA")" ]; then
     if [ -z "$(ls -A "$PGDATA")" ]; then
         gosu postgres initdb
         gosu postgres initdb
     fi
     fi
 
     exec gosu postgres "$@"
     exec gosu postgres "$@"
  fi
  fi
 
  exec "$@"
  exec "$@"


Dieses Skript verwendet [https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#exec die eingebaute Funktion exec], sodass die letztendlich ausgeführte Anwendung die PID 1 des Containers erhält. Dadurch kann die Anwendung alle an den Container gesendeten Unix-Signale empfangen. Weitere Informationen finden Sie in der [https://docs.docker.com/reference/dockerfile/#entrypoint ENTRYPOINT-Referenz].
Dieses Skript verwendet [https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#exec die eingebaute Funktion exec], sodass die letztendlich ausgeführte Anwendung die PID 1 des Containers erhält
* Dadurch kann die Anwendung alle an den Container gesendeten Unix-Signale empfangen
* Weitere Informationen finden Sie in der [https://docs.docker.com/reference/dockerfile/#entrypoint ENTRYPOINT-Referenz]


Im folgenden Beispiel wird ein Hilfsskript in den Container kopiert und beim Start des Containers über <tt>ENTRYPOINT</tt> ausgeführt:
Im folgenden Beispiel wird ein Hilfsskript in den Container kopiert und beim Start des Containers über <tt>ENTRYPOINT</tt> ausgeführt:
[https://docs.docker.com/reference/dockerfile/#copy COPY] ./docker-entrypoint.sh /
[https://docs.docker.com/reference/dockerfile/#entrypoint ENTRYPOINT] ["/docker-entrypoint.sh"]
[https://docs.docker.com/reference/dockerfile/#cmd CMD] ["postgres"]


[https://docs.docker.com/reference/dockerfile/#copy COPY] ./docker-entrypoint.sh /
Mit diesem Skript können Sie auf verschiedene Arten mit Postgres interagieren
[https://docs.docker.com/reference/dockerfile/#entrypoint ENTRYPOINT] ["/docker-entrypoint.sh"]
[https://docs.docker.com/reference/dockerfile/#cmd CMD] ["postgres"]
 
Mit diesem Skript können Sie auf verschiedene Arten mit Postgres interagieren.


Es kann Postgres starten:
Es kann Postgres starten:
  docker run postgres
  docker run postgres


Oder Sie können damit Postgres ausführen und Parameter an den Server übergeben:
Oder Sie können damit Postgres ausführen und Parameter an den Server übergeben
 
  docker run postgres postgres --help
  docker run postgres postgres --help


Zu guter Letzt kannst du damit auch ein ganz anderes Tool starten, zum Beispiel Bash:
Zu guter Letzt kannst du damit auch ein ganz anderes Tool starten, zum Beispiel Bash:
  docker run --rm -it postgres bash
  docker run --rm -it postgres bash


Weitere Informationen zu <tt>ENTRYPOINT</tt> finden Sie in der [https://docs.docker.com/reference/dockerfile/#entrypoint Dockerfile-Referenz zur ENTRYPOINT-Anweisung].
; Links
 
# https://docs.docker.com/build/building/best-practices/#entrypoint
=== UMFANG ===
# [https://docs.docker.com/reference/dockerfile/#entrypoint Dockerfile-Referenz zur ENTRYPOINT-Anweisung]
* https://docs.docker.com/build/building/best-practices/#volume
 
Sie sollten die Anweisung <tt>VOLUME</tt> verwenden, um Datenbank-Speicherbereiche, Konfigurationsspeicher oder von Ihrem Docker-Container erstellte Dateien und Ordner freizugeben. Es wird dringend empfohlen, <tt>VOLUME</tt> für jede Kombination aus veränderbaren oder vom Benutzer zu wartenden Teilen Ihres Images zu verwenden.


Weitere Informationen zu <tt>VOLUME</tt> finden Sie in der [https://docs.docker.com/reference/dockerfile/#volume Dockerfile-Referenz zur VOLUME-Anweisung].
== Volume ==
Sie sollten die Anweisung <tt>VOLUME</tt> verwenden, um Datenbank-Speicherbereiche, Konfigurationsspeicher oder von Ihrem Docker-Container erstellte Dateien und Ordner freizugeben
* Es wird dringend empfohlen, <tt>VOLUME</tt> für jede Kombination aus veränderbaren oder vom Benutzer zu wartenden Teilen Ihres Images zu verwenden


=== BENUTZER ===
; Links
* https://docs.docker.com/build/building/best-practices/#user
# https://docs.docker.com/build/building/best-practices/#volume
# [https://docs.docker.com/reference/dockerfile/#volume Dockerfile-Referenz zur VOLUME-Anweisung]


Wenn ein Dienst ohne Sonderrechte ausgeführt werden kann, verwenden Sie <tt>USER</tt>, um zu einem Nicht-Root-Benutzer zu wechseln. Erstellen Sie zunächst den Benutzer und die Gruppe im Dockerfile, etwa wie im folgenden Beispiel:
== USER ==
Wenn ein Dienst ohne Sonderrechte ausgeführt werden kann, verwenden Sie <tt>USER</tt>, um zu einem Nicht-Root-Benutzer zu wechseln
* Erstellen Sie zunächst den Benutzer und die Gruppe im Dockerfile, etwa wie im folgenden Beispiel:


[https://docs.docker.com/reference/dockerfile/#run RUN]
[https://docs.docker.com/reference/dockerfile/#run RUN]
Zeile 332: Zeile 385:


; Anmerkung
; Anmerkung
* Betrachten wir eine explizite UID/GID.
* Betrachten wir eine explizite UID/GID
* Benutzern und Gruppen in einem Image wird eine nicht-deterministische UID/GID zugewiesen, da die „nächste“ UID/GID unabhängig von Image-Neuerstellungen vergeben wird. Wenn dies also kritisch ist, sollten Sie eine explizite UID/GID zuweisen.
* Benutzern und Gruppen in einem Image wird eine nicht-deterministische UID/GID zugewiesen, da die „nächste“ UID/GID unabhängig von Image-Neuerstellungen vergeben wird
* Wenn dies also kritisch ist, sollten Sie eine explizite UID/GID zuweisen


; Anmerkung
; Anmerkung
* unterstützt dieses Flag nicht.
* unterstützt dieses Flag nicht
 
Vermeiden Sie die Installation oder Verwendung von <tt>sudo</tt>, da es ein unvorhersehbares Verhalten hinsichtlich TTY und Signalweiterleitung aufweist, das zu Problemen führen kann
* Wenn Sie unbedingt eine ähnliche Funktionalität wie bei <tt>sudo</tt> benötigen, beispielsweise um den Daemon als <tt>root</tt> zu initialisieren, ihn aber als Nicht-<tt>root</tt> auszuführen, sollten Sie die Verwendung von [https://github.com/tianon/gosu „gosu“] in Betracht ziehen
 
Um die Anzahl der Ebenen und die Komplexität zu reduzieren, sollten Sie es schließlich vermeiden, <tt>USER</tt> häufig hin und her zu wechseln
 
; Links
# https://docs.docker.com/build/building/best-practices/#user
# [https://docs.docker.com/reference/dockerfile/#user Dockerfile-Referenz zur USER-Anweisung]
 
== WORKDIR ==
Aus Gründen der Übersichtlichkeit und Zuverlässigkeit sollten Sie für Ihr <tt>WORKDIR</tt> stets absolute Pfade verwenden
* Außerdem sollten Sie <tt>WORKDIR</tt> anstelle von sich häufenden Anweisungen wie <tt>RUN cd … && do-something</tt> verwenden, da diese schwer lesbar sind und die Fehlerbehebung sowie die Wartung erschweren
 
; Links
# https://docs.docker.com/build/building/best-practices/#workdir
# [https://docs.docker.com/reference/dockerfile/#workdir Dockerfile-Referenz zur Anweisung WORKDIR]
 
== ONBUILD ==
Ein <tt>ONBUILD</tt>-Befehl wird ausgeführt, nachdem der aktuelle Dockerfile-Build abgeschlossen ist. <tt>ONBUILD</tt> wird in jedem untergeordneten Image ausgeführt, das <tt>FROM</tt> das aktuelle Image abgeleitet ist
* Stellen Sie sich den <tt>ONBUILD</tt>-Befehl als eine Anweisung vor, die das übergeordnete Dockerfile an das untergeordnete Dockerfile gibt
 
Bei einem Docker-Build werden <tt>ONBUILD</tt>-Befehle vor allen Befehlen in einer untergeordneten Dockerfile-Datei ausgeführt


Vermeiden Sie die Installation oder Verwendung von <tt>sudo</tt>, da es ein unvorhersehbares Verhalten hinsichtlich TTY und Signalweiterleitung aufweist, das zu Problemen führen kann. Wenn Sie unbedingt eine ähnliche Funktionalität wie bei <tt>sudo</tt> benötigen, beispielsweise um den Daemon als <tt>root</tt> zu initialisieren, ihn aber als Nicht-<tt>root</tt> auszuführen, sollten Sie die Verwendung von [https://github.com/tianon/gosu „gosu“] in Betracht ziehen.
<tt>ONBUILD</tt> ist nützlich für Images, die <tt>FROM</tt> ein bestimmtes Image erstellt werden sollen
* Beispielsweise würden Sie <tt>ONBUILD</tt> für ein Sprach-Stack-Image verwenden, das beliebige, in dieser Sprache geschriebene Anwendersoftware innerhalb des Dockerfile erstellt, wie Sie in den [https://github.com/docker-library/ruby/blob/c43fef8a60cea31eb9e7d960a076d633cb62ba8d/2.4/jessie/onbuild/Dockerfile Ruby-Varianten von ONBUILD sehen können]


Um die Anzahl der Ebenen und die Komplexität zu reduzieren, sollten Sie es schließlich vermeiden, <tt>USER</tt> häufig hin und her zu wechseln.
Mit <tt>ONBUILD</tt> erstellte Images sollten ein eigenes Tag erhalten
* Zum Beispiel <tt>ruby:1.9-onbuild</tt> oder <tt>ruby:2.0-onbuild</tt>


Weitere Informationen zu <tt>USER</tt> finden Sie in der [https://docs.docker.com/reference/dockerfile/#user Dockerfile-Referenz zur USER-Anweisung].
Seien Sie vorsichtig, wenn Sie <tt>ADD</tt> oder <tt>COPY</tt> in <tt>ONBUILD</tt> einfügen
* Das Image stürzt katastrophal ab, wenn im Kontext des neuen Builds die hinzugefügte Ressource fehlt
* Das Hinzufügen eines separaten Tags, wie oben empfohlen, hilft, dieses Problem zu mildern, indem es dem Verfasser des Dockerfiles die Wahl lässt


=== WORKDIR ===
; Links
* https://docs.docker.com/build/building/best-practices/#workdir
# https://docs.docker.com/build/building/best-practices/#onbuild
# [https://docs.docker.com/reference/dockerfile/#onbuild Dockerfile-Referenz zur ONBUILD-Anweisung]


Aus Gründen der Übersichtlichkeit und Zuverlässigkeit sollten Sie für Ihr <tt>WORKDIR</tt> stets absolute Pfade verwenden. Außerdem sollten Sie <tt>WORKDIR</tt> anstelle von sich häufenden Anweisungen wie <tt>RUN cd … && do-something</tt> verwenden, da diese schwer lesbar sind und die Fehlerbehebung sowie die Wartung erschweren.
<noinclude>
<!--
----
{{Navigation|<zurück>|<nachste>}}
----
-->


Weitere Informationen zu <tt>WORKDIR</tt> finden Sie in der [https://docs.docker.com/reference/dockerfile/#workdir Dockerfile-Referenz zur Anweisung WORKDIR].
== Anhang ==
=== Siehe auch ===
<div style="column-count:2">
<categorytree hideroot=on mode="pages">{{BASEPAGENAME}}</categorytree>
</div>
----
{{Special:PrefixIndex/{{BASEPAGENAME}}/}}


=== ONBUILD ===
=== Dokumentation ===
* https://docs.docker.com/build/building/best-practices/#onbuild
<!--
; Man-Page
# [https://manpages.debian.org/stable/procps/pgrep.1.de.html prep(1)]


Ein <tt>ONBUILD</tt>-Befehl wird ausgeführt, nachdem der aktuelle Dockerfile-Build abgeschlossen ist. <tt>ONBUILD</tt> wird in jedem untergeordneten Image ausgeführt, das <tt>FROM</tt> das aktuelle Image abgeleitet ist. Stellen Sie sich den <tt>ONBUILD</tt>-Befehl als eine Anweisung vor, die das übergeordnete Dockerfile an das untergeordnete Dockerfile gibt.
; Info-Pages


Bei einem Docker-Build werden <tt>ONBUILD</tt>-Befehle vor allen Befehlen in einer untergeordneten Dockerfile-Datei ausgeführt.
; Hinweise
<div class="card h-100 bg-warning">
<div class="card-header">'''<big>Header</big>'''</div>
<div class="card-body bg-white">
Hier steht der Kartentext
</div>
</div>
-->


<tt>ONBUILD</tt> ist nützlich für Images, die <tt>FROM</tt> ein bestimmtes Image erstellt werden sollen. Beispielsweise würden Sie <tt>ONBUILD</tt> für ein Sprach-Stack-Image verwenden, das beliebige, in dieser Sprache geschriebene Anwendersoftware innerhalb des Dockerfile erstellt, wie Sie in den [https://github.com/docker-library/ruby/blob/c43fef8a60cea31eb9e7d960a076d633cb62ba8d/2.4/jessie/onbuild/Dockerfile Ruby-Varianten von ONBUILD sehen können].
=== Links ===
==== Projekt ====
==== Weblinks ====
# https://docs.docker.com/reference/dockerfile/  
# https://docs.docker.com/build/building/best-practices/#dockerfile-instructions


Mit <tt>ONBUILD</tt> erstellte Images sollten ein eigenes Tag erhalten. Zum Beispiel <tt>ruby:1.9-onbuild</tt> oder <tt>ruby:2.0-onbuild</tt>.
<!--
{{DEFAULTSORT:new}}
{{DISPLAYTITLE:new}}
-->


Seien Sie vorsichtig, wenn Sie <tt>ADD</tt> oder <tt>COPY</tt> in <tt>ONBUILD</tt> einfügen. Das Image stürzt katastrophal ab, wenn im Kontext des neuen Builds die hinzugefügte Ressource fehlt. Das Hinzufügen eines separaten Tags, wie oben empfohlen, hilft, dieses Problem zu mildern, indem es dem Verfasser des Dockerfiles die Wahl lässt.


Weitere Informationen zu <tt>ONBUILD</tt> finden Sie in der [https://docs.docker.com/reference/dockerfile/#onbuild Dockerfile-Referenz zur ONBUILD-Anweisung].


[[Kategorie:Docker/Image]]
</noinclude>
[[Kategorie:Docker/Image/best-practice]]

Aktuelle Version vom 20. November 2026, 10:51 Uhr

Docker/Image/best-practice/Dockerfile - Empfehlungen zur Verwendung von Dockerfile-Anweisungen


Beschreibung

Effiziente und wartungsfreundliche Dockerfiles erstellen

Empfehlungen zur korrekten Verwendung der Dockerfile-Anweisungen

FROM

Verwenden Sie nach Möglichkeit aktuelle offizielle Images als Grundlage für Ihre Images

  • Docker empfiehlt das Alpine-Image, da es streng kontrolliert wird und eine geringe Größe aufweist (unter 6 MB), dabei aber dennoch eine vollständige Linux-Distribution darstellt
Links
  1. https://docs.docker.com/reference/dockerfile/#from Dockerfile-Referenz zur FROM-Anweisung
  2. https://docs.docker.com/build/building/best-practices/#from

LABEL

Sie können Ihrem Bild Beschriftungen hinzufügen, um Bilder nach Projekten zu ordnen, Lizenzinformationen zu erfassen, die Automatisierung zu unterstützen oder aus anderen Gründen

  • Fügen Sie für jede Beschriftung eine Zeile ein, die mit LABEL beginnt und ein oder mehrere Schlüssel-Wert-Paare enthält
  • Die folgenden Beispiele zeigen die verschiedenen zulässigen Formate
  • Erläuternde Kommentare sind direkt im Text enthalten

Zeichenketten mit Leerzeichen müssen in Anführungszeichen gesetzt oder die Leerzeichen müssen mit Escape-Zeichen versehen werden

  • Innere Anführungszeichen (") müssen ebenfalls mit Escape-Zeichen versehen werden
Beispiel
# Set one or more individual labels
LABEL com.example.version="0.0.1-beta"
LABEL vendor1="ACME Incorporated"
LABEL vendor2=ZENITH\ Incorporated
LABEL com.example.release-date="2015-02-12"
LABEL com.example.version.is-production=""

Ein Image kann mehr als ein Label haben

  • Vor Docker 1.10 wurde empfohlen, alle Labels in einer einzigen LABEL-Anweisung zusammenzufassen, um zu verhindern, dass zusätzliche Layer erstellt werden
  • Dies ist nun nicht mehr erforderlich, die Zusammenfassung von Labels wird jedoch weiterhin unterstützt
Beispiel
# Set multiple labels on one line
LABEL com.example.version="0.0.1-beta" com.example.release-date="2015-02-12"

Das obige Beispiel lässt sich auch wie folgt schreiben:

# Set multiple labels at once, using line-continuation characters to break long lines
LABEL vendor=ACME\ Incorporated \
     com.example.is-beta= \
     com.example.is-production="" \
     com.example.version="0.0.1-beta" \
     com.example.release-date="2015-02-12"

Siehe Objekt-Labels verstehen für Richtlinien zu zulässigen Label-Schlüsseln und -Werten

Links

RUN

Teilen Sie lange oder komplexe RUN-Anweisungen auf mehrere Zeilen auf

  • getrennt durch Backslashes
  • Dockerfile lesbarer, verständlicher und wartbarer zu machen

Befehle können mit dem Operator && verkettet werden und Escape-Zeichen verwenden, um lange Befehle in mehrere Zeilen aufzuteilen

RUN apt-get update && apt-get install -y --no-install-recommends \
   package-bar \
   package-baz \
   package-foo

Standardmäßig dient der Backslash als Escape-Zeichen für ein Zeilenumbruchzeichen, aber du kannst dies mit der escape-Direktive ändern

Here-Dokumente

Sie können auch Here-Dokumente verwenden, um mehrere Befehle auszuführen, ohne sie mit einem Pipeline-Operator zu verketten:

<<EOF
apt-get update
apt-get install -y --no-install-recommends \
    package-bar \
    package-baz \
    package-foo
EOF
Links
  1. https://docs.docker.com/build/building/best-practices/#run
  2. Dockerfile-Referenz zur RUN-Anweisung

apt-get

Ein häufiger Anwendungsfall für RUN-Anweisungen in Debian-basierten Images ist die Installation von Software mithilfe von apt-get

  • Da apt-get Pakete installiert, weist der Befehl RUN apt-get einige nicht intuitiv erscheinende Verhaltensweisen auf, auf die man achten sollte

Kombinieren Sie RUN apt-get update immer mit apt-get install in derselben RUN-Anweisung

Beispiel
apt-get update && apt-get install -y --no-install-recommends \
    package-bar \
    package-baz \
    package-foo

Die alleinige Verwendung von apt-get update in einer RUN-Anweisung führt zu Problemen mit dem Cache und dazu, dass nachfolgende apt-get install-Anweisungen fehlschlagen

  • Dieses Problem tritt beispielsweise im folgenden Dockerfile auf:
# syntax=docker/dockerfile:1
FROM ubuntu:22.04
RUN apt-get update
RUN apt-get install -y --no-install-recommends curl

Nach dem Erstellen des Images befinden sich alle Layer im Docker-Cache

  • Angenommen, Sie ändern später apt-get install, indem Sie ein zusätzliches Paket hinzufügen, wie im folgenden Dockerfile gezeigt:
# syntax=docker/dockerfile:1
FROM ubuntu:22.04
RUN apt-get update
RUN apt-get install -y --no-install-recommends curl nginx

Docker betrachtet die ursprünglichen und die geänderten Anweisungen als identisch und verwendet den Cache aus den vorherigen Schritten erneut

  • Infolgedessen wird der Befehl apt-get update nicht ausgeführt, da der Build die zwischengespeicherte Version verwendet
  • Da der Befehl apt-get update nicht ausgeführt wird, kann es vorkommen, dass Ihr Build eine veraltete Version der Pakete curl und nginx erhält

Mit RUN apt-get update && apt-get install -y --no-install-recommends stellen Sie sicher, dass Ihr Dockerfile die neuesten Paketversionen installiert, ohne dass weitere Programmierarbeiten oder manuelle Eingriffe erforderlich sind

  • Diese Technik wird als „Cache Busting“ bezeichnet
  • Sie können Cache Busting auch erreichen, indem Sie eine bestimmte Paketversion angeben
  • Dies wird als „Version Pinning“ bezeichnet
Beispiel
RUN apt-get update && apt-get install -y --no-install-recommends \
   package-bar \
   package-baz \
   package-foo=1.3.*

Durch die Versionsfestlegung wird der Build dazu gezwungen, eine bestimmte Version abzurufen, unabhängig davon, was sich im Cache befindet

  • Diese Technik kann zudem Fehler reduzieren, die durch unerwartete Änderungen an erforderlichen Paketen verursacht werden

Im Folgenden finden Sie einen korrekt formatierten RUN-Befehl, der alle apt-get- Empfehlungen veranschaulicht

apt-get update && apt-get install -y --no-install-recommends \
   aufs-tools \
   automake \
   build-essential \
   curl \
   dpkg-sig \
   libcap-dev \
   libsqlite3-dev \
   mercurial \
   reprepro \
   ruby1.9.1 \
   ruby1.9.1-dev \
   s3cmd=1.1.* \
   && rm -rf /var/lib/apt/lists/*

Das s3cmd-Argument gibt eine Version 1.1.* an

  • Wenn für das Image zuvor eine ältere Version verwendet wurde, führt die Angabe der neuen Version zu einem Cache-Bust von apt-get update und stellt sicher, dass die neue Version installiert wird
  • Die Auflistung der Pakete in jeder Zeile kann zudem Fehler durch doppelte Paketinstallationen verhindern

Wenn Sie zudem den apt-Cache durch Löschen von /var/lib/apt/lists bereinigen, verringert sich die Image-Größe, da der apt-Cache nicht in einer Layer gespeichert wird

  • Da die RUN-Anweisung mit apt-get update beginnt, wird der Paket-Cache immer vor apt-get install aktualisiert

Offizielle Debian- und Ubuntu-Images führen automatisch apt-get clean aus, sodass ein expliziter Aufruf nicht erforderlich ist

Links

Pipes

Verwendung von Pipes

Einige RUN-Befehle setzen voraus, dass die Ausgabe eines Befehls mithilfe des Pipe-Zeichens (|) an einen anderen Befehl weitergeleitet werden kann, wie im folgenden Beispiel gezeigt:

wget -O - https://some.site | wc -l > /number

Docker führt diese Befehle mit dem Interpreter /bin/sh -c aus, der zur Feststellung des Erfolgs lediglich den Exit-Code der letzten Operation in der Pipe auswertet

  • Im obigen Beispiel ist dieser Build-Schritt erfolgreich und erzeugt ein neues Image, solange der Befehl wc -l erfolgreich ist, selbst wenn der Befehl wget fehlschlägt

Wenn Sie möchten, dass der Befehl aufgrund eines Fehlers in einer beliebigen Phase der Pipe fehlschlägt, fügen Sie set -o pipefail && am Anfang ein, um sicherzustellen, dass ein unerwarteter Fehler verhindert, dass der Build versehentlich erfolgreich abgeschlossen wird

Beispiel
set -o pipefail && wget -O - https://some.site | wc -l > /number
Beispiel
["/bin/bash", "-c", "set -o pipefail && wget -O - https://some.site | wc -l > /number"]
Links

CMD

Der Befehl CMD sollte verwendet werden, um die in Ihrem Image enthaltene Software zusammen mit etwaigen Argumenten auszuführen

  • CMD sollte fast immer in der Form CMD ["ausführbare Datei", "Parameter1", "Parameter2"] verwendet werden
  • Wenn das Image also für einen Dienst wie Apache und Rails bestimmt ist, würden Sie beispielsweise CMD ["apache2","-DFOREGROUND"] ausführen
  • Tatsächlich wird diese Form des Befehls für jedes dienstbasierte Image empfohlen

In den meisten anderen Fällen sollte CMD eine interaktive Shell erhalten, wie bash, Python oder Perl

  • Zum Beispiel CMD ["perl", "-de0"], CMD ["python"] oder CMD ["php", "-a"]
  • Wenn Sie diese Form verwenden, bedeutet das, dass Sie bei der Ausführung von beispielsweise docker run -it python direkt in eine einsatzbereite Shell gelangen. CMD sollte nur selten in der Form CMD ["param", "param"] in Verbindung mit ENTRYPOINT verwendet werden, es sei denn, Sie und Ihre erwarteten Benutzer sind bereits gut mit der Funktionsweise von ENTRYPOINT vertraut
Links
  1. Dockerfile-Referenz zur CMD-Anweisung
  2. https://docs.docker.com/build/building/best-practices/#cmd

EXPOSE

Die Anweisung EXPOSE gibt die Ports an, auf denen ein Container auf Verbindungen wartet

  • Daher sollten Sie den gängigen, herkömmlichen Port für Ihre Anwendung verwenden
  • Beispielsweise würde ein Image, das den Apache-Webserver enthält, EXPOSE 80 verwenden, während ein Image, das MongoDB enthält, EXPOSE 27017 verwenden würde und so weiter

Für den externen Zugriff können Ihre Benutzer den Befehl docker run mit einem Flag ausführen, das angibt, wie der angegebene Port auf einen Port ihrer Wahl abgebildet werden soll

  • Für die Verknüpfung von Containern stellt Docker Umgebungsvariablen für den Pfad vom Zielcontainer zurück zum Quellcontainer bereit (zum Beispiel MYSQL_PORT_3306_TCP)
Links
  1. https://docs.docker.com/build/building/best-practices/#expose
  2. Dockerfile-Referenz zur EXPOSE-Anweisung

ENV

Um die Ausführung neuer Software zu vereinfachen, können Sie mit ENV die Umgebungsvariable PATH für die Software aktualisieren, die Ihr Container installiert

  • So stellt beispielsweise ENV PATH=/usr/local/nginx/bin:$PATH sicher, dass CMD ["nginx"] einfach funktioniert

Die Anweisung ENV ist ebenfalls nützlich, um die erforderlichen Umgebungsvariablen für die Dienste bereitzustellen, die Sie in Container verlagern möchten, wie beispielsweise die PGDATA von Postgres

Schließlich kann ENV auch dazu verwendet werden, häufig verwendete Versionsnummern festzulegen, damit Versionserhöhungen einfacher zu verwalten sind, wie im folgenden Beispiel zu sehen ist:

ENV PG_MAJOR=9.3 ENV PG_VERSION=9.3.4 RUN curl -SL https://example.com/postgres-$PG_VERSION.tar.xz | tar -xJC /usr/src/postgres && … ENV PATH=/usr/local/postgres-$PG_MAJOR/bin:$PATH

Ähnlich wie bei der Verwendung von Konstanten in einem Programm – im Gegensatz zur festen Programmierung von Werten – können Sie mit diesem Ansatz durch Ändern einer einzigen ENV-Anweisung die Version der Software in Ihrem Container automatisch erhöhen

Jede ENV-Zeile erstellt eine neue Zwischenebene, genau wie RUN-Befehle

  • Das bedeutet, dass selbst wenn Sie die Umgebungsvariable in einer späteren Ebene zurücksetzen, sie in dieser Ebene weiterhin bestehen bleibt und ihr Wert ausgegeben werden kann
  • Sie können dies testen, indem Sie eine Dockerfile wie die folgende erstellen und diese anschließend kompilieren
  1. syntax=docker/dockerfile:1

FROM alpine ENV ADMIN_USER="mark" RUN echo $ADMIN_USER > ./mark RUN unset ADMIN_USER

docker run --rm test sh -c 'echo $ADMIN_USER'

mark

Um dies zu verhindern und die Umgebungsvariable zurückzusetzen, verwenden Sie einen RUN-Befehl mit Shell-Befehlen, um die Variable in einer einzigen Ebene zu setzen, zu verwenden und zurückzusetzen

  • Sie können Ihre Befehle mit ; oder && trennen
  • Wenn Sie die zweite Methode verwenden und einer der Befehle fehlschlägt, schlägt auch der Befehl docker build fehl
  • Dies ist in der Regel eine gute Idee
  • Die Verwendung von \ als Zeichen für Zeilenfortsetzung in Linux-Dockerfiles verbessert die Lesbarkeit
  • Sie könnten auch alle Befehle in ein Shell-Skript einfügen und den RUN-Befehl so gestalten, dass er lediglich dieses Shell-Skript ausführt
  1. syntax=docker/dockerfile:1

FROM alpine RUN export ADMIN_USER="mark" \

   && echo $ADMIN_USER > ./mark \
   && unset ADMIN_USER

CMD sh

docker run --rm test sh -c 'echo $ADMIN_USER'
Links
  1. https://docs.docker.com/build/building/best-practices/#env
  2. Dockerfile-Referenz zur ENV-Anweisung

KOPIEREN

ADD und COPY sind funktional ähnlich.

COPY unterstützt das einfache Kopieren von Dateien in den Container, entweder aus dem Build-Kontext oder aus einer Stufe eines mehrstufigen Builds.

ADD bietet Funktionen zum Abrufen von Dateien von entfernten HTTPS- und Git-URLs sowie zum automatischen Entpacken von tar-Dateien beim Hinzufügen von Dateien aus dem Build-Kontext

Meistens werden Sie COPY verwenden wollen, um Dateien in einem mehrstufigen Build von einer Stufe in eine andere zu kopieren

  • Wenn Sie Dateien aus dem Build-Kontext vorübergehend in den Container einbinden müssen, um eine RUN-Anweisung auszuführen, können Sie die COPY-Anweisung oft stattdessen durch eine Bind-Mount-Verbindung ersetzen
Beispiel

Vorübergehend eine requirements.txt-Datei für eine RUN pip install-Anweisung hinzufügen

RUN --mount=type=bind,source=requirements.txt,target=/tmp/requirements.txt \
   pip install --requirement /tmp/requirements.txt

Bind-Mounts sind effizienter als COPY, wenn es darum geht, Dateien aus dem Build- Kontext in den Container einzubinden

  • Beachten Sie, dass per Bind-Mount eingebundene Dateien nur vorübergehend für eine einzelne RUN-Anweisung hinzugefügt werden und im endgültigen Image nicht erhalten bleiben
  • Wenn Sie Dateien aus dem Build-Kontext in das endgültige Image einbinden möchten, verwenden Sie COPY

Der Befehl ADD eignet sich am besten, wenn Sie im Rahmen Ihres Builds ein Remote-Artefakt herunterladen müssen.

  • ADD ist besser als das manuelle Hinzufügen von Dateien mit Programmen wie wget und tar, da es einen präziseren Build-Cache gewährleistet.
  • ADD bietet außerdem integrierte Unterstützung für die Prüfsummenüberprüfung der Remote- Ressourcen sowie ein Protokoll zum Parsen von Branches, Tags und Unterverzeichnissen aus Git-URLs

Im folgenden Beispiel wird ADD verwendet, um ein .NET-Installationsprogramm herunterzuladen

  • In Kombination mit mehrstufigen Builds verbleibt in der letzten Stufe nur die .NET-Laufzeitumgebung, keine Zwischen-Dateien
# syntax=docker/dockerfile:1
FROM scratch AS src
ARG DOTNET_VERSION=8.0.0-preview.6.23329.7
ADD --checksum=sha256:270d731bd08040c6a3228115de1f74b91cf441c584139ff8f8f6503447cebdbb \
   https://dotnetcli.azureedge.net/dotnet/Runtime/$DOTNET_VERSION/dotnet-runtime-$DOTNET_VERSION-linux-arm64.tar.gz /dotnet.tar.gz

FROM mcr.microsoft.com/dotnet/runtime-deps:8.0.0-preview.6-bookworm-slim-arm64v8 AS installer
# Retrieve .NET Runtime
RUN --mount=from=src,target=/src <<EOF
mkdir -p /dotnet
tar -oxzf /src/dotnet.tar.gz -C /dotnet
EOF

FROM mcr.microsoft.com/dotnet/runtime-deps:8.0.0-preview.6-bookworm-slim-arm64v8

COPY --from=installer /dotnet /usr/share/dotnet
RUN ln -s /usr/share/dotnet/dotnet /usr/bin/dotnet
Links
  1. https://docs.docker.com/build/building/best-practices/#add-or-copy HINZUFÜGEN oder
  2. Dockerfile-Referenz für die Anweisung „ADD“
  3. Dockerfile-Referenz zur COPY-Anweisung

ENTRYPOINT

Die beste Verwendung für ENTRYPOINT besteht darin, den Hauptbefehl des Images festzulegen, sodass das Image so ausgeführt wird, als wäre es dieser Befehl, und anschließend CMD als Standardoptionen zu verwenden

Im Folgenden finden Sie ein Beispiel für ein Bild für das Befehlszeilentool s3cmd:

ENTRYPOINT ["s3cmd"] CMD ["--help"]

Mit dem folgenden Befehl können Sie das Image ausführen und die Hilfe zum Befehl anzeigen:

docker run s3cmd

Alternativ können Sie die richtigen Parameter verwenden, um einen Befehl auszuführen, wie im folgenden Beispiel gezeigt:

docker run s3cmd ls s3://mybucket

Das ist nützlich, da der Bildname gleichzeitig als Verweis auf die Binärdatei dienen kann, wie im obigen Befehl gezeigt

Die Anweisung ENTRYPOINT kann auch in Kombination mit einem Hilfsskript verwendet werden, wodurch sie ähnlich wie der obige Befehl funktioniert, selbst wenn der Start des Tools möglicherweise mehr als einen Schritt erfordert

Beispielsweise verwendet das offizielle Postgres-Image das folgende Skript als ENTRYPOINT:

#!/bin/sh
set -e

if [ "$1" = 'postgres' ]; then
    chown -R postgres "$PGDATA"

    if [ -z "$(ls -A "$PGDATA")" ]; then
        gosu postgres initdb
    fi

    exec gosu postgres "$@"
fi

exec "$@"

Dieses Skript verwendet die eingebaute Funktion exec, sodass die letztendlich ausgeführte Anwendung die PID 1 des Containers erhält

  • Dadurch kann die Anwendung alle an den Container gesendeten Unix-Signale empfangen
  • Weitere Informationen finden Sie in der ENTRYPOINT-Referenz

Im folgenden Beispiel wird ein Hilfsskript in den Container kopiert und beim Start des Containers über ENTRYPOINT ausgeführt:

COPY ./docker-entrypoint.sh /
ENTRYPOINT ["/docker-entrypoint.sh"]
CMD ["postgres"]

Mit diesem Skript können Sie auf verschiedene Arten mit Postgres interagieren

Es kann Postgres starten:

docker run postgres

Oder Sie können damit Postgres ausführen und Parameter an den Server übergeben

docker run postgres postgres --help

Zu guter Letzt kannst du damit auch ein ganz anderes Tool starten, zum Beispiel Bash:

docker run --rm -it postgres bash
Links
  1. https://docs.docker.com/build/building/best-practices/#entrypoint
  2. Dockerfile-Referenz zur ENTRYPOINT-Anweisung

Volume

Sie sollten die Anweisung VOLUME verwenden, um Datenbank-Speicherbereiche, Konfigurationsspeicher oder von Ihrem Docker-Container erstellte Dateien und Ordner freizugeben

  • Es wird dringend empfohlen, VOLUME für jede Kombination aus veränderbaren oder vom Benutzer zu wartenden Teilen Ihres Images zu verwenden
Links
  1. https://docs.docker.com/build/building/best-practices/#volume
  2. Dockerfile-Referenz zur VOLUME-Anweisung

USER

Wenn ein Dienst ohne Sonderrechte ausgeführt werden kann, verwenden Sie USER, um zu einem Nicht-Root-Benutzer zu wechseln

  • Erstellen Sie zunächst den Benutzer und die Gruppe im Dockerfile, etwa wie im folgenden Beispiel:

RUN

groupadd -r postgres && useradd --no-log-init -r -g postgres postgres
Anmerkung
  • Betrachten wir eine explizite UID/GID
  • Benutzern und Gruppen in einem Image wird eine nicht-deterministische UID/GID zugewiesen, da die „nächste“ UID/GID unabhängig von Image-Neuerstellungen vergeben wird
  • Wenn dies also kritisch ist, sollten Sie eine explizite UID/GID zuweisen
Anmerkung
  • unterstützt dieses Flag nicht

Vermeiden Sie die Installation oder Verwendung von sudo, da es ein unvorhersehbares Verhalten hinsichtlich TTY und Signalweiterleitung aufweist, das zu Problemen führen kann

  • Wenn Sie unbedingt eine ähnliche Funktionalität wie bei sudo benötigen, beispielsweise um den Daemon als root zu initialisieren, ihn aber als Nicht-root auszuführen, sollten Sie die Verwendung von „gosu“ in Betracht ziehen

Um die Anzahl der Ebenen und die Komplexität zu reduzieren, sollten Sie es schließlich vermeiden, USER häufig hin und her zu wechseln

Links
  1. https://docs.docker.com/build/building/best-practices/#user
  2. Dockerfile-Referenz zur USER-Anweisung

WORKDIR

Aus Gründen der Übersichtlichkeit und Zuverlässigkeit sollten Sie für Ihr WORKDIR stets absolute Pfade verwenden

  • Außerdem sollten Sie WORKDIR anstelle von sich häufenden Anweisungen wie RUN cd … && do-something verwenden, da diese schwer lesbar sind und die Fehlerbehebung sowie die Wartung erschweren
Links
  1. https://docs.docker.com/build/building/best-practices/#workdir
  2. Dockerfile-Referenz zur Anweisung WORKDIR

ONBUILD

Ein ONBUILD-Befehl wird ausgeführt, nachdem der aktuelle Dockerfile-Build abgeschlossen ist. ONBUILD wird in jedem untergeordneten Image ausgeführt, das FROM das aktuelle Image abgeleitet ist

  • Stellen Sie sich den ONBUILD-Befehl als eine Anweisung vor, die das übergeordnete Dockerfile an das untergeordnete Dockerfile gibt

Bei einem Docker-Build werden ONBUILD-Befehle vor allen Befehlen in einer untergeordneten Dockerfile-Datei ausgeführt

ONBUILD ist nützlich für Images, die FROM ein bestimmtes Image erstellt werden sollen

  • Beispielsweise würden Sie ONBUILD für ein Sprach-Stack-Image verwenden, das beliebige, in dieser Sprache geschriebene Anwendersoftware innerhalb des Dockerfile erstellt, wie Sie in den Ruby-Varianten von ONBUILD sehen können

Mit ONBUILD erstellte Images sollten ein eigenes Tag erhalten

  • Zum Beispiel ruby:1.9-onbuild oder ruby:2.0-onbuild

Seien Sie vorsichtig, wenn Sie ADD oder COPY in ONBUILD einfügen

  • Das Image stürzt katastrophal ab, wenn im Kontext des neuen Builds die hinzugefügte Ressource fehlt
  • Das Hinzufügen eines separaten Tags, wie oben empfohlen, hilft, dieses Problem zu mildern, indem es dem Verfasser des Dockerfiles die Wahl lässt
Links
  1. https://docs.docker.com/build/building/best-practices/#onbuild
  2. Dockerfile-Referenz zur ONBUILD-Anweisung


Anhang

Siehe auch



Dokumentation

Projekt

  1. https://docs.docker.com/reference/dockerfile/
  2. https://docs.docker.com/build/building/best-practices/#dockerfile-instructions