💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken
Dieses umfassende Docker-Tutorial bietet Entwicklern und IT-Profis einen tiefen Einblick in die Container-Technologie. Vom Verständnis der Kernkonzepte von Docker bis hin zu praktischen Installations- und Managementtechniken deckt der Leitfaden alles ab, was benötigt wird, um die leistungsstarken Containerisierungsfähigkeiten von Docker für die moderne Softwareentwicklung und -bereitstellung zu nutzen.
Docker ist eine leistungsstarke Plattform für die Container-Technologie, die es Entwicklern ermöglicht, Anwendungen effizient zu paketieren, zu verteilen und auszuführen. Container bieten leichtgewichtige, portable Umgebungen, die Software und ihre Abhängigkeiten kapseln.
| Konzept | Beschreibung |
|---|---|
| Docker Image | Schreibgeschütztes Template, das Anwendungscode und Abhängigkeiten enthält |
| Container | Ausführbare Instanz eines Docker-Images |
| Docker Engine | Laufzeitumgebung zum Erstellen und Verwalten von Containern |
Ihre LabEx-Umgebung wird mit vorinstalliertem Docker geliefert. Lassen Sie uns die Docker-Version überprüfen, um sicherzustellen, dass sie einsatzbereit ist.
docker --versionDie Ausgabe sollte die Docker-Version anzeigen, z. B. Docker version 20.10.21, build baeda1f. Dies bestätigt, dass Docker korrekt installiert und zugänglich ist.
Ein Docker-Image ist ein schreibgeschütztes Template, das eine Reihe von Anweisungen zur Erstellung eines Containers enthält. Wir werden das hello-world-Image herunterladen, ein minimales Image, das zum Testen von Docker-Installationen verwendet wird.
docker pull hello-worldDieser Befehl lädt das hello-world-Image von Docker Hub auf Ihren lokalen Rechner herunter. Sie sollten eine Ausgabe sehen, die den Download-Fortschritt und die Bestätigung anzeigt, dass das Image heruntergeladen wurde.
Nachdem wir nun ein Image haben, lassen Sie uns einen Container daraus ausführen. Das Ausführen eines Containers bedeutet, eine Instanz des Images zu erstellen.
docker run hello-worldWenn Sie hello-world ausführen, führt Docker die folgenden Aktionen aus:
hello-world-Image lokal vorhanden ist. Wenn nicht, wird es heruntergeladen (was wir bereits getan haben).Dies demonstriert den grundlegenden Lebenszyklus eines Docker-Containers: Image herunterladen, Container ausführen, und der Container führt seine definierte Aufgabe aus.
Um die von Ihnen heruntergeladenen Images anzuzeigen, verwenden Sie den Befehl docker images.
docker imagesDieser Befehl listet alle Docker-Images auf, die auf Ihrem lokalen System gespeichert sind, einschließlich des hello-world-Images, das wir gerade heruntergeladen haben. Sie sehen Details wie Repository, Tag, Image-ID, Erstellungsdatum und Größe.
Container bieten isolierte Umgebungen mit eigenen Dateisystemen, Prozessen und Netzwerkschnittstellen. Sie können schnell gestartet, gestoppt, verschoben und gelöscht werden, was sie ideal für Microservices und Cloud-native Anwendungen macht.
Ein Dockerfile ist ein Textdokument, das alle Befehle enthält, die ein Benutzer auf der Kommandozeile aufrufen kann, um ein Image zusammenzustellen. Es definiert die Umgebung, Abhängigkeiten und Konfiguration für containerisierte Anwendungen.
Navigieren Sie in das Verzeichnis docker_app, das während der Einrichtungsphase erstellt wurde. Dies wird unser Arbeitsverzeichnis für dieses Lab sein.
cd /home/labex/project/docker_appErstellen wir nun ein einfaches Dockerfile namens Dockerfile in diesem Verzeichnis. Dieses Dockerfile erstellt ein Image basierend auf Ubuntu und fügt ihm eine einfache Textdatei hinzu.
nano DockerfileFügen Sie den folgenden Inhalt in das Dockerfile ein:
## Verwenden Sie ein offizielles Ubuntu-Basisimage
FROM ubuntu:22.04
## Legen Sie das Arbeitsverzeichnis im Container fest
WORKDIR /app
## Erstellen Sie eine einfache Textdatei
RUN echo "Hello from Dockerfile!" > /app/message.txt
## Befehl, der beim Start des Containers ausgeführt wird
CMD ["cat", "/app/message.txt"]FROM ubuntu:22.04: Diese Anweisung gibt das Basisimage für unser neues Image an. Wir verwenden Ubuntu 22.04.WORKDIR /app: Dies legt das Arbeitsverzeichnis für alle nachfolgenden RUN, CMD, ENTRYPOINT, COPY oder ADD-Anweisungen im Dockerfile fest. Wenn /app nicht existiert, wird es erstellt.RUN echo "Hello from Dockerfile!" > /app/message.txt: Diese Anweisung führt während des Build-Prozesses einen Befehl innerhalb des Images aus. Hier wird eine Datei namens message.txt im Verzeichnis /app mit dem Inhalt "Hello from Dockerfile!" erstellt.CMD ["cat", "/app/message.txt"]: Diese Anweisung stellt Standardbefehle für einen laufenden Container bereit. Wenn ein Container aus diesem Image gestartet wird, führt er cat /app/message.txt aus und zeigt den Inhalt unserer Nachrichten-Datei an.Speichern Sie die Datei, indem Sie Strg+S drücken, und beenden Sie nano, indem Sie Strg+X drücken.
Nachdem wir unser Dockerfile haben, erstellen wir daraus das Docker-Image. Der Befehl docker build liest das Dockerfile und erstellt ein Docker-Image.
docker build -t my-ubuntu-app .docker build: Der Befehl zum Erstellen eines Docker-Images.-t my-ubuntu-app: Dies taggt unser Image mit dem Namen my-ubuntu-app. Sie können einen beliebigen Namen wählen..: Dies gibt den Build-Kontext an, d. h. die Sammlung von Dateien im angegebenen PATH oder URL. Der Punkt (.) gibt an, dass das aktuelle Verzeichnis (/home/labex/project/docker_app) der Build-Kontext ist. Docker sucht in diesem Verzeichnis nach einem Dockerfile.Sie sehen eine Ausgabe, die jeden Schritt des Build-Prozesses zeigt und den Anweisungen in Ihrem Dockerfile entspricht.
Nachdem das Image erfolgreich erstellt wurde, lassen Sie uns einen Container daraus ausführen, um den Inhalt von message.txt anzuzeigen.
docker run my-ubuntu-appDieser Befehl erstellt und startet einen neuen Container aus Ihrem my-ubuntu-app-Image. Die CMD-Anweisung in Ihrem Dockerfile wird ausgeführt, und Sie sollten "Hello from Dockerfile!" auf Ihrem Terminal sehen.
Um besser zu verstehen, wie Dateien innerhalb eines Containers verwaltet werden, starten wir eine interaktive Sitzung und überprüfen die von uns erstellte Datei.
docker run -it my-ubuntu-app /bin/bash-it: Dieses Flag weist ein Pseudo-TTY zu und hält STDIN offen, sodass Sie mit dem Container interagieren können.my-ubuntu-app: Der Name des Images, das wir ausführen möchten./bin/bash: Dies überschreibt die CMD-Anweisung im Dockerfile und führt stattdessen eine Bash-Shell innerhalb des Containers aus, was Ihnen eine Kommandozeile bietet.Sobald Sie sich im Container befinden, sehen Sie eine neue Kommandozeile (z. B. root@<container_id>:/app#). Nun können Sie die Dateien auflisten und den Inhalt von message.txt anzeigen.
ls -l
cat message.txtSie sollten message.txt aufgelistet sehen und dessen Inhalt angezeigt bekommen. Um den Container zu verlassen, geben Sie einfach exit ein.
exitDiese interaktive Sitzung zeigt, dass die Datei message.txt erfolgreich erstellt wurde und innerhalb des Dateisystems des Containers zugänglich ist.
Multi-Stage-Builds sind ein leistungsstarkes Feature, das es Ihnen ermöglicht, mehrere FROM-Anweisungen in Ihrem Dockerfile zu verwenden. Jede FROM-Anweisung kann ein anderes Basisimage verwenden, und jede FROM-Anweisung startet eine neue Build-Phase. Dies hilft bei der Optimierung der Komplexität von Dockerfiles und der Reduzierung der endgültigen Image-Größe, indem Build- und Laufzeitumgebungen getrennt werden.
Für dieses Beispiel simulieren wir eine einfache Anwendung, die einen Build-Schritt erfordert. Wir erstellen eine build_script.sh und eine final_app.txt-Datei.
Stellen Sie zunächst sicher, dass Sie sich im Verzeichnis docker_app befinden:
cd /home/labex/project/docker_appErstellen Sie nun ein einfaches Build-Skript:
nano build_script.shFügen Sie den folgenden Inhalt in build_script.sh ein:
#!/bin/bash
echo "Running build process..."
echo "This is the final application output." > /app/output/final_app.txt
echo "Build complete."Speichern Sie die Datei (Strg+S) und beenden Sie (Strg+X).
Erstellen Sie als Nächstes einen Platzhalter für den Inhalt unserer endgültigen Anwendung. In einem realen Szenario würde dies durch den Build-Prozess generiert werden.
nano final_app.txtFügen Sie den folgenden Inhalt in final_app.txt ein:
This is a placeholder for the final application.Speichern Sie die Datei (Strg+S) und beenden Sie (Strg+X).
Ändern wir nun unser Dockerfile, um einen Multi-Stage-Build zu verwenden. Wir werden eine "Builder"-Phase haben, die unser build_script.sh ausführt, und dann eine "Produktions"-Phase, die nur die notwendigen Ausgaben aus der Builder-Phase kopiert.
nano DockerfileErsetzen Sie den vorhandenen Inhalt durch Folgendes:
## Phase 1: Builder-Phase
FROM ubuntu:22.04 AS builder
## Bash installieren, um das Skript auszuführen
RUN apt-get update && apt-get install -y bash
## Arbeitsverzeichnis für die Builder-Phase festlegen
WORKDIR /build
## Build-Skript kopieren und ausführbar machen
COPY build_script.sh .
RUN chmod +x build_script.sh
## Verzeichnis für die Ausgabe erstellen
RUN mkdir -p /build/output
## Build-Skript ausführen
RUN ./build_script.sh
## Phase 2: Produktions-Phase
FROM ubuntu:22.04
## Arbeitsverzeichnis für die Produktions-Phase festlegen
WORKDIR /app
## Nur das notwendige Artefakt aus der Builder-Phase kopieren
COPY --from=builder /build/output/final_app.txt .
## Befehl, der beim Start des Containers ausgeführt wird
CMD ["cat", "final_app.txt"]FROM ubuntu:22.04 AS builder: Dies startet die erste Phase und benennt sie builder.RUN apt-get update && apt-get install -y bash: Installiert bash in der Builder-Phase, was zur Ausführung unseres Skripts benötigt wird.WORKDIR /build: Legt das Arbeitsverzeichnis für die Builder-Phase fest.COPY build_script.sh .: Kopiert unser Build-Skript in die Builder-Phase.RUN chmod +x build_script.sh: Macht das Skript ausführbar.RUN mkdir -p /build/output: Erstellt ein Ausgabeverzeichnis in der Builder-Phase.RUN ./build_script.sh: Führt das Build-Skript aus, das final_app.txt in /build/output generiert.FROM ubuntu:22.04: Dies startet die zweite Phase (die Produktions-Phase). Sie verwendet ein frisches ubuntu:22.04-Image, was bedeutet, dass sie standardmäßig nichts von der builder-Phase erbt.WORKDIR /app: Legt das Arbeitsverzeichnis für die Produktions-Phase fest.COPY --from=builder /build/output/final_app.txt .: Dies ist die entscheidende Anweisung für Multi-Stage-Builds. Sie kopiert final_app.txt aus dem Verzeichnis /build/output der builder-Phase in das aktuelle Verzeichnis (/app) der Produktions-Phase. Dies stellt sicher, dass nur das endgültige Artefakt enthalten ist, wodurch das Produktions-Image klein bleibt.CMD ["cat", "final_app.txt"]: Der Befehl, der beim Start des Produktionscontainers ausgeführt wird und den Inhalt der kopierten Datei anzeigt.Speichern Sie die Datei (Strg+S) und beenden Sie (Strg+X).
Erstellen wir nun das neue Image mit unserem Multi-Stage-Dockerfile.
docker build -t multi-stage-app .Beobachten Sie die Build-Ausgabe. Sie sehen Schritte sowohl für die builder-Phase als auch für die endgültige Phase.
Nachdem der Build abgeschlossen ist, führen Sie den Container aus, um zu überprüfen, ob der Inhalt von final_app.txt angezeigt wird.
docker run multi-stage-appSie sollten "This is the final application output." sehen, was bestätigt, dass der Multi-Stage-Build das Artefakt erfolgreich von der Build-Phase in das endgültige Image kopiert hat.
Es ist eine gute Praxis, nicht mehr benötigte Docker-Ressourcen (Container und Images) zu bereinigen, um Speicherplatz freizugeben.
Listen Sie zunächst alle Container auf (einschließlich beendeter):
docker ps -aSie können bestimmte Container anhand ihrer ID oder ihres Namens entfernen:
docker rm $(docker ps -aq)Dieser Befehl entfernt alle beendeten Container. docker ps -aq listet alle Container-IDs auf, und docker rm entfernt sie.
Listen Sie als Nächstes alle Images auf:
docker imagesSie können bestimmte Images anhand ihrer ID oder ihres Namens entfernen. Seien Sie vorsichtig, keine Images zu entfernen, die noch von laufenden Containern verwendet werden.
docker rmi my-ubuntu-app multi-stage-app hello-world ubuntu:22.04Dieser Befehl entfernt die Images, die wir in diesem Lab erstellt und verwendet haben. Wenn ein Image noch von einem Container verwendet wird, müssen Sie zuerst den Container entfernen.
docker imagesDieser Befehl zeigt an, dass die Images entfernt wurden.
Damit ist das Lab zu Docker-Grundlagen und fortgeschrittenen Techniken abgeschlossen. Sie haben gelernt, wie man Dockerfiles erstellt, Images baut, Container ausführt und die Image-Größe mit Multi-Stage-Builds optimiert.
Durch die Beherrschung der Docker-Grundlagen, der Dockerfile-Verwaltung und fortgeschrittener Techniken können Entwickler effizientere, portablere und skalierbarere Softwareumgebungen erstellen. Dieses Tutorial hat Sie mit praktischen Fähigkeiten in der Containererstellung, im Image-Management und in Bereitstellungsstrategien ausgestattet, sodass Sie Entwicklungsabläufe optimieren und Cloud-native Anwendungsarchitekturen nutzen können.
