Docker/Image/best-practice: Unterschied zwischen den Versionen
Keine Bearbeitungszusammenfassung |
|||
| Zeile 1: | Zeile 1: | ||
== [https://docs.docker.com/build/building/best-practices/#use-multi-stage-builds Verwenden Sie mehrstufige Builds] | == Mehrstufige Builds == | ||
; [https://docs.docker.com/build/building/best-practices/#use-multi-stage-builds Verwenden Sie mehrstufige Builds] | |||
Mit mehrstufigen Builds können Sie die Größe Ihres endgültigen Images reduzieren, indem Sie eine klarere Trennung zwischen dem Erstellen Ihres Images und der endgültigen Ausgabe schaffen. Teilen Sie die Anweisungen in Ihrer Dockerfile-Datei in einzelne Phasen auf, um sicherzustellen, dass die resultierende Ausgabe nur die Dateien enthält, die für die Ausführung der Anwendung erforderlich sind. | Mit mehrstufigen Builds können Sie die Größe Ihres endgültigen Images reduzieren, indem Sie eine klarere Trennung zwischen dem Erstellen Ihres Images und der endgültigen Ausgabe schaffen. Teilen Sie die Anweisungen in Ihrer Dockerfile-Datei in einzelne Phasen auf, um sicherzustellen, dass die resultierende Ausgabe nur die Dateien enthält, die für die Ausführung der Anwendung erforderlich sind. | ||
| Zeile 7: | Zeile 7: | ||
Weitere Informationen finden Sie unter [https://docs.docker.com/build/building/multi-stage/ Mehrstufige Builds]. | Weitere Informationen finden Sie unter [https://docs.docker.com/build/building/multi-stage/ Mehrstufige Builds]. | ||
=== [https://docs.docker.com/build/building/best-practices/#create-reusable-stages Wiederverwendbare Phasen erstellen] | === Wiederverwendbare Phasen === | ||
; [https://docs.docker.com/build/building/best-practices/#create-reusable-stages Wiederverwendbare Phasen erstellen] | |||
Wenn Sie mehrere Images haben, die viele Gemeinsamkeiten aufweisen, sollten Sie in Erwägung ziehen, eine wiederverwendbare Stage zu erstellen, die die gemeinsamen Komponenten enthält, und Ihre individuellen Stages darauf aufzubauen. Docker muss die gemeinsame Stage nur einmal erstellen. Das bedeutet, dass Ihre abgeleiteten Images den Arbeitsspeicher auf dem Docker-Host effizienter nutzen und schneller geladen werden. | Wenn Sie mehrere Images haben, die viele Gemeinsamkeiten aufweisen, sollten Sie in Erwägung ziehen, eine wiederverwendbare Stage zu erstellen, die die gemeinsamen Komponenten enthält, und Ihre individuellen Stages darauf aufzubauen. Docker muss die gemeinsame Stage nur einmal erstellen. Das bedeutet, dass Ihre abgeleiteten Images den Arbeitsspeicher auf dem Docker-Host effizienter nutzen und schneller geladen werden. | ||
Version vom 19. November 2026, 22:19 Uhr
Mehrstufige Builds
Mit mehrstufigen Builds können Sie die Größe Ihres endgültigen Images reduzieren, indem Sie eine klarere Trennung zwischen dem Erstellen Ihres Images und der endgültigen Ausgabe schaffen. Teilen Sie die Anweisungen in Ihrer Dockerfile-Datei in einzelne Phasen auf, um sicherzustellen, dass die resultierende Ausgabe nur die Dateien enthält, die für die Ausführung der Anwendung erforderlich sind.
Durch die Verwendung mehrerer Stufen können Sie zudem effizienter bauen, indem Sie die Bauschritte parallel ausführen.
Weitere Informationen finden Sie unter Mehrstufige Builds.
Wiederverwendbare Phasen
Wenn Sie mehrere Images haben, die viele Gemeinsamkeiten aufweisen, sollten Sie in Erwägung ziehen, eine wiederverwendbare Stage zu erstellen, die die gemeinsamen Komponenten enthält, und Ihre individuellen Stages darauf aufzubauen. Docker muss die gemeinsame Stage nur einmal erstellen. Das bedeutet, dass Ihre abgeleiteten Images den Arbeitsspeicher auf dem Docker-Host effizienter nutzen und schneller geladen werden.
Außerdem ist es einfacher, eine gemeinsame Basisebene zu pflegen („Don’t repeat yourself“), als mehrere verschiedene Ebenen zu haben, die ähnliche Aufgaben erfüllen.
Der erste Schritt zur Erstellung eines sicheren Images ist die Auswahl des richtigen Basis-Images. Achten Sie bei der Auswahl eines Images darauf, dass es aus einer vertrauenswürdigen Quelle stammt, und halten Sie es möglichst klein.* Offizielle Docker-Images sind eine sorgfältig zusammengestellte Sammlung, die über eine klare Dokumentation verfügt, bewährte Verfahren fördert und regelmäßig aktualisiert wird. Sie bieten einen zuverlässigen Ausgangspunkt für viele Anwendungen.
- Verifizierte Anbieter-Bilder sind hochwertige Bilder, die von den Organisationen veröffentlicht und gepflegt werden, die mit Docker zusammenarbeiten, wobei Docker die Echtheit der Inhalte in deren Repositorys überprüft.
- Von Docker geförderte Open-Source-Projekte werden von Open-Source-Projekten veröffentlicht und gepflegt, die von Docker im Rahmen eines Open-Source-Programms gefördert werden.
Achten Sie bei der Auswahl Ihres Basis-Images auf die Symbole, die darauf hinweisen, dass das Image Teil dieser Programme ist.
"Docker Hub Official and Verified Publisher images"[1]
Achten Sie beim Erstellen Ihres eigenen Images anhand einer Dockerfile darauf, ein minimales Basis-Image zu wählen, das Ihren Anforderungen entspricht. Ein kleineres Basis-Image bietet nicht nur Portabilität und schnelle Downloads, sondern verringert auch die Größe Ihres Images und minimiert die Anzahl der durch die Abhängigkeiten verursachten Sicherheitslücken.
Sie sollten außerdem in Erwägung ziehen, zwei Arten von Basis-Images zu verwenden: eines für die Erstellung und die Unit-Tests und ein weiteres (in der Regel schlankeres) Image für die Produktion. In den späteren Phasen der Entwicklung benötigt Ihr Image möglicherweise keine Build-Tools wie Compiler, Build-Systeme und Debugging-Tools mehr. Ein kleines Image mit minimalen Abhängigkeiten kann die Angriffsfläche erheblich verringern.
Docker-Images sind unveränderlich. Beim Erstellen eines Images wird ein Snapshot dieses Images zu diesem Zeitpunkt erstellt. Dazu gehören alle Basis-Images, Bibliotheken oder andere Software, die Sie bei der Erstellung verwenden. Um Ihre Images auf dem neuesten Stand und sicher zu halten, sollten Sie Ihre Images regelmäßig mit aktualisierten Abhängigkeiten neu erstellen.
Das folgende Dockerfile verwendet das Tag 24.04 des ubuntu-Images. Im Laufe der Zeit kann dieses Tag auf eine andere zugrunde liegende Version des ubuntu-Images verweisen, da der Herausgeber das Image mit neuen Sicherheitspatches und aktualisierten Bibliotheken neu erstellt.
# syntax=docker/dockerfile:1 FROM ubuntu:24.04 RUN apt-get -y update && apt-get install -y --no-install-recommends python3
Um die neueste Version des Basis-Images zu erhalten, verwenden Sie das Flag --pull:
docker build --pull -t my-image:my-tag .
Das Flag --pull zwingt Docker dazu, nach einer neueren Version des Basis-Images zu suchen und diese herunterzuladen, selbst wenn Sie eine Version lokal im Cache gespeichert haben.
Das Flag --no-cache deaktiviert den Build-Cache und zwingt Docker dazu, alle Layer von Grund auf neu zu erstellen:
docker build --no-cache -t my-image:my-tag .
Dadurch werden die neuesten verfügbaren Versionen der Abhängigkeiten von Paketverwaltern wie apt-get oder npm abgerufen. Es wird kein neues Basis-Image heruntergeladen – verwenden Sie hierfür --pull.
Die beiden Flags dienen unterschiedlichen Zwecken und können kombiniert werden. Verwenden Sie beide zusammen, um ein neues Basis-Image zu erhalten, und führen Sie alle Build-Schritte erneut aus:
docker build --pull --no-cache -t my-image:my-tag .
Berücksichtigen Sie auch das Fixieren von Basisbildversionen.
Um Dateien auszuschließen, die für den Build nicht relevant sind, ohne Ihr Quell-Repository umzustrukturieren, verwenden Sie eine .dockerignore-Datei. Diese Datei unterstützt Ausschlussmuster, die denen von .gitignore-Dateien ähneln.
Um beispielsweise alle Dateien mit der Erweiterung .md auszuschließen:
*.md
Informationen zum Erstellen einer solchen Datei finden Sie unter Dockerignore-Datei.
Das in Ihrer Dockerfile definierte Image sollte Container erzeugen, die so kurzlebig wie möglich sind. Kurzlebig bedeutet, dass der Container angehalten und gelöscht, anschließend neu erstellt und mit einem absoluten Minimum an Einrichtung und Konfiguration ersetzt werden kann.
Lesen Sie den Abschnitt Prozesse unter der Methodik „The Twelve-Factor App“, um ein Gefühl dafür zu bekommen, warum Container auf diese zustandslose Weise ausgeführt werden.
Vermeiden Sie es, zusätzliche oder unnötige Pakete zu installieren, nur weil sie vielleicht ganz praktisch sein könnten. So brauchen Sie beispielsweise in einem Datenbank-Image keinen Texteditor einzubinden.
Wenn Sie die Installation zusätzlicher oder unnötiger Pakete vermeiden, weisen Ihre Images eine geringere Komplexität, weniger Abhängigkeiten, kleinere Dateigrößen und kürzere Erstellungszeiten auf.
Jeder Container sollte nur eine Aufgabe erfüllen. Die Entkopplung von Anwendungen in mehrere Container erleichtert die horizontale Skalierung und die Wiederverwendung von Containern. Beispielsweise könnte ein Webanwendungs-Stack aus drei separaten Containern bestehen, von denen jeder über ein eigenes Image verfügt, um die Webanwendung, die Datenbank und einen In-Memory-Cache entkoppelt zu verwalten.
Jeden Container auf einen Prozess zu beschränken, ist eine gute Faustregel, aber keine unumstößliche Regel. Beispielsweise können Container nicht nur mit einem Init-Prozess gestartet werden, sondern manche Programme können auch eigenständig zusätzliche Prozesse starten. So kann beispielsweise Celery mehrere Worker-Prozesse starten, und Apache kann pro Anfrage einen Prozess erstellen.
Entscheiden Sie nach bestem Ermessen, die Container so sauber und modular wie möglich zu halten. Wenn Container voneinander abhängig sind, können Sie Docker-Containernetzwerke nutzen, um sicherzustellen, dass diese Container miteinander kommunizieren können.
Sortieren Sie mehrzeilige Argumente nach Möglichkeit alphanumerisch, um die Pflege zu vereinfachen. Dadurch lassen sich Doppelungen bei den Paketen vermeiden und die Liste lässt sich viel einfacher aktualisieren. Außerdem werden PRs dadurch wesentlich lesbarer und leichter zu prüfen. Es ist ebenfalls hilfreich, vor einem Backslash ein Leerzeichen einzufügen (\).
Hier ist ein Beispiel aus dem buildpack-deps-Image:
RUN apt-get update && apt-get install -y --no-install-recommends \
bzr \ cvs \ git \ mercurial \ subversion \ && rm -rf /var/lib/apt/lists/*
Beim Erstellen eines Images arbeitet Docker die Anweisungen in Ihrer Dockerfile der Reihe nach ab und führt sie in der angegebenen Reihenfolge aus. Bei jeder Anweisung prüft Docker, ob er die Anweisung aus dem Build-Cache wiederverwenden kann.
Um schnellere Builds zu gewährleisten, ist es entscheidend, die Funktionsweise des Build-Caches und den Ablauf der Cache-Invalidierung zu verstehen. Weitere Informationen zum Docker-Build-Cache und zur Optimierung Ihrer Builds finden Sie unter Docker-Build-Cache.
Bild-Tags sind veränderbar, das heißt, ein Herausgeber kann ein Tag aktualisieren, sodass es auf ein neues Bild verweist. Dies ist nützlich, da Herausgeber dadurch Tags so anpassen können, dass sie auf neuere Versionen eines Bildes verweisen. Für Sie als Nutzer des Bildes bedeutet dies, dass Sie automatisch die neue Version erhalten, wenn Sie Ihr Bild neu erstellen.
Wenn Sie beispielsweise in Ihrer Dockerfile-Datei FROM alpine:3.21 angeben, wird 3.21 als die aktuellste Patch-Version für 3.21 interpretiert.
# syntax=docker/dockerfile:1 FROM alpine:3.21
Zu einem bestimmten Zeitpunkt könnte das Tag 3.21 auf die Version 3.21.1 des Images verweisen. Wenn Sie das Image drei Monate später neu erstellen, könnte dasselbe Tag auf eine andere Version verweisen, beispielsweise 3.21.4. Dieser Veröffentlichungsworkflow entspricht den Best Practices, und die meisten Herausgeber wenden diese Tagging-Strategie an, sie ist jedoch nicht zwingend vorgeschrieben.
Der Nachteil dabei ist, dass nicht garantiert ist, dass Sie bei jedem Build dasselbe erhalten. Dies könnte zu kompatibilitätsbrechenden Änderungen führen, und es bedeutet außerdem, dass Sie keinen Nachweis über die genauen Image-Versionen haben, die Sie verwenden.
Um die Integrität Ihrer Lieferkette vollständig zu gewährleisten, können Sie die Image-Version an einen bestimmten Digest binden. Indem Sie Ihre Images an einen Digest binden, stellen Sie sicher, dass immer dieselbe Image-Version verwendet wird, selbst wenn ein Herausgeber das Tag durch ein neues Image ersetzt. Das folgende Dockerfile bindet beispielsweise das Alpine-Image an dasselbe Tag wie zuvor, 3.21, diesmal jedoch zusätzlich mit einem Digest-Verweis.
# syntax=docker/dockerfile:1 FROM alpine:3.21@sha256:a8560b36e8b8210634f77d9f7f9efd7ffa463e380b75e2e74aff4511df3ef88c
Mit diesem Dockerfile würden Ihre Builds auch dann, wenn der Herausgeber das Tag 3.21 aktualisiert, weiterhin die festgelegte Image-Version verwenden: a8560b36e8b8210634f77d9f7f9efd7ffa463e380b75e2e74aff4511df3ef88c.
Das hilft Ihnen zwar, unerwartete Änderungen zu vermeiden, ist aber auch mühsamer, da Sie jedes Mal, wenn Sie das Basis-Image aktualisieren möchten, den Image-Digest für die jeweiligen Versionen manuell nachschlagen und einfügen müssen. Außerdem verzichten Sie damit auf automatische Sicherheitsupdates, die Sie wahrscheinlich gerne erhalten möchten.
Die Standardrichtlinie Keine veralteten Basis-Images von Docker Scout prüft, ob die von Ihnen verwendete Basis-Image-Version tatsächlich die aktuellste ist. Diese Richtlinie prüft außerdem, ob die in Ihrem Dockerfile festgelegten Digests der richtigen Version entsprechen. Wenn ein Herausgeber ein Image aktualisiert, das Sie fixiert haben, gibt die Richtlinienauswertung den Status „nicht konform“ zurück, was darauf hinweist, dass Sie Ihr Image aktualisieren sollten.
Um Ihre Basis-Images automatisch auf dem neuesten Stand zu halten, verwenden Sie GitHub Dependabot mit package-ecosystem: „docker“. Dependabot erstellt Pull-Anfragen, um die Tags und Digests Ihrer Basis-Images nach einem festgelegten Zeitplan zu aktualisieren. Dies ist besser als die Verwendung eines Tags, das die Version automatisch ändert, da Sie die Kontrolle behalten und über einen Prüfpfad verfügen, aus dem hervorgeht, wann und wie die Änderung erfolgte.
Sie können die verfügbaren Updates für Basis-Images auch über die Befehlszeile mit docker scout recommendations einsehen.
Wenn Sie eine Änderung in die Versionsverwaltung einchecken oder einen Pull-Request erstellen, verwenden Sie GitHub Actions oder eine andere CI/CD-Pipeline, um ein Docker-Image automatisch zu erstellen, mit einem Tag zu versehen und zu testen.
Befolgen Sie diese Empfehlungen zur korrekten Verwendung der Dockerfile-Anweisungen , um ein effizientes und wartungsfreundliches Dockerfile zu erstellen.
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.
Weitere Informationen zur FROM-Anweisung finden Sie unter Dockerfile-Referenz zur FROM-Anweisung.
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. Zum 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. Informationen zum Abfragen von Labels finden Sie in den Abschnitten zum Filtern unter Labels für Objekte verwalten. Siehe auch LABEL in der Dockerfile-Referenz.
Teilen Sie lange oder komplexe RUN-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 && verketten 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.
Sie können auch Here-Dokumente verwenden, um mehrere Befehle auszuführen, ohne sie mit einem Pipeline-Operator zu verketten:
RUN <<EOF apt-get update apt-get install -y --no-install-recommends \
package-bar \ package-baz \ package-foo
EOF
Weitere Informationen zu RUN finden Sie in der Dockerfile-Referenz zur RUN-Anweisung.
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:
RUN 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.
RUN 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.
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:
RUN 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. Zum Beispiel:
RUN set -o pipefail && wget -O - https://some.site | wc -l > /number
RUN ["/bin/bash", "-c", "set -o pipefail && wget -O - https://some.site | wc -l > /number"]
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 beispielsweise 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.
Weitere Informationen zu CMD finden Sie in der Dockerfile-Referenz zur CMD-Anweisung.
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).
Weitere Informationen zu EXPOSE finden Sie in der Dockerfile-Referenz zur EXPOSE-Anweisung.
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.
# 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.
# 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'
Weitere Informationen zu ENV finden Sie unter Dockerfile-Referenz zur ENV-Anweisung.
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. Beispielsweise, um vorübergehend eine requirements.txt-Datei für eine RUN pip install-Anweisung hinzuzufü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
Weitere Informationen zu ADD oder COPY finden Sie hier:* Dockerfile-Referenz für die Anweisung „ADD“
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
Weitere Informationen zu ENTRYPOINT finden Sie in der Dockerfile-Referenz zur ENTRYPOINT-Anweisung.
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.
Weitere Informationen zu VOLUME finden Sie in der Dockerfile-Referenz zur VOLUME-Anweisung.
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
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.
Weitere Informationen zu USER finden Sie in der Dockerfile-Referenz zur USER-Anweisung.
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.
Weitere Informationen zu WORKDIR finden Sie in der Dockerfile-Referenz zur Anweisung WORKDIR.
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.
Weitere Informationen zu ONBUILD finden Sie in der Dockerfile-Referenz zur ONBUILD-Anweisung.