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

Aus Foxwiki
Wechseln zu:Navigation, Suche
 
(33 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.
 
# [[Docker/Image/best-practice/Dockerfile]]

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