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

Aus Foxwiki
Wechseln zu:Navigation, Suche
Keine Bearbeitungszusammenfassung
 
(20 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 1: Zeile 1:
<noinclude>
<!--
----
{{Navigation|<zurück>|<nachste>}}
{{Navigation|BSI/200-3|BSI/200-3/Einleitung/Beispiele}}
----
-->
'''{{BASEPAGENAME}}''' - Empfehlungen zur Verwendung von Dockerfile-Anweisungen
</noinclude>
== Beschreibung ==
== Beschreibung ==
; Effiziente und wartungsfreundliche Dockerfiles
; Effiziente und wartungsfreundliche Dockerfiles erstellen
Befolgen Sie folgende Empfehlungen zur korrekten Verwendung der Dockerfile-Anweisungen
Empfehlungen zur korrekten Verwendung der Dockerfile-Anweisungen
* https://docs.docker.com/reference/dockerfile/
* https://docs.docker.com/build/building/best-practices/#dockerfile-instructions
 
== VON ==
* https://docs.docker.com/build/building/best-practices/#from


== FROM ==
Verwenden Sie nach Möglichkeit aktuelle offizielle Images als Grundlage für Ihre Images
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
* 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


Weitere Informationen zur <tt>FROM</tt>-Anweisung finden Sie unter [https://docs.docker.com/reference/dockerfile/#from Dockerfile-Referenz zur FROM-Anweisung]
; Links
# https://docs.docker.com/reference/dockerfile/#from Dockerfile-Referenz zur FROM-Anweisung
# https://docs.docker.com/build/building/best-practices/#from


== LABEL ==
== LABEL ==
* https://docs.docker.com/build/building/best-practices/#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
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
* 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
Zeile 36: Zeile 42:
* 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
* 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
* Dies ist nun nicht mehr erforderlich, die Zusammenfassung von Labels wird jedoch weiterhin unterstützt
* Beispiel:


# Set multiple labels on one line
; Beispiel
[https://docs.docker.com/reference/dockerfile/#label LABEL] com.example.version="0.0.1-beta" com.example.release-date="2015-02-12"
# 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"


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= \
Zeile 53: Zeile 58:
* 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]
* 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 auch [https://docs.docker.com/reference/dockerfile/#label LABEL] in der Dockerfile-Referenz
; Links
* https://docs.docker.com/build/building/best-practices/#label


== RUN ==
== RUN ==
* https://docs.docker.com/build/building/best-practices/#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


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
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 \
Beispielsweise können Sie Befehle mit dem Operator <tt>&&</tt> verketten 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 \
Zeile 68: Zeile 75:
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 79: 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 ===
=== 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>
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
* 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
Zeile 91: Zeile 96:


; 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 158: Zeile 161:


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
; Links
* https://docs.docker.com/build/building/best-practices/#apt-get


=== Pipes ===
=== Pipes ===
* https://docs.docker.com/build/building/best-practices/#using-pipes Verwendung von
; 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


Zeile 172: Zeile 176:


; 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
["/bin/bash", "-c", "set -o pipefail && wget -O - https://some.site | wc -l > /number"]
; Links
* [https://docs.docker.com/build/building/best-practices/#using-pipes Verwendung von Pipes]
* [https://docs.docker.com/reference/dockerfile/#run RUN]
* [https://docs.docker.com/reference/dockerfile/#run RUN]
["/bin/bash", "-c", "set -o pipefail && wget -O - https://some.site | wc -l > /number"]


== CMD ==
== CMD ==
* https://docs.docker.com/build/building/best-practices/#cmd
Der Befehl <tt>CMD</tt> sollte verwendet werden, um die in Ihrem Image enthaltene Software zusammen mit etwaigen Argumenten auszuführen
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
* <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
* 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
* Tatsächlich wird diese Form des Befehls für jedes dienstbasierte Image empfohlen


In den meisten anderen Fällen sollte <tt>CMD</tt> eine interaktive Shell erhalten, wie beispielsweise bash, Python oder Perl
In den meisten anderen Fällen sollte <tt>CMD</tt> eine interaktive Shell erhalten, wie bash, Python oder Perl
* Zum Beispiel <tt>CMD ["perl", "-de0"]</tt>, <tt>CMD ["python"]</tt> oder <tt>CMD ["php", "-a"]</tt>
* 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
* 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]
; Links
# [https://docs.docker.com/reference/dockerfile/#cmd Dockerfile-Referenz zur CMD-Anweisung]
# https://docs.docker.com/build/building/best-practices/#cmd


== EXPOSE ==
== EXPOSE ==
* https://docs.docker.com/build/building/best-practices/#expose
Die Anweisung <tt>EXPOSE</tt> gibt die Ports an, auf denen ein Container auf Verbindungen wartet
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
* Daher sollten Sie den gängigen, herkömmlichen Port für Ihre Anwendung verwenden
Zeile 201: Zeile 207:
* 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>)
* 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>)


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


== ENV ==
== ENV ==
* https://docs.docker.com/build/building/best-practices/#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
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
* So stellt beispielsweise <tt>ENV PATH=/usr/local/nginx/bin:$PATH</tt> sicher, dass <tt>CMD ["nginx"]</tt> einfach funktioniert
Zeile 248: 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 ==
== KOPIEREN ==
* 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>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>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


Meistens werden Sie <tt>COPY</tt> verwenden wollen, um Dateien in einem mehrstufigen Build von einer Stufe in eine andere zu kopieren
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
* 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:


[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


Zeile 266: Zeile 277:
* Wenn Sie Dateien aus dem Build-Kontext in das endgültige Image einbinden möchten, verwenden Sie <tt>COPY</tt>
* Wenn Sie Dateien aus dem Build-Kontext in das endgültige Image einbinden möchten, verwenden Sie <tt>COPY</tt>


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]
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]


Im folgenden Beispiel wird <tt>ADD</tt> verwendet, um ein .NET-Installationsprogramm herunterzuladen
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
* In Kombination mit mehrstufigen Builds verbleibt in der letzten Stufe nur die .NET-Laufzeitumgebung, keine Zwischen-Dateien


# syntax=docker/dockerfile:1
# syntax=docker/dockerfile:1
 
[https://docs.docker.com/reference/dockerfile/#from FROM] scratch AS src
[https://docs.docker.com/reference/dockerfile/#from FROM] scratch AS src
[https://docs.docker.com/reference/dockerfile/#arg ARG] DOTNET_VERSION=8.0.0-preview.6.23329.7
[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://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


Zeile 322: 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 "$@"


Zeile 340: Zeile 350:


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/#copy COPY] ./docker-entrypoint.sh /
[https://docs.docker.com/reference/dockerfile/#entrypoint ENTRYPOINT] ["/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/#cmd CMD] ["postgres"]


Mit diesem Skript können Sie auf verschiedene Arten mit Postgres interagieren
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


== Volume ==
Sie sollten die Anweisung <tt>VOLUME</tt> verwenden, um Datenbank-Speicherbereiche, Konfigurationsspeicher oder von Ihrem Docker-Container erstellte Dateien und Ordner freizugeben
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
* 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]
; Links
 
# https://docs.docker.com/build/building/best-practices/#volume
== BENUTZER ==
# [https://docs.docker.com/reference/dockerfile/#volume Dockerfile-Referenz zur VOLUME-Anweisung]
* https://docs.docker.com/build/building/best-practices/#user


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


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


== WORKDIR ==
== WORKDIR ==
* https://docs.docker.com/build/building/best-practices/#workdir
Aus Gründen der Übersichtlichkeit und Zuverlässigkeit sollten Sie für Ihr <tt>WORKDIR</tt> stets absolute Pfade verwenden
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
* 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


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


== ONBUILD ==
== ONBUILD ==
* https://docs.docker.com/build/building/best-practices/#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
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
* Stellen Sie sich den <tt>ONBUILD</tt>-Befehl als eine Anweisung vor, die das übergeordnete Dockerfile an das untergeordnete Dockerfile gibt
Zeile 419: Zeile 425:
* Das Hinzufügen eines separaten Tags, wie oben empfohlen, hilft, dieses Problem zu mildern, indem es dem Verfasser des Dockerfiles die Wahl lässt
* 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]
; Links
# https://docs.docker.com/build/building/best-practices/#onbuild
# [https://docs.docker.com/reference/dockerfile/#onbuild Dockerfile-Referenz zur ONBUILD-Anweisung]
 
<noinclude>
<!--
----
{{Navigation|<zurück>|<nachste>}}
----
-->
 
== Anhang ==
=== Siehe auch ===
<div style="column-count:2">
<categorytree hideroot=on mode="pages">{{BASEPAGENAME}}</categorytree>
</div>
----
{{Special:PrefixIndex/{{BASEPAGENAME}}/}}
 
=== Dokumentation ===
<!--
; Man-Page
# [https://manpages.debian.org/stable/procps/pgrep.1.de.html prep(1)]
 
; Info-Pages
 
; 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>
-->
 
=== Links ===
==== Projekt ====
==== Weblinks ====
# https://docs.docker.com/reference/dockerfile/
# https://docs.docker.com/build/building/best-practices/#dockerfile-instructions
 
<!--
{{DEFAULTSORT:new}}
{{DISPLAYTITLE:new}}
-->
 
 


[[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