Einführung
Dieses Tutorial führt Sie durch den Prozess des Klonens eines Docker-Container-Images. Docker-Images sind verpackte Vorlagen, die alles enthalten, was zum Ausführen einer Anwendung benötigt wird, und das Klonen ermöglicht es Ihnen, Kopien zu erstellen, die Sie dann anpassen können. Am Ende dieser Anleitung werden Sie verstehen, wie man ein Docker-Image klont, modifiziert und für die Bereitstellung freigibt.
Docker verstehen und Ihre Umgebung überprüfen
Bevor wir mit dem Klonen von Docker-Images beginnen, ist es wichtig zu verstehen, was Docker ist, und zu überprüfen, ob unsere Umgebung richtig eingerichtet ist.
Was ist Docker?
Docker ist eine Plattform, die Container verwendet, um Anwendungen zu entwickeln, bereitzustellen und auszuführen. Container verpacken eine Anwendung mit all ihren Abhängigkeiten und stellen so sicher, dass sie in verschiedenen Umgebungen konsistent funktioniert. Dies macht Docker besonders nützlich für Entwicklungs- und Bereitstellungs-Workflows.
Überprüfen der Docker-Installation
Lassen Sie uns zunächst sicherstellen, dass Docker korrekt auf unserem System installiert ist. Öffnen Sie ein Terminalfenster und führen Sie aus:
docker --version
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
Docker version 20.10.21, build baeda1f
Als Nächstes überprüfen Sie, ob der Docker-Dienst läuft:
sudo systemctl status docker
Die Ausgabe sollte anzeigen, dass Docker aktiv (läuft) ist. Wenn es nicht läuft, können Sie es mit folgendem Befehl starten:
sudo systemctl start docker
Testen der Docker-Funktionalität
Lassen Sie uns einen einfachen Testbefehl ausführen, um zu überprüfen, ob Docker ordnungsgemäß funktioniert:
docker run hello-world
Dieser Befehl lädt das hello-world-Image herunter und führt es aus, das eine Bestätigungsmeldung ausgibt und beendet wird. Sie sollten eine Ausgabe ähnlich der folgenden sehen:
Hello from Docker!
This message shows that your installation appears to be working correctly.
Auflisten von Docker-Images
Um zu sehen, welche Docker-Images derzeit auf Ihrem System verfügbar sind, führen Sie aus:
docker images
Dieser Befehl listet alle Docker-Images auf, die derzeit lokal gespeichert sind. Die Ausgabe zeigt das Image-Repository, den Tag, die Image-ID, das Erstellungsdatum und die Größe.
Nachdem wir nun bestätigt haben, dass Docker ordnungsgemäß funktioniert, sind wir bereit, im nächsten Schritt mit Docker-Images zu arbeiten.
Abrufen und Ausführen eines Docker-Images
In diesem Schritt werden wir ein Docker-Image von Docker Hub abrufen und auf unserem lokalen System ausführen. Dies ist der erste Schritt im Prozess des Klonens eines Docker-Images.
Was ist Docker Hub?
Docker Hub ist ein Cloud-basierter Registry-Dienst, in dem Benutzer Container-Images finden und freigeben können. Es enthält viele offizielle Images, die von Softwareanbietern verwaltet werden, sowie von der Community beigesteuerte Images.
Abrufen eines Images von Docker Hub
Lassen Sie uns das offizielle Nginx-Webserver-Image von Docker Hub abrufen. Nginx ist ein beliebter Webserver, den wir in diesem Tutorial als Beispiel verwenden werden.
Führen Sie den folgenden Befehl aus, um das Nginx-Image herunterzuladen:
docker pull nginx:latest
Dieser Befehl lädt die neueste Version des Nginx-Images herunter. Sie sollten eine Ausgabe sehen, die den Download-Fortschritt anzeigt:
latest: Pulling from library/nginx
a2abf6c4d29d: Pull complete
a9edb18cadd1: Pull complete
589b7251471a: Pull complete
186b1aaa4aa6: Pull complete
b4df32aa5a72: Pull complete
a0bcbecc962e: Pull complete
Digest: sha256:0d17b565c37bcbd895e9d92315a05c1c3c9a29f762b011a10c54a66cd53c9b31
Status: Downloaded newer image for nginx:latest
docker.io/library/nginx:latest
Überprüfen des heruntergeladenen Images
Um zu bestätigen, dass das Image erfolgreich heruntergeladen wurde, listen Sie Ihre Docker-Images erneut auf:
docker images
Sie sollten jetzt das Nginx-Image in der Liste sehen:
REPOSITORY TAG IMAGE ID CREATED SIZE
nginx latest 605c77e624dd 2 weeks ago 142MB
Ausführen des Nginx Docker-Containers
Lassen Sie uns nun einen Container basierend auf dem Nginx-Image ausführen, das wir gerade abgerufen haben:
docker run --name my-nginx -d -p 8080:80 nginx
Dieser Befehl führt Folgendes aus:
--name my-nginx: Benennt unseren Container "my-nginx"-d: Führt den Container im Detached-Modus (im Hintergrund) aus-p 8080:80: Ordnet Port 8080 auf unserem Host Port 80 im Container zunginx: Verwendet das Nginx-Image, das wir zuvor abgerufen haben
Sie sollten eine lange Zeichenkette als Ausgabe sehen, die die Container-ID ist.
Überprüfen des laufenden Containers
Um zu überprüfen, ob der Container läuft:
docker ps
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
f8d3e9c5b9a7 nginx "/docker-entrypoint.…" 30 seconds ago Up 29 seconds 0.0.0.0:8080->80/tcp my-nginx
Sie können jetzt auf die Nginx-Standardseite zugreifen, indem Sie einen Webbrowser öffnen und zu http://localhost:8080 navigieren oder indem Sie curl verwenden:
curl http://localhost:8080
Sie sollten den HTML-Inhalt der Nginx-Willkommensseite sehen.
Nachdem wir nun erfolgreich ein Docker-Image abgerufen und ausgeführt haben, sind wir bereit, im nächsten Schritt unser eigenes benutzerdefiniertes Image basierend darauf zu erstellen.
Erstellen eines benutzerdefinierten Docker-Images
Nachdem wir nun einen laufenden Nginx-Container haben, erstellen wir ein benutzerdefiniertes Image, indem wir es modifizieren. Dies ist der Kern des Klonprozesses. Wir werden:
- Änderungen am laufenden Container vornehmen
- Ein neues Image aus diesen Änderungen erstellen
- Einen Container basierend auf unserem neuen Image ausführen
Docker-Image-Erstellung verstehen
Docker-Images können auf zwei Arten erstellt werden:
- Mithilfe eines Dockerfiles (der empfohlene Ansatz für die Produktion)
- Durch Übertragen von Änderungen, die an einem laufenden Container vorgenommen wurden (nützlich für Erkundung und Experimente)
Wir werden in diesem Tutorial den zweiten Ansatz verwenden, da er einfacher zu verstehen ist, um den Klonprozess zu verstehen.
Modifizieren des laufenden Containers
Zuerst erstellen wir eine benutzerdefinierte HTML-Datei, um die standardmäßige Nginx-Willkommensseite zu ersetzen. Wir müssen den laufenden Container betreten und seine Dateien ändern.
Verwenden Sie den folgenden Befehl, um eine Shell innerhalb des laufenden Containers auszuführen:
docker exec -it my-nginx bash
Dies öffnet eine interaktive Bash-Shell innerhalb des Containers. Erstellen wir nun eine benutzerdefinierte HTML-Datei:
echo "<html><body><h1>My Custom Docker Image</h1><p>This is a custom Nginx image created in the LabEx tutorial.</p></body></html>" > /usr/share/nginx/html/index.html
Sie können die Änderung überprüfen, indem Sie den Inhalt der Datei überprüfen:
cat /usr/share/nginx/html/index.html
Beenden Sie nun die Container-Shell:
exit
Testen der Änderungen
Testen wir, ob unsere Änderungen angewendet wurden, indem wir erneut auf den Nginx-Server zugreifen:
curl http://localhost:8080
Sie sollten jetzt unseren benutzerdefinierten HTML-Inhalt anstelle der standardmäßigen Nginx-Willkommensseite sehen.
Erstellen eines neuen Images aus dem modifizierten Container
Nachdem wir den Container modifiziert haben, erstellen wir ein neues Image, das diese Änderungen enthält. Dies geschieht mit dem Befehl docker commit:
docker commit my-nginx my-custom-nginx:v1
Dieser Befehl erstellt ein neues Image namens my-custom-nginx mit dem Tag v1 basierend auf dem aktuellen Zustand des Containers my-nginx.
Überprüfen des neuen Images
Überprüfen wir, ob unser neues Image erstellt wurde:
docker images
Sie sollten Ihr neues Image in der Liste sehen:
REPOSITORY TAG IMAGE ID CREATED SIZE
my-custom-nginx v1 a1b2c3d4e5f6 10 seconds ago 142MB
nginx latest 605c77e624dd 2 weeks ago 142MB
Ausführen eines Containers aus dem neuen Image
Lassen Sie uns nun den ursprünglichen Container stoppen und entfernen und dann einen neuen Container basierend auf unserem benutzerdefinierten Image ausführen:
docker stop my-nginx
docker rm my-nginx
docker run --name my-custom-container -d -p 8081:80 my-custom-nginx:v1
Diese Befehle:
- Stoppen den ursprünglichen Container
- Entfernen den ursprünglichen Container
- Erstellen einen neuen Container basierend auf unserem benutzerdefinierten Image, das auf Port 8081 gemappt ist
Testen des neuen Containers
Überprüfen wir, ob unser neuer Container korrekt ausgeführt wird:
docker ps
Sie sollten Ihren neuen Container in der Liste sehen:
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
g9h8i7j6k5l4 my-custom-nginx:v1 "/docker-entrypoint.…" 10 seconds ago Up 9 seconds 0.0.0.0:8081->80/tcp my-custom-container
Greifen Sie nun auf den Nginx-Server auf dem neuen Port zu:
curl http://localhost:8081
Sie sollten denselben benutzerdefinierten HTML-Inhalt sehen, was bestätigt, dass unser neues Image die von uns vorgenommenen Änderungen enthält.
Herzlichen Glückwunsch! Sie haben erfolgreich ein Docker-Image geklont und angepasst. Im nächsten Schritt erfahren wir, wie Sie dieses benutzerdefinierte Image freigeben können.
Verschlagworten und Freigeben Ihres Docker-Images
Nachdem wir nun ein benutzerdefiniertes Docker-Image erstellt haben, lernen wir, wie man es richtig verschlagwortet und für die Freigabe vorbereitet. In einem realen Szenario würden Sie das Image in eine Registry wie Docker Hub pushen, aber in diesem Tutorial konzentrieren wir uns auf die Vorbereitungsschritte.
Docker-Image-Tags verstehen
Docker-Images werden durch ihren Repository-Namen und Tag identifiziert. Tags helfen bei der Versionierung und Organisation von Images. Der Standard-Tag ist latest, aber es ist eine gute Praxis, aussagekräftige Versions-Tags zu verwenden.
Hinzufügen weiterer Tags zu Ihrem Image
Fügen wir unserem benutzerdefinierten Image ein paar weitere Tags hinzu:
docker tag my-custom-nginx:v1 my-custom-nginx:latest
docker tag my-custom-nginx:v1 my-custom-nginx:stable
Diese Befehle erstellen zwei zusätzliche Tags für unser Image: latest und stable. Die tatsächlichen Image-Daten werden zwischen allen drei Tags geteilt, daher ist dieser Vorgang sehr effizient.
Überprüfen der Tags
Überprüfen wir unsere Images erneut:
docker images
Sie sollten jetzt mehrere Einträge für my-custom-nginx sehen:
REPOSITORY TAG IMAGE ID CREATED SIZE
my-custom-nginx v1 a1b2c3d4e5f6 10 minutes ago 142MB
my-custom-nginx latest a1b2c3d4e5f6 10 minutes ago 142MB
my-custom-nginx stable a1b2c3d4e5f6 10 minutes ago 142MB
nginx latest 605c77e624dd 2 weeks ago 142MB
Beachten Sie, dass alle my-custom-nginx-Images dieselbe Image-ID haben, was darauf hindeutet, dass es sich um dasselbe Image mit unterschiedlichen Tags handelt.
Vorbereiten der Image-Verteilung
In einem realen Szenario würden Sie Ihr Image in eine Registry wie Docker Hub pushen. Dazu müssten Sie:
- Ein Konto auf Docker Hub erstellen
- Sich von Ihrem Terminal aus bei Docker Hub anmelden
- Ihr Image mit Ihrem Docker Hub-Benutzernamen taggen
- Das Image pushen
Nehmen wir für Demonstrationszwecke an, dass Ihr Docker Hub-Benutzername yourusername ist. So bereiten Sie Ihr Image für das Pushen vor:
docker tag my-custom-nginx:v1 yourusername/my-custom-nginx:v1
Um das Image zu pushen (in einem realen Szenario), würden Sie Folgendes verwenden:
## Dies dient nur zur Demonstration - wir werden es nicht tatsächlich pushen
## docker push yourusername/my-custom-nginx:v1
Speichern eines Docker-Images in einer Datei
Anstatt in eine Registry zu pushen, können Sie ein Docker-Image auch in einer Datei speichern, um es manuell zu übertragen:
docker save -o my-custom-nginx.tar my-custom-nginx:v1
Dieser Befehl speichert das Image in einem Tarball namens my-custom-nginx.tar. Sie können überprüfen, ob die Datei erstellt wurde:
ls -lh my-custom-nginx.tar
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
-rw------- 1 labex labex 142M Nov 10 12:34 my-custom-nginx.tar
Laden eines Images aus einer Datei
Um ein Image von einem Tarball auf einem anderen Rechner (oder demselben Rechner nach dem Entfernen des Images) zu laden, würden Sie Folgendes verwenden:
## Wir werden diesen Befehl nicht tatsächlich als Teil des Tutorials ausführen
## docker load -i my-custom-nginx.tar
Exportieren der Container-Dokumentation
Um anderen zu helfen, Ihr benutzerdefiniertes Image zu verstehen, ist es eine gute Praxis, die von Ihnen vorgenommenen Änderungen zu dokumentieren. Erstellen wir eine einfache Dokumentationsdatei:
cat > my-custom-nginx-doc.txt << EOF
## My Custom Nginx Image
This is a custom Nginx image created by cloning the official Nginx image.
### Changes Made
- Replaced the default welcome page with a custom HTML page
### How to Run
docker run --name my-custom-container -d -p 8080:80 my-custom-nginx:v1
### Version History
- v1: Initial custom version with modified welcome page
EOF
Sie haben jetzt eine Dokumentationsdatei für Ihr benutzerdefiniertes Image.
Herzlichen Glückwunsch! Sie haben gelernt, wie Sie Ihr Docker-Image verschlagworten und für die Freigabe vorbereiten. Im nächsten Schritt werden wir einige Best Practices durchgehen und unsere Umgebung bereinigen.
Best Practices und Bereinigung
In diesem letzten Schritt werden wir einige Best Practices für die Arbeit mit Docker-Images behandeln und unsere Umgebung bereinigen.
Best Practices für Docker-Images
1. Verwenden Sie spezifische Tags
Verwenden Sie immer spezifische Versions-Tags, anstatt sich auf das Tag latest zu verlassen. Dies gewährleistet Konsistenz in Ihren Bereitstellungen.
## Besserer Ansatz
docker pull nginx:1.23.2
## Weniger vorhersehbar
docker pull nginx:latest
2. Halten Sie Images klein
Kleinere Images lassen sich schneller herunterladen und verbrauchen weniger Speicherplatz. Erwägen Sie nach Möglichkeit die Verwendung von Alpine-basierten Images:
## Sehen wir uns den Größenunterschied an
docker pull nginx:alpine
docker images | grep nginx
Sie könnten eine Ausgabe wie diese sehen:
nginx alpine 2bc7edbc3cf2 2 weeks ago 40.7MB
nginx latest 605c77e624dd 2 weeks ago 142MB
Die Alpine-Version ist deutlich kleiner!
3. Verwenden Sie Multi-Stage-Builds
Verwenden Sie beim Erstellen von Images mit einem Dockerfile Multi-Stage-Builds, um das endgültige Image klein zu halten. Hier ist ein einfaches Beispiel (Sie müssen dies nicht ausführen):
## Build stage
FROM golang:1.17 AS builder
WORKDIR /app
COPY . .
RUN go build -o app
## Final stage
FROM alpine:3.15
COPY --from=builder /app/app /app
CMD ["/app"]
4. Dokumentieren Sie Ihre Images
Pflegen Sie immer eine Dokumentation für Ihre benutzerdefinierten Images, einschließlich:
- Wofür das Image gedacht ist
- Wie man es verwendet
- Welche Änderungen Sie vorgenommen haben
- Alle Konfigurationsoptionen
Wir haben im vorherigen Schritt eine einfache Dokumentationsdatei erstellt.
5. Scannen Sie nach Sicherheitslücken
Scannen Sie Ihre Images regelmäßig auf Sicherheitslücken:
## Beispiel für das Scannen (Docker Desktop hat dies integriert)
## docker scan my-custom-nginx:v1
Untersuchen von Docker-Images
Lassen Sie uns einen nützlichen Befehl zum Untersuchen von Docker-Images erkunden:
docker inspect my-custom-nginx:v1
Dieser Befehl zeigt detaillierte Informationen über das Image an, einschließlich seiner Schichten, Konfiguration und Umgebungsvariablen.
Anzeigen des Image-Verlaufs
Sie können den Verlauf der Erstellung eines Images sehen:
docker history my-custom-nginx:v1
Dies zeigt jede Schicht des Images und die Befehle, mit denen sie erstellt wurden.
Bereinigung
Lassen Sie uns nun unsere Umgebung bereinigen, indem wir die von uns erstellten Container und Images entfernen:
- Stoppen und entfernen Sie zuerst unseren benutzerdefinierten Container:
docker stop my-custom-container
docker rm my-custom-container
- Entfernen Sie die von uns erstellten Images:
docker rmi my-custom-nginx:v1 my-custom-nginx:latest my-custom-nginx:stable
- Optional können Sie das Nginx-Image entfernen:
docker rmi nginx:latest nginx:alpine
- Überprüfen Sie, ob alle Container und Images entfernt wurden:
docker ps -a
docker images
Verwenden von Docker System Prune
Docker bietet einen praktischen Befehl zum Bereinigen ungenutzter Ressourcen:
docker system prune
Dadurch werden alle gestoppten Container, ungenutzten Netzwerke, hängenden Images und der Build-Cache entfernt. Sie werden vor dem Fortfahren um eine Bestätigung gebeten.
Für eine aggressivere Bereinigung können Sie Folgendes verwenden:
docker system prune -a
Dadurch werden zusätzlich alle ungenutzten Images entfernt, nicht nur die hängenden.
Fazit
Sie haben jetzt gelernt, wie man:
- Docker-Images pullt und ausführt
- Laufende Container modifiziert
- Änderungen committet, um neue benutzerdefinierte Images zu erstellen
- Images für Organisation und Verteilung taggt
- Images in Dateien speichert, um sie manuell zu übertragen
- Ihre benutzerdefinierten Images dokumentiert
- Ihre Docker-Umgebung bereinigt
Diese Fähigkeiten bilden die Grundlage für die Arbeit mit Docker-Images und werden für Sie wertvoll sein, wenn Sie Ihre Reise mit der Containerisierung fortsetzen.
Zusammenfassung
In diesem praktischen Tutorial haben Sie den gesamten Prozess des Klonens eines Docker-Container-Images gelernt. Sie begannen mit dem Verständnis der Docker-Grundlagen und der Überprüfung Ihrer Umgebung. Anschließend haben Sie ein offizielles Nginx-Image gepullt und als Container ausgeführt. Als Nächstes haben Sie diesen Container angepasst, indem Sie seinen Inhalt modifiziert und diese Änderungen committet haben, um Ihr eigenes benutzerdefiniertes Image zu erstellen.
Sie haben auch gelernt, wie Sie Ihre Images für die Versionierung und Verteilung richtig taggen, wie Sie Images in Dateien für die manuelle Übertragung speichern und wie Sie Ihre Änderungen dokumentieren. Schließlich haben Sie Best Practices für die Arbeit mit Docker-Images erkundet und Ihre Umgebung bereinigt.
Diese Fähigkeiten bieten eine solide Grundlage für die Arbeit mit Docker in Entwicklungs- und Produktionsumgebungen. Sie können jetzt selbstbewusst Docker-Images erstellen und an Ihre spezifischen Anforderungen anpassen, wodurch Ihre Anwendungen über verschiedene Umgebungen hinweg portabler und konsistenter werden.
