💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken
Dieses Dockerfile-Tutorial soll eine umfassende Einführung in die Erstellung und Verwendung von Dockerfiles bieten. Ob Sie mit Docker neu vertraut sind oder Ihr vorhandenes Wissen erweitern möchten, diese Anleitung führt Sie durch die Grundlagen von Dockerfiles, von der Verständnis von Docker-Images und -Containern bis hin zur Erstellung und Optimierung Ihrer eigenen benutzerdefinierten Docker-Images.
Docker ist eine Open-Source-Plattform, die es Entwicklern ermöglicht, Anwendungen in einer konsistenten und isolierten Umgebung, sogenannten Containern, zu erstellen, bereitzustellen und auszuführen. Container verpacken eine Anwendung und ihre Abhängigkeiten in eine einzelne, portable Einheit und gewährleisten, dass die Anwendung unabhängig von der zugrundeliegenden Infrastruktur auf dieselbe Weise ausgeführt wird.
Ein Dockerfile ist ein textbasiertes Skript, das eine Reihe von Anweisungen zum Erstellen eines Docker-Images enthält. Es spezifiziert das Basis-Image, die auszuführenden Schritte und die Konfigurationseinstellungen für den Container. Durch die Verwendung eines Dockerfiles können Sie den Prozess der Erstellung und Verwaltung von Docker-Images automatisieren, wodurch die Erstellung, Verteilung und Bereitstellung Ihrer Anwendungen vereinfacht wird.
Um mit Docker und Dockerfiles zu beginnen, müssen Sie Docker auf Ihrem System installiert haben. Sie können Docker von der offiziellen Docker-Website (https://www.docker.com/get-started) herunterladen und installieren. Sobald Docker installiert ist, können Sie mit der Erstellung Ihrer eigenen Dockerfiles und dem Erstellen von Docker-Images beginnen.
## Docker auf Ubuntu 22.04 installieren
sudo apt-get update
sudo apt-get install -y docker.ioIm nächsten Abschnitt werden wir tiefer in die Struktur und Syntax von Dockerfiles eintauchen und lernen, wie benutzerdefinierte Docker-Images erstellt werden.
Ein Docker-Image ist eine schreibgeschützte Vorlage, die eine Reihe von Anweisungen zum Erstellen eines Docker-Containers enthält. Es umfasst den Anwendungscode, die Laufzeitumgebung, Systemtools, Bibliotheken und alle anderen Dateien, die zum Ausführen der Anwendung benötigt werden. Docker-Images werden mithilfe eines Dockerfiles erstellt und können über Docker-Registrierungen wie Docker Hub geteilt und verteilt werden.
Ein Docker-Container ist eine ausführbare Instanz eines Docker-Images. Container sind leichte, eigenständige und ausführbare Pakete, die alles enthalten, was zum Ausführen einer Anwendung benötigt wird, einschließlich Code, Laufzeitumgebung, Systemtools und Systembibliotheken. Container sind voneinander und vom Host-Betriebssystem isoliert, was eine konsistente und zuverlässige Anwendungsbereitstellung gewährleistet.
## Einen einfachen Ubuntu-Container ausführen
docker run -it ubuntu:22.04 bashDocker-Images bestehen aus mehreren Layers, die jeweils eine Reihe von Änderungen am Basis-Image darstellen. Wenn Sie ein neues Image erstellen, verwendet Docker den Image-Cache, um diese Layers wiederzuverwenden, wodurch der Build-Prozess effizienter wird. Dieser Caching-Mechanismus beschleunigt den Build-Prozess und reduziert die Größe des endgültigen Images.
Sie können Ihre benutzerdefinierten Docker-Images in ein Registry wie Docker Hub pushen, um sie mit anderen zu teilen oder in verschiedenen Umgebungen bereitzustellen. Umgekehrt können Sie Images aus einem Registry ziehen, um sie in Ihren eigenen Projekten zu verwenden.
## Docker-Image auf Docker Hub pushen
docker push labex/my-app:latest
## Docker-Image von Docker Hub ziehen
docker pull labex/my-app:latestIm nächsten Abschnitt werden wir die grundlegende Syntax und Struktur von Dockerfiles untersuchen, mit denen Sie Ihre eigenen benutzerdefinierten Docker-Images erstellen können.
Ein Dockerfile ist ein textbasiertes Skript, das eine Reihe von Anweisungen zum Erstellen eines Docker-Images enthält. Die grundlegende Syntax eines Dockerfiles lautet wie folgt:
## Kommentar
ANWEISUNG ArgumentDie häufigsten Anweisungen in einem Dockerfile umfassen:
| Anweisung | Beschreibung |
|---|---|
FROM |
Gibt das Basis-Image für den Build an. |
RUN |
Führt einen Befehl im Container während des Builds aus. |
COPY |
Kopiert Dateien oder Verzeichnisse vom Host in den Container. |
ADD |
Ähnlich wie COPY, kann aber auch Remote-Dateien herunterladen und Archive extrahieren. |
CMD |
Gibt den Standardbefehl an, der beim Start des Containers ausgeführt werden soll. |
EXPOSE |
Teilt Docker mit, dass der Container auf den angegebenen Netzwerkport(s) lauscht. |
ENV |
Legt eine Umgebungsvariable fest. |
WORKDIR |
Legt das Arbeitsverzeichnis für alle folgenden RUN, CMD, ENTRYPOINT, COPY und ADD-Anweisungen fest. |
Ein typisches Dockerfile folgt dieser Struktur:
ubuntu:22.04 mithilfe der Anweisung FROM.RUN, um das Paket-Management zu aktualisieren und die notwendigen Abhängigkeiten zu installieren.COPY, um Ihren Anwendungscode in den Container zu kopieren.ENV, um alle notwendigen Umgebungsvariablen festzulegen.EXPOSE, um die Ports zu öffnen, auf denen Ihre Anwendung lauscht.CMD oder ENTRYPOINT, um den Standardbefehl anzugeben, der beim Start des Containers ausgeführt werden soll.Hier ist ein Beispiel-Dockerfile für eine einfache Python-Webanwendung:
FROM python:3.9-slim
## Paket-Manager aktualisieren und Abhängigkeiten installieren
RUN apt-get update && apt-get install -y \
build-essential \
libpq-dev \
&& rm -rf /var/lib/apt/lists/*
## Anwendungscode kopieren
COPY . /app
WORKDIR /app
## Python-Abhängigkeiten installieren
RUN pip install --no-cache-dir -r requirements.txt
## Port, auf dem die App läuft, öffnen
EXPOSE 8000
## Einstiegspunkt definieren
CMD ["python", "app.py"]Im nächsten Abschnitt werden wir untersuchen, wie Sie benutzerdefinierte Docker-Images mithilfe von Dockerfiles erstellen.
Um ein benutzerdefiniertes Docker-Image zu erstellen, müssen Sie ein Dockerfile erstellen. Erstellen Sie dazu eine neue Datei mit dem Namen Dockerfile in Ihrem Projektverzeichnis. Diese Datei enthält die Anweisungen zum Erstellen Ihres Docker-Images.
Sobald Ihr Dockerfile fertig ist, können Sie das Docker-Image mit dem Befehl docker build erstellen:
docker build -t labex/my-app:latest .Dieser Befehl liest das Dockerfile, führt die Anweisungen Schritt für Schritt aus und erstellt ein neues Docker-Image mit dem Namen labex/my-app:latest. Das . am Ende des Befehls gibt den Build-Kontext an, das ist das Verzeichnis, in dem sich das Dockerfile befindet.
Wenn Sie den Befehl docker build ausführen, führt Docker die Anweisungen im Dockerfile schrittweise aus. Jede Anweisung erstellt eine neue Schicht im Image, und Docker verwendet den Image-Cache, um den Build-Prozess zu optimieren.
Nachdem Sie das Image erstellt haben, können Sie es mit einer bestimmten Version oder einem Label versehen und dann in ein Docker-Registry wie Docker Hub pushen, damit es von anderen verwendet werden kann.
## Das Image taggen
docker tag labex/my-app:latest labex/my-app:v1.0
## Das Image auf Docker Hub pushen
docker push labex/my-app:v1.0Sobald das Image in einem Registry verfügbar ist, können Sie es ziehen und einen Container basierend auf dem Image ausführen:
## Das Image von Docker Hub ziehen
docker pull labex/my-app:v1.0
## Einen Container aus dem Image ausführen
docker run -p 8000:8000 labex/my-app:v1.0Im nächsten Abschnitt werden wir besprechen, wie Sie die Dockerfile-Layers für eine bessere Effizienz optimieren können.
Wie bereits erwähnt, bestehen Docker-Images aus mehreren Schichten. Jede Schicht repräsentiert eine Reihe von Änderungen am Basis-Image. Docker zwischerspeichert diese Schichten, was den Build-Prozess beschleunigt.
Um die Dockerfile-Schichten für eine bessere Effizienz zu optimieren, sollten Sie diese Best Practices befolgen:
Gruppierung verwandter Anweisungen: Gruppieren Sie verwandte Anweisungen, um den Image-Cache zu nutzen. Beispielsweise installieren Sie alle Abhängigkeiten in einer einzigen RUN-Anweisung anstelle mehrerer RUN-Anweisungen.
Minimierung der Anzahl der Schichten: Jede Anweisung im Dockerfile erzeugt eine neue Schicht. Versuchen Sie daher, die Anzahl der Schichten zu minimieren, indem Sie Anweisungen wo immer möglich kombinieren.
Verwendung von Multi-Stage-Builds: Multi-Stage-Builds ermöglichen es Ihnen, mehrere FROM-Anweisungen in einem einzigen Dockerfile zu verwenden, was zur Erstellung kleinerer und effizienterer Images beitragen kann.
Nutzung des Image-Caches: Ordnen Sie Ihre Dockerfile-Anweisungen so an, dass der Image-Cache genutzt wird. Platzieren Sie beispielsweise Anweisungen, die weniger wahrscheinlich geändert werden (z. B. die Installation von System-Abhängigkeiten) früher im Dockerfile.
Hier ist ein Beispiel für ein optimiertes Dockerfile:
FROM python:3.9-slim AS base
## Installation der System-Abhängigkeiten
RUN apt-get update && apt-get install -y \
build-essential \
libpq-dev \
&& rm -rf /var/lib/apt/lists/*
## Erstellen eines Nicht-Root-Benutzers
RUN useradd -m -s /bin/bash appuser
USER appuser
WORKDIR /app
## Installation der Python-Abhängigkeiten
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
## Kopieren des Anwendungscodes
COPY . .
## Exponieren des Ports und Definieren des Einstiegspunkts
EXPOSE 8000
CMD ["python", "app.py"]In diesem Beispiel haben wir verwandte Anweisungen gruppiert, die Anzahl der Schichten minimiert und den Image-Cache genutzt, um ein effizienteres Dockerfile zu erstellen.
Sie können Umgebungsvariablen in einem Dockerfile mit der ENV-Anweisung definieren. Dadurch können Sie Umgebungsvariablen festlegen, die während der Laufzeit des Containers verfügbar sind.
ENV APP_ENV=production
ENV DB_HOST=postgres.example.com
ENV DB_PASSWORD=secretSobald Sie eine Umgebungsvariable im Dockerfile definiert haben, können Sie diese in anderen Anweisungen mit dem Präfix $ referenzieren.
ENV APP_ENV=production
COPY config.$APP_ENV.yml /app/config.ymlSie können Umgebungsvariablen auch zur Laufzeit überschreiben, wenn Sie einen Container mit dem Flag -e oder --env starten.
docker run -e DB_PASSWORD=newpassword labex/my-app:latestHier sind einige Best Practices für die Verwaltung von Umgebungsvariablen in Dockerfiles:
Indem Sie diese Best Practices befolgen, können Sie Umgebungsvariablen in Ihren Dockerfiles effektiv verwalten und sicherstellen, dass Ihre Container korrekt konfiguriert sind.
Um Ihre Anwendung von außerhalb des Containers zugänglich zu machen, müssen Sie die Ports freigeben, auf denen Ihre Anwendung lauscht. Sie können die EXPOSE-Anweisung in Ihrem Dockerfile verwenden, um die zu exportierenden Ports anzugeben.
EXPOSE 8000
EXPOSE 5432Wenn Sie einen Container basierend auf diesem Image ausführen, können Sie die freigegebenen Ports mithilfe des Flags -p oder --publish mit dem Hostsystem verknüpfen.
docker run -p 8000:8000 -p 5432:5432 labex/my-app:latestSie können die Anweisungen CMD und ENTRYPOINT in Ihrem Dockerfile verwenden, um den Standardbefehl anzugeben, der bei der Start eines Containers ausgeführt werden soll.
Die CMD-Anweisung legt den Standardbefehl und alle Argumente fest, die an diesen übergeben werden sollen. Wenn die CMD-Anweisung verwendet wird, kann der Befehl docker run den Standardbefehl überschreiben.
CMD ["python", "app.py"]Die ENTRYPOINT-Anweisung legt die Standardanwendung fest, die beim Start des Containers ausgeführt wird. Der ENTRYPOINT-Befehl kann nicht vom Befehl docker run überschrieben werden, aber Sie können Argumente an ihn übergeben.
ENTRYPOINT ["python"]
CMD ["app.py"]In diesem Beispiel wird beim Ausführen des Containers der Befehl python app.py ausgeführt.
docker run labex/my-app:latestSie können auch die RUN-Anweisung verwenden, um Befehle während des Buildprozesses auszuführen. Dies ist nützlich für Aufgaben wie die Installation von Abhängigkeiten oder die Einrichtung der Anwendungsumgebung.
RUN apt-get update && apt-get install -y \
build-essential \
libpq-dev \
&& rm -rf /var/lib/apt/lists/*Durch das Verständnis der Portfreigabe und der Ausführung von Befehlen in Containern stellen Sie sicher, dass Ihre Anwendungen im Docker-Umfeld zugänglich und korrekt konfiguriert sind.
Die COPY-Anweisung in einem Dockerfile dient zum Kopieren von Dateien oder Verzeichnissen vom Hostsystem in das Docker-Image. Die Syntax für die COPY-Anweisung lautet:
COPY <Quelle> <Ziel>Dabei ist <Quelle> der Pfad zur Datei oder zum Verzeichnis auf dem Hostsystem und <Ziel> der Pfad, an den die Datei oder das Verzeichnis im Docker-Container kopiert werden soll.
COPY requirements.txt /app/
COPY . /app/Im obigen Beispiel werden die Datei requirements.txt und das gesamte aktuelle Verzeichnis (.) in das Verzeichnis /app/ innerhalb des Docker-Containers kopiert.
Die ADD-Anweisung ähnelt der COPY-Anweisung, verfügt aber über zusätzliche Funktionen. Die ADD-Anweisung kann Dateien von einer Remote-URL kopieren und komprimierte Archive (z. B. .tar.gz, .zip) direkt in das Docker-Image extrahieren.
ADD https://example.com/file.tar.gz /app/
ADD local_file.tar.gz /app/Im obigen Beispiel wird die Datei file.tar.gz von einer Remote-URL heruntergeladen und in das Verzeichnis /app/ extrahiert, und die Datei local_file.tar.gz wird kopiert und in das Verzeichnis /app/ extrahiert.
Hier sind einige Best Practices, die Sie beim Kopieren von Dateien und Verzeichnissen in Docker-Images beachten sollten:
COPY-Anweisung anstelle von ADD zu verwenden, da COPY einfacher und weniger anfällig für unerwartetes Verhalten ist..dockerignore in Ihrem Projektverzeichnis, um Dateien und Verzeichnisse auszuschließen, die nicht im Docker-Build-Kontext enthalten sein sollen.COPY-Anweisungen so an, dass der Docker-Build-Cache genutzt wird. Platzieren Sie Anweisungen, die Dateien kopieren, die weniger wahrscheinlich geändert werden, früher im Dockerfile.Indem Sie diese Best Practices befolgen, stellen Sie sicher, dass Ihre Docker-Images effizient, wartbar und nur die notwendigen Dateien und Abhängigkeiten enthalten.
Verwenden Sie aussagekräftige Namen für Ihre Dockerfiles und Docker-Images, die den Zweck klar kommunizieren. Verwenden Sie außerdem Kommentare, um den Zweck jedes Abschnitts oder jeder Anweisung in Ihrem Dockerfile zu erläutern.
## Verwenden Sie ein Basis-Image mit den neuesten Sicherheitsupdates
FROM ubuntu:22.04
## Installieren Sie die notwendigen Abhängigkeiten
RUN apt-get update && apt-get install -y \
build-essential \
libpq-dev \
&& rm -rf /var/lib/apt/lists/*
## Kopieren Sie den Anwendungscode
COPY . /app
WORKDIR /appMehrstufige Builds ermöglichen es Ihnen, mehrere FROM-Anweisungen in einem einzigen Dockerfile zu verwenden, was zur Erstellung kleinerer und effizienterer Images beitragen kann. Dies ist besonders nützlich, wenn Sie Ihre Anwendung mit einer bestimmten Toolchain erstellen müssen, aber die gesamte Toolchain nicht im endgültigen Image enthalten haben möchten.
## Build-Phase
FROM python:3.9-slim AS builder
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
## Endphase
FROM python:3.9-slim
COPY --from=builder /usr/local/lib/python3.9/site-packages /usr/local/lib/python3.9/site-packages
COPY --from=builder /app /app
WORKDIR /app
CMD ["python", "app.py"]Wie bereits erwähnt, verwenden Sie Umgebungsvariablen, um Konfigurationseinstellungen zu speichern, und beachten Sie die Best Practices für die Verwaltung in Ihren Dockerfiles.
Ordnen Sie Ihre Dockerfile-Anweisungen so an, dass der Docker-Build-Cache genutzt wird. Gruppieren Sie verwandte Anweisungen und platzieren Sie Anweisungen, die weniger wahrscheinlich geändert werden, früher im Dockerfile.
Verwenden Sie eine .dockerignore-Datei, um Dateien und Verzeichnisse auszuschließen, die im endgültigen Docker-Image nicht benötigt werden. Dies reduziert den Build-Kontext und verbessert die Build-Zeiten.
Stellen Sie sicher, dass Ihre Dockerfiles gut dokumentiert sind, einschließlich Informationen zum Zweck des Images, den verwendeten Umgebungsvariablen und allen speziellen Anweisungen für das Erstellen oder Ausführen des Containers.
Indem Sie diese Best Practices befolgen, können Sie Dockerfiles erstellen, die leicht verständlich, wartbar und erweiterbar sind, wodurch Ihre Docker-basierten Anwendungen robuster und skalierbarer werden.
Stellen Sie sicher, dass die Syntax Ihres Dockerfiles korrekt ist. Häufige Syntaxfehler umfassen fehlende oder falsche Anweisungen, fehlende Anführungszeichen und falsche Einrückungen.
## Beispiel für einen Syntaxfehler
FROM ubuntu:22.04
RUN apt-get update
apt-get install -y build-essentialWenn Ihr Docker-Build fehlschlägt, überprüfen Sie die Build-Logs auf Fehlermeldungen, die Ihnen helfen können, das Problem zu identifizieren. Häufige Build-Fehler umfassen:
## Beispiel für einen Build-Fehler aufgrund fehlender Abhängigkeiten
RUN apt-get update && apt-get install -y \
build-essential \
libpq-dev \
## Dieses Paket fehlt
libssl-dev \
&& rm -rf /var/lib/apt/lists/*Wenn Ihr Docker-Container nicht wie erwartet funktioniert, überprüfen Sie die Container-Logs auf Fehlermeldungen oder unerwartetes Verhalten. Häufige Laufzeitprobleme umfassen:
## Beispiel für ein Laufzeitproblem aufgrund falscher Portweiterleitung
EXPOSE 8000
## Beim Ausführen des Containers wird der Port nicht korrekt weitergeleitet
docker run -p 8080:8000 labex/my-app:latestSie können die folgenden Techniken verwenden, um Ihre Dockerfiles zu debuggen:
docker build mit dem Flag --no-cache, um einen vollständigen Rebuild durchzuführen und den Image-Cache zu umgehen.docker run mit dem Flag --rm, um den Container automatisch zu entfernen, nachdem er beendet wurde, was die Überprüfung des Containerzustands erleichtert.docker logs, um die Logs eines laufenden Containers anzuzeigen.docker exec, um in einen laufenden Container einzusteigen und sein Dateisystem zu untersuchen oder zusätzliche Befehle auszuführen.Durch das Verständnis häufiger Dockerfile-Probleme und die Verwendung der entsprechenden Debugging-Techniken können Sie Probleme in Ihren Docker-basierten Anwendungen schnell identifizieren und lösen.
Am Ende dieses Dockerfile-Tutorials verfügen Sie über ein fundiertes Verständnis der Dockerfile-Syntax und -Struktur. Dadurch können Sie Ihre eigenen Docker-Images effektiv erstellen und verwalten. Sie lernen bewährte Methoden für die Erstellung wartbarer Dockerfiles sowie Techniken zur Fehlerbehebung bei häufigen Problemen. Mit diesem Wissen sind Sie bestens gerüstet, um Ihre Entwicklungs- und Bereitstellungsprozesse mithilfe der Leistungsfähigkeit von Docker zu optimieren.
