|
|
| (34 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt) |
| Zeile 1: |
Zeile 1: |
| == Mehrstufige Builds ==
| | <noinclude> |
| ; [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.
| | ---- |
| | {{Navigation|<zurück>|<nachste>}} |
| | {{Navigation|BSI/200-3|BSI/200-3/Einleitung/Beispiele}} |
| | ---- |
| | --> |
| | '''{{BASEPAGENAME}}''' |
| | </noinclude> |
|
| |
|
| Durch die Verwendung mehrerer Stufen können Sie zudem effizienter bauen, indem Sie die Bauschritte parallel ausführen.
| | == Beschreibung == |
| | {| class="table table-striped table-hover col1bold col2bold col1nowrap" |
| | |- |
| | | 01 || [[Docker/Image/best-practice/mehrstufige Builds|Mehrstufige Builds]] || Verwenden Sie mehrstufige Builds |
| | |- |
| | | 02 || [[Docker/Image/best-practice/Basisimage|Basis-Images]] || |
| | |- |
| | | 03 || [[Docker/Image/best-practice/Dateien ausschließen|Dateien ausschließen]] || |
| | |- |
| | | 04 || [[Docker/Image/best-practice/Temporäre Container|Temporäre Container]] || |
| | |- |
| | | 05 || [[Docker/Image/best-practice/Pakete|Pakete]] || |
| | |- |
| | | 06 || [[Docker/Image/best-practice/Anwendungen entkoppeln|Anwendungen entkoppeln]] || |
| | |- |
| | | 07 || [[Docker/Image/best-practice/Mehrzeilige Argumente|Mehrzeilige Argumente]] || |
| | |- |
| | | 08 || [[Docker/Image/best-practice/Cache|Cache]] || |
| | |- |
| | | 09 || [[Docker/Image/best-practice/Basisbildes pinnen|Basisbildes pinnen]] || |
| | |- |
| | | 10 || [[Docker/Image/best-practice/Images testen|Images testen]] || |
| | |- |
| | | 11 || [[Docker/Image/best-practice/Dockerfile|Dockerfile]] || |
| | |- |
| | | 12 || [[Docker/Image/best-practice/Maintenance|Maintenance]] || |
| | |} |
|
| |
|
| Weitere Informationen finden Sie unter [https://docs.docker.com/build/building/multi-stage/ Mehrstufige Builds].
| | <noinclude> |
| | <!-- |
| | ---- |
| | {{Navigation|<zurück>|<nachste>}} |
| | ---- |
| | --> |
|
| |
|
| === Wiederverwendbare Phasen === | | == Anhang == |
| ; [https://docs.docker.com/build/building/best-practices/#create-reusable-stages Wiederverwendbare Phasen erstellen]
| | === Siehe auch === |
| | <div style="column-count:2"> |
| | <categorytree hideroot=on mode="pages">{{BASEPAGENAME}}</categorytree> |
| | </div> |
| | ---- |
| | {{Special:PrefixIndex/{{BASEPAGENAME}}/}} |
|
| |
|
| 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.
| | === Dokumentation === |
| | <!-- |
| | ; Man-Page |
| | # [https://manpages.debian.org/stable/procps/pgrep.1.de.html prep(1)] |
|
| |
|
| 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.
| | ; Info-Pages |
|
| |
|
| == Basisimage == | | ; Hinweise |
| * [https://docs.docker.com/build/building/best-practices/#choose-the-right-base-image Wählen Sie das richtige Basisimage aus]
| | <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> |
| | --> |
|
| |
|
| 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.* [https://hub.docker.com/search?badges=official 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.
| | === Links === |
| * [https://hub.docker.com/search?badges=verified_publisher 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.
| | ==== Projekt ==== |
| * [https://hub.docker.com/search?badges=open_source Von Docker geförderte Open-Source-Projekte] werden von Open-Source-Projekten veröffentlicht und gepflegt, die von Docker im Rahmen eines [https://docs.docker.com/docker-hub/image-library/trusted-content/#docker-sponsored-open-source-software-images Open-Source-Programms] gefördert werden.
| | # https://docs.docker.com/build/building/best-practices/ |
|
| |
|
| | ==== Weblinks ==== |
|
| |
|
| | <!-- |
| | {{DEFAULTSORT:new}} |
| | {{DISPLAYTITLE:new}} |
| | --> |
|
| |
|
| Achten Sie bei der Auswahl Ihres Basis-Images auf die Symbole, die darauf hinweisen, dass das Image Teil dieser Programme ist.
| | [[Kategorie:Docker/Image/best-practice]] |
|
| |
|
| [[Image:Bild1.png|top|alt="Docker Hub Official and Verified Publisher images"]][https://docs.docker.com/build/images/hub-official-images.webp]
| | </noinclude> |
| | |
| 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.
| |
| | |
| == Maintenance ==
| |
| ; Erstellen Sie Ihre Images regelmäßig neu
| |
| * [https://docs.docker.com/build/building/best-practices/#rebuild-your-images-often]]
| |
| | |
| 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.
| |
| | |
| === [https://docs.docker.com/build/building/best-practices/#use---pull-to-get-fresh-base-images Verwenden Sie „--pull“, um aktuelle Basis-Images abzurufen] ===
| |
| | |
| Das folgende Dockerfile verwendet das Tag <tt>24.04</tt> des <tt>ubuntu</tt>-Images. Im Laufe der Zeit kann dieses Tag auf eine andere zugrunde liegende Version des <tt>ubuntu</tt>-Images verweisen, da der Herausgeber das Image mit neuen Sicherheitspatches und aktualisierten Bibliotheken neu erstellt.
| |
| | |
| <nowiki># syntax=docker/dockerfile:1</nowiki>
| |
| [https://docs.docker.com/reference/dockerfile/#from FROM] ubuntu:24.04
| |
| [https://docs.docker.com/reference/dockerfile/#run 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 <tt>--pull</tt>:
| |
| | |
| docker build --pull -t my-image:my-tag .
| |
| | |
| Das Flag <tt>--pull</tt> 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.
| |
| | |
| === [https://docs.docker.com/build/building/best-practices/#use---no-cache-for-clean-builds Verwenden Sie „--no-cache“ für saubere Builds] ===
| |
| | |
| Das Flag <tt>--no-cache</tt> 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 <tt>apt-get</tt> oder <tt>npm</tt> abgerufen. Es wird kein neues Basis-Image heruntergeladen – verwenden Sie hierfür <tt>--pull</tt>.
| |
| | |
| 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 [https://docs.docker.com/build/building/best-practices/#pin-base-image-versions das Fixieren von Basisbildversionen].
| |
| | |
| == [https://docs.docker.com/build/building/best-practices/#exclude-with-dockerignore Mit .dockerignore ausschließen] ==
| |
| | |
| Um Dateien auszuschließen, die für den Build nicht relevant sind, ohne Ihr Quell-Repository umzustrukturieren, verwenden Sie eine <tt>.dockerignore</tt>-Datei. Diese Datei unterstützt Ausschlussmuster, die denen von <tt>.gitignore</tt>-Dateien ähneln.
| |
| | |
| Um beispielsweise alle Dateien mit der Erweiterung <tt>.md</tt> auszuschließen:
| |
| | |
| <nowiki>*.md</nowiki>
| |
| | |
| Informationen zum Erstellen einer solchen Datei finden Sie unter [https://docs.docker.com/build/concepts/context/#dockerignore-files Dockerignore-Datei].
| |
| | |
| == [https://docs.docker.com/build/building/best-practices/#create-ephemeral-containers Temporäre Container erstellen] ==
| |
| | |
| 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 [https://12factor.net/processes 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.
| |
| | |
| == [https://docs.docker.com/build/building/best-practices/#dont-install-unnecessary-packages Installieren Sie keine unnötigen Pakete] ==
| |
| | |
| 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.
| |
| | |
| == [https://docs.docker.com/build/building/best-practices/#decouple-applications Anwendungen entkoppeln] ==
| |
| | |
| 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 [https://docs.docker.com/engine/containers/multi-service_container/ mit einem Init-Prozess gestartet werden], sondern manche Programme können auch eigenständig zusätzliche Prozesse starten. So kann beispielsweise [https://docs.celeryq.dev/ Celery] mehrere Worker-Prozesse starten, und [https://httpd.apache.org/ 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 [https://docs.docker.com/engine/network/ Docker-Containernetzwerke] nutzen, um sicherzustellen, dass diese Container miteinander kommunizieren können.
| |
| | |
| == [https://docs.docker.com/build/building/best-practices/#sort-multi-line-arguments Mehrzeilige Argumente sortieren] ==
| |
| | |
| 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 (<tt>\</tt>).
| |
| | |
| Hier ist ein Beispiel aus dem [https://github.com/docker-library/buildpack-deps buildpack-deps-Image]:
| |
| | |
| [https://docs.docker.com/reference/dockerfile/#run RUN] apt-get update && apt-get install -y --no-install-recommends \
| |
| bzr \
| |
| cvs \
| |
| git \
| |
| mercurial \
| |
| subversion \
| |
| && rm -rf /var/lib/apt/lists/*
| |
| | |
| == [https://docs.docker.com/build/building/best-practices/#leverage-build-cache Cache nutzen] ==
| |
| | |
| 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 [https://docs.docker.com/build/cache/ Docker-Build-Cache].
| |
| | |
| == [https://docs.docker.com/build/building/best-practices/#pin-base-image-versions Versionen des Basisbildes pinnen] ==
| |
| | |
| 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 <tt>FROM alpine:3.21</tt> angeben, wird <tt>3.21</tt> als die aktuellste Patch-Version für <tt>3.21</tt> interpretiert.
| |
| | |
| <nowiki># syntax=docker/dockerfile:1</nowiki>
| |
| [https://docs.docker.com/reference/dockerfile/#from FROM] alpine:3.21
| |
| | |
| Zu einem bestimmten Zeitpunkt könnte das Tag <tt>3.21</tt> 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, <tt>3.21</tt>, diesmal jedoch zusätzlich mit einem Digest-Verweis.
| |
| | |
| <nowiki># syntax=docker/dockerfile:1</nowiki>
| |
| [https://docs.docker.com/reference/dockerfile/#from FROM] alpine:3.21@sha256:a8560b36e8b8210634f77d9f7f9efd7ffa463e380b75e2e74aff4511df3ef88c
| |
| | |
| Mit diesem Dockerfile würden Ihre Builds auch dann, wenn der Herausgeber das Tag <tt>3.21</tt> aktualisiert, weiterhin die festgelegte Image-Version verwenden: <tt>a8560b36e8b8210634f77d9f7f9efd7ffa463e380b75e2e74aff4511df3ef88c</tt>.
| |
| | |
| 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 [https://docs.docker.com/scout/policy/#no-outdated-base-images 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 [https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuring-dependabot-version-updates GitHub Dependabot] mit <tt>package-ecosystem: „docker“</tt>. 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 [https://docs.docker.com/reference/cli/docker/scout/recommendations/ docker scout recommendations] einsehen.
| |
| | |
| == [https://docs.docker.com/build/building/best-practices/#build-and-test-your-images-in-ci Erstellen und testen Sie Ihre Images in CI] ==
| |
| | |
| Wenn Sie eine Änderung in die Versionsverwaltung einchecken oder einen Pull-Request erstellen, verwenden Sie [https://docs.docker.com/build/ci/github-actions/ GitHub Actions] oder eine andere CI/CD-Pipeline, um ein Docker-Image automatisch zu erstellen, mit einem Tag zu versehen und zu testen.
| |
| | |
| == [https://docs.docker.com/build/building/best-practices/#dockerfile-instructions Anweisungen für die `Dockerfile`-Datei] ==
| |
| | |
| Befolgen Sie diese Empfehlungen zur korrekten Verwendung der [https://docs.docker.com/reference/dockerfile/ Dockerfile-Anweisungen] , um ein effizientes und wartungsfreundliches Dockerfile zu erstellen.
| |
| | |
| <div style="margin-left:1cm;margin-right:1cm;">Tipp</div>
| |
| | |
| <div style="margin-left:1cm;margin-right:1cm;">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.</div>
| |
| | |
| === [https://docs.docker.com/build/building/best-practices/#from VON] ===
| |
| | |
| 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.
| |
| | |
| Weitere Informationen zur <tt>FROM</tt>-Anweisung finden Sie unter [https://docs.docker.com/reference/dockerfile/#from Dockerfile-Referenz zur FROM-Anweisung].
| |
| | |
| === [https://docs.docker.com/build/building/best-practices/#label 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.
| |
| | |
| 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:
| |
| | |
| <nowiki># Set one or more individual labels</nowiki>
| |
| [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=""
| |
| | |
| 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:
| |
| | |
| <nowiki># Set multiple labels on one line</nowiki>
| |
| [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:
| |
| | |
| <nowiki># Set multiple labels at once, using line-continuation characters to break long lines</nowiki>
| |
| [https://docs.docker.com/reference/dockerfile/#label 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 [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.
| |
| | |
| === [https://docs.docker.com/build/building/best-practices/#run RUN] ===
| |
| | |
| 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.
| |
| | |
| [https://docs.docker.com/reference/dockerfile/#run 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 [https://docs.docker.com/reference/dockerfile/#escape escape-Direktive] ändern.
| |
| | |
| 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
| |
| apt-get update
| |
| apt-get install -y --no-install-recommends \
| |
| package-bar \
| |
| package-baz \
| |
| package-foo
| |
| EOF
| |
| | |
| Weitere Informationen 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/#apt-get 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. Beispiel:
| |
| | |
| [https://docs.docker.com/reference/dockerfile/#run RUN] apt-get update && apt-get install -y --no-install-recommends \
| |
| package-bar \
| |
| package-baz \
| |
| 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:
| |
| | |
| <nowiki># syntax=docker/dockerfile:1</nowiki>
| |
| | |
| [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
| |
| | |
| 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:
| |
| | |
| <nowiki># syntax=docker/dockerfile:1</nowiki>
| |
| | |
| [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
| |
| | |
| 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. Beispiel:
| |
| | |
| [https://docs.docker.com/reference/dockerfile/#run 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 <tt>RUN</tt>-Befehl, der alle <tt>apt-get</tt>- Empfehlungen veranschaulicht.
| |
| | |
| [https://docs.docker.com/reference/dockerfile/#run 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 <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.
| |
| | |
| 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.
| |
| | |
| ==== [https://docs.docker.com/build/building/best-practices/#using-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:
| |
| | |
| [https://docs.docker.com/reference/dockerfile/#run RUN] 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.
| |
| | |
| 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. Zum Beispiel:
| |
| | |
| [https://docs.docker.com/reference/dockerfile/#run RUN] set -o pipefail && wget -O - https://some.site | wc -l > /number
| |
| | |
| <div style="margin-left:1cm;margin-right:1cm;">Anmerkung</div>
| |
| | |
| <div style="margin-left:1cm;margin-right:1cm;">Nicht alle Shells unterstützen die Option <tt>-o pipefail</tt>.</div>
| |
| | |
| <div style="margin-left:1cm;margin-right:1cm;">In Fällen wie der <tt>dash</tt>-Shell auf Debian-basierten Images sollten Sie erwägen, die ''exec''-Form von <tt>RUN</tt> zu verwenden, um explizit eine Shell auszuwählen, die die Option <tt>pipefail</tt> unterstützt. Zum Beispiel:</div>
| |
| | |
| [https://docs.docker.com/reference/dockerfile/#run RUN] ["/bin/bash", "-c", "set -o pipefail && wget -O - https://some.site | wc -l > /number"]
| |
| | |
| === [https://docs.docker.com/build/building/best-practices/#cmd 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.
| |
| | |
| 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].
| |
| | |
| === [https://docs.docker.com/build/building/best-practices/#expose ENTHÜLLEN] ===
| |
| | |
| 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.
| |
| | |
| 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>).
| |
| | |
| Weitere Informationen zu <tt>EXPOSE</tt> finden Sie in der [https://docs.docker.com/reference/dockerfile/#expose Dockerfile-Referenz zur EXPOSE-Anweisung].
| |
| | |
| === [https://docs.docker.com/build/building/best-practices/#env 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.
| |
| | |
| 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:
| |
| | |
| [https://docs.docker.com/reference/dockerfile/#env ENV] PG_MAJOR=9.3
| |
| [https://docs.docker.com/reference/dockerfile/#env ENV] PG_VERSION=9.3.4
| |
| [https://docs.docker.com/reference/dockerfile/#run RUN] curl -SL https://example.com/postgres-$PG_VERSION.tar.xz | tar -xJC /usr/src/postgres && …
| |
| [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.
| |
| | |
| 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.
| |
| | |
| <nowiki># syntax=docker/dockerfile:1</nowiki>
| |
| [https://docs.docker.com/reference/dockerfile/#from FROM] alpine
| |
| [https://docs.docker.com/reference/dockerfile/#env ENV] ADMIN_USER="mark"
| |
| [https://docs.docker.com/reference/dockerfile/#run RUN] echo $ADMIN_USER > ./mark
| |
| [https://docs.docker.com/reference/dockerfile/#run 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 <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><nowiki>;</nowiki></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.
| |
| | |
| <nowiki># syntax=docker/dockerfile:1</nowiki>
| |
| [https://docs.docker.com/reference/dockerfile/#from FROM] alpine
| |
| [https://docs.docker.com/reference/dockerfile/#run RUN] export ADMIN_USER="mark" \
| |
| && echo $ADMIN_USER > ./mark \
| |
| && unset ADMIN_USER
| |
| [https://docs.docker.com/reference/dockerfile/#cmd CMD] sh
| |
| 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].
| |
| | |
| === [https://docs.docker.com/build/building/best-practices/#add-or-copy HINZUFÜGEN oder KOPIEREN] ===
| |
| | |
| <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.
| |
| | |
| 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:
| |
| | |
| [https://docs.docker.com/reference/dockerfile/#run RUN] --mount=type=bind,source=requirements.txt,target=/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>.
| |
| | |
| 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. In Kombination mit mehrstufigen Builds verbleibt in der letzten Stufe nur die .NET-Laufzeitumgebung, keine Zwischen-Dateien.
| |
| | |
| <nowiki># syntax=docker/dockerfile:1</nowiki>
| |
| | |
| [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/#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://docs.docker.com/reference/dockerfile/#from FROM] mcr.microsoft.com/dotnet/runtime-deps:8.0.0-preview.6-bookworm-slim-arm64v8 AS installer
| |
| | |
| <nowiki># Retrieve .NET Runtime</nowiki>
| |
| [https://docs.docker.com/reference/dockerfile/#run RUN] --mount=from=src,target=/src <<EOF
| |
| mkdir -p /dotnet
| |
| 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/#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]
| |
| | |
| | |
| | |
| === [https://docs.docker.com/build/building/best-practices/#entrypoint 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.
| |
| | |
| Im Folgenden finden Sie ein Beispiel für ein Bild für das Befehlszeilentool <tt>s3cmd</tt>:
| |
| | |
| [https://docs.docker.com/reference/dockerfile/#entrypoint ENTRYPOINT] ["s3cmd"]
| |
| [https://docs.docker.com/reference/dockerfile/#cmd 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 <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>:
| |
| | |
| <nowiki>#!/bin/sh</nowiki>
| |
| 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 [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:
| |
| | |
| [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"]
| |
| | |
| 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 <tt>ENTRYPOINT</tt> finden Sie in der [https://docs.docker.com/reference/dockerfile/#entrypoint Dockerfile-Referenz zur ENTRYPOINT-Anweisung].
| |
| | |
| === [https://docs.docker.com/build/building/best-practices/#volume UMFANG] ===
| |
| | |
| 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].
| |
| | |
| === [https://docs.docker.com/build/building/best-practices/#user BENUTZER] ===
| |
| | |
| 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] groupadd -r postgres && useradd --no-log-init -r -g postgres postgres
| |
| | |
| <div style="margin-left:1cm;margin-right:1cm;">Anmerkung</div>
| |
| | |
| <div style="margin-left:1cm;margin-right:1cm;">Betrachten wir eine explizite UID/GID.</div>
| |
| | |
| <div style="margin-left:1cm;margin-right:1cm;">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.</div>
| |
| | |
| <div style="margin-left:1cm;margin-right:1cm;">Anmerkung</div>
| |
| | |
| <div style="margin-left:1cm;margin-right:1cm;">Aufgrund eines [https://github.com/golang/go/issues/13548 ungelösten Fehlers] bei der Verarbeitung von Sparse-Dateien durch das Go-Archiv-/Tar-Paket kann der Versuch, einen Benutzer mit einer sehr hohen UID innerhalb eines Docker-Containers anzulegen, zu einem Speicherplatzmangel führen, da <tt>/var/log/faillog</tt> in der Container-Ebene mit NULL-Zeichen (\0) gefüllt wird. Eine Abhilfe besteht darin, das Flag <tt>--no-log-init</tt> an <tt>useradd</tt> zu übergeben. Der Debian/Ubuntu-Wrapper <tt>adduser</tt> unterstützt dieses Flag nicht.</div>
| |
| | |
| 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.
| |
| | |
| Weitere Informationen zu <tt>USER</tt> finden Sie in der [https://docs.docker.com/reference/dockerfile/#user Dockerfile-Referenz zur USER-Anweisung].
| |
| | |
| === [https://docs.docker.com/build/building/best-practices/#workdir 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.
| |
| | |
| Weitere Informationen zu <tt>WORKDIR</tt> finden Sie in der [https://docs.docker.com/reference/dockerfile/#workdir Dockerfile-Referenz zur Anweisung WORKDIR].
| |
| | |
| === [https://docs.docker.com/build/building/best-practices/#onbuild 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.
| |
| | |
| <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].
| |
| | |
| 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>.
| |
| | |
| 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]]
| |