💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken
Dieser umfassende Leitfaden behandelt die grundlegenden Konzepte und Best Practices für die Erstellung von Docker-Images von Grund auf. Sie lernen, wie Sie Docker-Images erstellen, deren Größe optimieren, Versionierung und Tagging verwalten und den gesamten Lebenszyklus Ihrer Docker-Images handhaben. Ob Sie neu bei Docker sind oder ein erfahrener Benutzer, dieser Tutorial wird Sie mit dem Wissen und den Werkzeugen ausstatten, um die Kunst der Docker-Image-Erstellung zu meistern.
Docker-Images sind die Grundlage von Docker-Containern, den grundlegenden Einheiten der Bereitstellung im Docker-Ökosystem. Ein Docker-Image ist eine schreibgeschützte Vorlage, die eine Reihe von Anweisungen zum Erstellen eines Docker-Containers enthält. Diese Anweisungen beinhalten den Anwendungscode, die Laufzeitumgebung, Systemtools, Bibliotheken und alle anderen Abhängigkeiten, die zum Ausführen der Anwendung erforderlich sind.
Docker-Images werden mithilfe einer Reihe von Anweisungen, dem Dockerfile, erstellt. Ein Dockerfile ist eine Textdatei, die alle Befehle enthält, die ein Benutzer benötigt, um ein Docker-Image zu erstellen. Beim Erstellen eines Docker-Images liest Docker die Anweisungen aus dem Dockerfile und erstellt das Image Schicht für Schicht.
Docker-Images werden in einem Docker-Registry gespeichert, einem zentralen Repository für Docker-Images. Das bekannteste Docker-Registry ist Docker Hub, ein öffentliches Registry, in dem Benutzer Docker-Images teilen und herunterladen können.
Docker-Images können verwendet werden, um mehrere Instanzen derselben Anwendung zu erstellen, um eine konsistente und zuverlässige Bereitstellung in verschiedenen Umgebungen sicherzustellen. Sie bieten auch eine Möglichkeit, Anwendungen zu verpacken und zu verteilen, was die gemeinsame Nutzung und Zusammenarbeit an Projekten erleichtert.
| Befehl | Beschreibung |
|---|---|
docker build |
Erstellt ein Docker-Image aus einem Dockerfile |
docker pull |
Zieht ein Docker-Image aus einem Registry herunter |
docker push |
Schiebt ein Docker-Image in ein Registry hoch |
docker run |
Führt einen Docker-Container aus einem Docker-Image aus |
In den folgenden Abschnitten werden wir tiefer in den Prozess der Erstellung von Docker-Images von Grund auf, der Verwaltung von Image-Schichten und Caching, der Optimierung der Imagegröße und der Best Practices für die Docker-Image-Erstellung eintauchen.
Das Erstellen von Docker-Images von Grund auf beinhaltet die Erstellung eines Dockerfiles und die Verwendung des Befehls docker build, um das Image zu erstellen. Hier ist eine Schritt-für-Schritt-Anleitung zum Erstellen eines Docker-Images von Grund auf:
Ein Dockerfile ist eine Textdatei, die die Anweisungen zum Erstellen eines Docker-Images enthält. Hier ist ein Beispiel-Dockerfile:
## Verwendung des neuesten Ubuntu-Basis-Images
FROM ubuntu:latest
## Festlegung des Arbeitsverzeichnisses
WORKDIR /app
## Kopieren des Anwendungscodes
COPY . /app
## Installieren der benötigten Abhängigkeiten
RUN apt-get update && apt-get install -y \
python3 \
python3-pip
## Installieren der Anwendungsabhängigkeiten
RUN pip3 install -r requirements.txt
## Exponieren des Anwendungsports
EXPOSE 8080
## Festlegung des Befehls zum Ausführen der Anwendung
CMD ["python3", "app.py"]Dieses Dockerfile verwendet das neueste Ubuntu-Basis-Image, legt das Arbeitsverzeichnis fest, kopiert den Anwendungscode, installiert die benötigten Abhängigkeiten, exponiert den Anwendungsport und legt den Befehl zum Ausführen der Anwendung fest.
Um das Docker-Image zu erstellen, führen Sie den folgenden Befehl im selben Verzeichnis wie das Dockerfile aus:
docker build -t my-app .Dieser Befehl erstellt das Docker-Image mit dem Tag my-app mithilfe des Dockerfiles im aktuellen Verzeichnis.
Nach dem Erstellen des Docker-Images können Sie es mit den folgenden Befehlen überprüfen:
## Auflisten aller Docker-Images
docker images
## Überprüfen der Details des Docker-Images
docker inspect my-appDer Befehl docker images listet alle Docker-Images auf Ihrem System auf, und der Befehl docker inspect liefert detaillierte Informationen zu einem bestimmten Docker-Image.
Durch das Erstellen von Docker-Images von Grund auf haben Sie die vollständige Kontrolle über den Inhalt des Images und stellen sicher, dass Ihre Anwendung und ihre Abhängigkeiten korrekt und konsistent in verschiedenen Umgebungen verpackt sind.
Docker-Images werden in Schichten aufgebaut, wobei jede Zeile im Dockerfile eine neue Schicht darstellt. Diese Schichten werden von Docker zwischengespeichert, was den Build-Prozess erheblich beschleunigen kann.
Wenn Sie ein Docker-Image erstellen, erzeugt jede Anweisung im Dockerfile eine neue Schicht. Diese Schichten werden übereinander gestapelt und bilden das endgültige Image. Beispielsweise würde das Dockerfile aus dem vorherigen Abschnitt die folgenden Schichten erzeugen:
Docker zwischenspeichert die Schichten eines Images. Wenn sich eine Schicht nicht geändert hat, kann Docker die zwischengespeicherte Version wiederverwenden, anstatt sie neu zu erstellen. Dies kann den Build-Prozess, insbesondere bei größeren Images, erheblich beschleunigen.
Um das Caching von Docker zu nutzen, ist es wichtig, die Anweisungen in Ihrem Dockerfile von den am wenigsten bis zu den am häufigsten veränderten anzuordnen. Dies stellt sicher, dass die zwischengespeicherten Schichten während des Build-Prozesses so weit wie möglich wiederverwendet werden können.
Hier ist ein Beispiel für ein Dockerfile, das das Caching nutzt:
## Verwendung des neuesten Ubuntu-Basis-Images
FROM ubuntu:latest
## Festlegung des Arbeitsverzeichnisses
WORKDIR /app
## Kopieren des Anwendungscodes
COPY . /app
## Installieren der benötigten Abhängigkeiten
RUN apt-get update && apt-get install -y \
python3 \
python3-pip
## Installieren der Anwendungsabhängigkeiten
RUN pip3 install -r requirements.txt
## Exponieren des Anwendungsports
EXPOSE 8080
## Festlegung des Befehls zum Ausführen der Anwendung
CMD ["python3", "app.py"]In diesem Beispiel wird die COPY-Anweisung vor den RUN-Anweisungen platziert, die Abhängigkeiten installieren. Dies stellt sicher, dass, wenn sich der Anwendungscode nicht geändert hat, die zwischengespeicherten Schichten wiederverwendet werden können, wodurch der Build-Prozess beschleunigt wird.
Durch das Verständnis der Funktionsweise von Docker-Image-Schichten und Caching können Sie Ihren Build-Prozess optimieren und sicherstellen, dass Ihre Docker-Images effizient und konsistent erstellt werden.
Die Größe Ihrer Docker-Images klein zu halten ist aus mehreren Gründen wichtig, darunter schnellere Downloads, geringere Speicheranforderungen und verbesserte Leistung. Hier sind einige Techniken, die Sie verwenden können, um die Größe Ihrer Docker-Images zu optimieren:
Das Basis-Image, das Sie für Ihr Docker-Image auswählen, kann einen erheblichen Einfluss auf die endgültige Imagegröße haben. Wählen Sie ein möglichst kleines Basis-Image, z. B. die alpine- oder scratch-Images, die deutlich kleiner sind als die traditionellen ubuntu- oder centos-Images.
Jede Anweisung in Ihrem Dockerfile erzeugt eine neue Schicht im Image. Je mehr Schichten Sie haben, desto größer wird die endgültige Imagegröße. Versuchen Sie, mehrere Anweisungen nach Möglichkeit in einer einzigen Schicht zu kombinieren.
Multi-Stage-Builds ermöglichen es Ihnen, mehrere FROM-Anweisungen in Ihrem Dockerfile zu verwenden, jede mit einem anderen Basis-Image. Dies kann nützlich sein, um komplexe Anwendungen zu erstellen, die mehrere Abhängigkeiten benötigen, während die endgültige Imagegröße klein bleibt.
Hier ist ein Beispiel für ein Multi-Stage-Dockerfile:
## Build-Phase
FROM golang:1.16 AS builder
WORKDIR /app
COPY . .
RUN go build -o myapp
## Endphase
FROM alpine:latest
WORKDIR /app
COPY --from=builder /app/myapp .
CMD ["./myapp"]In diesem Beispiel verwendet die erste Phase das golang:1.16-Image, um die Anwendung zu erstellen, während die letzte Phase das deutlich kleinere alpine:latest-Image verwendet, um die Anwendung auszuführen.
Stellen Sie sicher, dass Sie nur die Pakete und Abhängigkeiten installieren, die für den Betrieb Ihrer Anwendung erforderlich sind. Entfernen Sie alle unnötigen Pakete oder Tools, um die Imagegröße zu reduzieren.
Die Datei .dockerignore ermöglicht es Ihnen, Dateien und Verzeichnisse aus dem Docker-Build-Kontext auszuschließen, was die Größe des endgültigen Images erheblich reduzieren kann.
Indem Sie diese Techniken befolgen, können Sie die Größe Ihrer Docker-Images optimieren, wodurch sie effizienter und einfacher zu verwalten sind.
Die Versionierung und das Tagging von Docker-Images ist ein wichtiger Aspekt der Verwaltung Ihrer Docker-basierten Anwendungen. Eine korrekte Versionierung und das Tagging helfen Ihnen, Änderungen zu verfolgen, auf vorherige Versionen zurückzugreifen und die Konsistenz in verschiedenen Umgebungen sicherzustellen.
Wenn Sie ein Docker-Image erstellen, können Sie ihm ein Tag zuweisen. Das Tag ist eine Bezeichnung, mit der Sie eine bestimmte Version des Images identifizieren können. Tags können beliebige Zeichenfolgen sein, aber es ist üblich, die semantische Versionierung zu verwenden (z. B. v1.0.0, v1.1.2, v2.0.0-beta).
Hier ist ein Beispiel dafür, wie Sie ein Docker-Image erstellen und taggen:
docker build -t my-app:v1.0.0 .Dieser Befehl erstellt ein Docker-Image mit dem Tag v1.0.0.
Die Versionierung Ihrer Docker-Images ist wichtig, um Änderungen zu verfolgen und sicherzustellen, dass Ihre Anwendungen mit der richtigen Imageversion bereitgestellt werden. Es gibt verschiedene Strategien, die Sie für die Versionierung von Docker-Images verwenden können:
v1.2.3).2023-04-15).abcd1234).Unabhängig von der gewählten Versionierungsstrategie ist es wichtig, konsistent zu sein und Ihren Versionierungsansatz zu dokumentieren.
Sobald Sie Ihre Docker-Images erstellt und getaggt haben, können Sie sie in einem Docker-Registry, wie Docker Hub oder einem privaten Registry, pushen. Sie können die Images dann aus dem Registry ziehen und verwenden, um Ihre Anwendungen bereitzustellen.
Hier ist ein Beispiel dafür, wie Sie ein Docker-Image auf Docker Hub pushen:
docker push my-app:v1.0.0Und hier ist ein Beispiel dafür, wie Sie ein Docker-Image von Docker Hub ziehen:
docker pull my-app:v1.0.0Durch die Versionierung und das Tagging Ihrer Docker-Images stellen Sie sicher, dass Ihre Anwendungen konsistent bereitgestellt werden und Sie Änderungen an Ihrer Docker-basierten Infrastruktur leicht verfolgen und verwalten können.
Sobald Sie Ihre Docker-Images erstellt haben, können Sie diese in ein Docker-Registry, wie Docker Hub oder ein privates Registry, verschieben und anschließend von diesem Registry ziehen, um Ihre Anwendungen bereitzustellen.
Um ein Docker-Image in ein Registry zu verschieben, müssen Sie sich zuerst beim Registry authentifizieren. Wenn Sie Docker Hub verwenden, können Sie sich mit dem Befehl docker login anmelden:
docker loginDies fordert Sie auf, Ihren Docker Hub-Benutzernamen und Ihr Passwort einzugeben.
Sobald Sie angemeldet sind, können Sie Ihr Docker-Image mit dem Befehl docker push in das Registry verschieben:
docker push my-app:v1.0.0Dieser Befehl verschiebt das Image my-app:v1.0.0 in das Docker-Registry.
Um ein Docker-Image aus einem Registry zu ziehen, können Sie den Befehl docker pull verwenden:
docker pull my-app:v1.0.0Dieser Befehl zieht das Image my-app:v1.0.0 aus dem Docker-Registry und speichert es auf Ihrem lokalen Rechner.
Sie können auch Images aus privaten Registries ziehen, indem Sie die Registry-URL im Befehl docker pull angeben:
docker pull myregistry.example.com/my-app:v1.0.0Dieser Befehl zieht das Image my-app:v1.0.0 aus dem Registry myregistry.example.com.
Durch das Verschieben und Ziehen von Docker-Images können Sie Ihre Anwendungen einfach zwischen verschiedenen Umgebungen und Teams teilen und verteilen und so konsistente und zuverlässige Bereitstellungen gewährleisten.
Die Erstellung von Docker-Images kann ein komplexer Prozess sein. Durch die Einhaltung von Best Practices können Sie jedoch sicherstellen, dass Ihre Images effizient, sicher und wartbar sind. Hier sind einige Best Practices zu beachten:
Wie bereits erwähnt, kann die Verwendung eines minimalen Basis-Images, wie alpine oder scratch, die Größe Ihrer Docker-Images erheblich reduzieren. Dies spart nicht nur Speicherplatz und Bandbreite, sondern reduziert auch die Angriffsfläche und die Anzahl potenzieller Sicherheitslücken.
Organisieren Sie die Anweisungen in Ihrem Dockerfile, um den Caching-Mechanismus von Docker zu nutzen. Gruppieren Sie verwandte Anweisungen und platzieren Sie die am wenigsten häufig ändernden Anweisungen ganz oben im Dockerfile.
Mehrstufige Builds ermöglichen es Ihnen, die Build- und Laufzeitumgebungen zu trennen, was zu kleineren und sichereren Images führt. Dies ist besonders nützlich für kompilierte Sprachen wie Go oder C++, bei denen Sie die Anwendung in einer Phase kompilieren und dann die kompilierte Binärdatei in ein kleineres Laufzeit-Image kopieren können.
Die Datei .dockerignore ermöglicht es Ihnen, Dateien und Verzeichnisse aus dem Docker-Build-Kontext auszuschließen, wodurch die Größe des Build-Kontexts reduziert und der Build-Prozess beschleunigt wird.
Nutzen Sie Tools wie trivy oder snyk, um Ihre Docker-Images auf bekannte Sicherheitslücken zu prüfen. Dies kann Ihnen helfen, potenzielle Sicherheitsrisiken zu identifizieren und zu beheben, bevor Sie Ihre Anwendungen bereitstellen.
Stellen Sie sicher, dass Ihre Dockerfiles sichere Praktiken befolgen, wie z. B.:
latest-Tags für Basis-ImagesDokumentieren Sie Ihren Prozess zur Erstellung von Docker-Images, einschließlich des Dockerfiles, der Build-Skripte und aller anderen relevanten Informationen. Automatisieren Sie den Build- und Bereitstellungsprozess mithilfe von Tools wie Jenkins, CircleCI oder GitHub Actions, um Konsistenz und Zuverlässigkeit sicherzustellen.
Durch die Einhaltung dieser Best Practices können Sie effiziente, sichere und wartbare Docker-Images erstellen, die eine solide Grundlage für Ihre Docker-basierten Anwendungen bilden.
Die Verwaltung des Lebenszyklus von Docker-Images ist ein wichtiger Aspekt der Aufrechterhaltung einer gesunden und effizienten Docker-basierten Infrastruktur. Dazu gehören Aufgaben wie die Versionsverwaltung von Images, die Bereinigung alter Images und die Verwaltung von Sicherheitsupdates für Images.
Wie bereits erwähnt, ist die Versionsverwaltung und das Tagging Ihrer Docker-Images entscheidend für die Nachverfolgung von Änderungen und die Sicherstellung konsistenter Bereitstellungen. Legen Sie eine klare Versionsstrategie fest, z. B. semantische Versionierung oder datumsbasierte Versionierung, und wenden Sie diese konsequent auf Ihre Docker-Images an.
Im Laufe der Zeit kann sich in Ihrem Docker-Image-Repository eine große Anzahl alter und nicht verwendeter Images ansammeln, die wertvollen Speicherplatz belegen. Bereinigen Sie diese alten Images regelmäßig, um Ressourcen freizugeben und ein schlankes und effizientes Image-Repository zu erhalten.
Sie können den Befehl docker image prune verwenden, um nicht verwendete Docker-Images zu entfernen:
## Entfernen aller nicht verwendeten Images
docker image prune -a
## Entfernen von Images älter als 30 Tage
docker image prune -a --filter "until=720h"Docker-Basis-Images können, wie jede andere Software, Sicherheitslücken aufweisen, die behoben werden müssen. Überwachen Sie regelmäßig Sicherheitsupdates und erstellen Sie Ihre Docker-Images neu, um die neuesten Sicherheits-Patches zu integrieren.
Sie können Tools wie trivy oder snyk verwenden, um Ihre Docker-Images auf bekannte Sicherheitslücken zu prüfen und festzustellen, welche Images aktualisiert werden müssen.
## Scannen eines Docker-Images auf Sicherheitslücken
trivy image my-app:v1.0.0Durch die Verwaltung des Lebenszyklus Ihrer Docker-Images können Sie sicherstellen, dass Ihre Docker-basierten Anwendungen sicher, aktuell und effizient sind.
Am Ende dieses Tutorials verfügen Sie über ein tiefes Verständnis der Docker-Imageerstellung, von der Erstellung von Images von Grund auf bis zur Verwaltung ihres Lebenszyklus. Sie werden in der Lage sein, effiziente, sichere und wartbare Docker-Images zu erstellen, die als solide Grundlage für Ihre Docker-basierten Anwendungen dienen. Dieses Wissen wird Sie befähigen, Ihre Docker-basierten Bereitstellungen zu optimieren und eine konsistente und zuverlässige Anwendungsbereitstellung sicherzustellen.
