LabEx
LoginBeitreten

Benutzerdefinierte Docker-Images

DockerBeginner
Jetzt üben

Einführung

Docker ist ein leistungsstarkes Werkzeug, um Anwendungen als Container zu verpacken und zu verteilen. Das Herzstück dieses Prozesses sind Docker-Images – vorgefertigte Pakete, die alles enthalten, was zum Ausführen einer Anwendung erforderlich ist, einschließlich Code, Abhängigkeiten und Konfigurationen. In diesem Lab lernst du, wie du benutzerdefinierte Docker-Images erstellst, um deine Anwendungen durch das Einbinden zusätzlicher Software, Bibliotheken oder Konfigurationen zu optimieren.

Während dieses gesamten Labs verwenden wir die WebIDE (VS Code) zum Bearbeiten von Dateien. Die WebIDE bietet eine vertraute und benutzerfreundliche Oberfläche für die Dateibearbeitung, was die Arbeit mit Konfigurationsdateien und Code erheblich erleichtert.

Einrichten der Projektumgebung

Beginnen wir damit, ein Projektverzeichnis zu erstellen und in dieses zu navigieren.

Während dieses gesamten Labs verwenden wir die WebIDE (VS Code) zum Bearbeiten von Dateien. Die WebIDE bietet eine vertraute und benutzerfreundliche Oberfläche für die Dateibearbeitung, was die Arbeit mit Konfigurationsdateien und Code erheblich erleichtert.

  1. Öffne ein Terminal in der WebIDE. Klicke dazu im oberen Menü auf "Terminal" und wähle dann "New Terminal".
  2. Führe im Terminal die folgenden Befehle aus:
mkdir -p ~/project/docker
cd ~/project/docker

Terminal mit den Befehlen zur Erstellung des Projektverzeichnisses

Dies erstellt ein neues Verzeichnis namens docker im Ordner ~/project und wechselt in dieses Arbeitsverzeichnis.

  1. Überprüfe, ob du dich im richtigen Verzeichnis befindest:
pwd

Du solltest /home/labex/project/docker als Ausgabe sehen.

Erläuterung dieser Befehle:

  • mkdir -p: Dieser Befehl erstellt ein Verzeichnis. Das Flag -p ermöglicht es, bei Bedarf auch übergeordnete Verzeichnisse zu erstellen.
  • cd: Dieser Befehl wechselt das aktuelle Arbeitsverzeichnis.
  • pwd: Dieser Befehl gibt das aktuelle Arbeitsverzeichnis aus.

Erstellen eines einfachen Docker-Images

Lass uns nun ein einfaches Docker-Image erstellen, das einen Nginx-Webserver ausführt.

  1. Navigiere in der WebIDE zum Datei-Explorer (normalerweise das erste Symbol in der linken Seitenleiste).
  2. Klicke mit der rechten Maustaste in den Datei-Explorer-Bereich und wähle "New File". Nenne die Datei Dockerfile (mit einem großen 'D' und ohne Dateiendung).
  3. Öffne das Dockerfile, indem du im Datei-Explorer darauf klickst. Füge den folgenden Inhalt hinzu:
FROM nginx
COPY index.html /usr/share/nginx/html/

Dieses Dockerfile definiert ein neues Image, das auf dem offiziellen Nginx-Image basiert, und kopiert eine Datei namens index.html in das Standard-Dokumentenstammverzeichnis von Nginx.

Erläuterung des Dockerfiles:

  • FROM nginx: Diese Zeile gibt das Basis-Image an, auf dem wir aufbauen. In diesem Fall verwenden wir das offizielle Nginx-Image.
  • COPY index.html /usr/share/nginx/html/: Diese Zeile kopiert unsere index.html-Datei in das Web-Stammverzeichnis des Containers.
  1. Erstelle eine neue Datei namens index.html im selben Verzeichnis. Klicke dazu erneut mit der rechten Maustaste in den Datei-Explorer-Bereich und wähle "New File".
  2. Öffne index.html und füge den folgenden Inhalt hinzu:
<!doctype html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
    <title>Hello Docker!</title>
  </head>
  <body>
    <h1>Hello Docker!</h1>
    <p>This is a custom Docker image.</p>
  </body>
</html>

Dies ist eine einfache HTML-Seite, die von unserem Nginx-Server bereitgestellt wird.

  1. Öffne ein Terminal in der WebIDE (Terminal -> New Terminal, falls du das vorherige geschlossen hast) und baue das Docker-Image mit dem folgenden Befehl:
docker build -t my-nginx .

Dieser Befehl erstellt ein neues Docker-Image mit dem Tag my-nginx.

Erläuterung des Befehls:

  • docker build: Dies ist der Befehl zum Erstellen eines Docker-Images.
  • -t my-nginx: Das Flag -t taggt unser Image mit dem Namen my-nginx.
  • .: Dies gibt den Build-Kontext (das Verzeichnis, das das Dockerfile enthält) als das aktuelle Verzeichnis an.
  1. Überprüfe nach Abschluss des Build-Vorgangs, ob das Image erfolgreich erstellt wurde:
docker images

Du solltest das my-nginx-Image in der Ausgabe sehen.

Ausführen und Testen des benutzerdefinierten Images

Lass uns einen Container auf Basis unseres neuen Images starten und testen.

  1. Starte im WebIDE-Terminal einen Container mit dem folgenden Befehl:
docker run -d -p 8080:80 --name my-nginx-container my-nginx

Erläuterung dieses Befehls:

  • docker run: Dieser Befehl erstellt und startet einen neuen Container.
  • -d: Dieses Flag führt den Container im "Detached"-Modus (im Hintergrund) aus.
  • -p 8080:80: Dies bildet Port 8080 auf deinem Host auf Port 80 im Container ab.
  • --name my-nginx-container: Dies weist unserem Container einen Namen zu.
  • my-nginx: Dies ist der Name des Images, das wir zum Erstellen des Containers verwenden.
  1. Überprüfe, ob der Container läuft:
docker ps

Du solltest my-nginx-container in der Ausgabe sehen. Dieser Befehl zeigt alle laufenden Container an.

  1. Um den Inhalt der Webseite anzuzeigen, verwende den curl-Befehl:
curl http://localhost:8080

Du solltest den HTML-Inhalt der index.html-Datei im Terminal sehen.

Falls du dich fragst, was curl macht: Es ist ein Werkzeug, um Daten von oder zu einem Server zu übertragen. In diesem Fall verwenden wir es, um den Inhalt von unserem Webserver abzurufen.

Du kannst auch oben in der LabEx-VM auf das Plus-Symbol (+) klicken, um einen neuen Webserver zu erstellen, und dann den Port 8080 eingeben, um den Inhalt anzuzeigen.

Einrichtung des Webserver-Ports

Hinzufügen benutzerdefinierter Software zum Image

In diesem Schritt änderst du dein Docker-Image, um zusätzliche Software einzubinden. Wir fügen als Beispiel den Texteditor nano hinzu, da dieser im Basis-nginx-Image nicht enthalten ist.

  1. Öffne in der WebIDE das Dockerfile. Klicke dazu im Datei-Explorer auf Dockerfile.
  2. Ändere den Inhalt des Dockerfile wie folgt:
FROM nginx
RUN apt-get update && apt-get install -y nano
COPY index.html /usr/share/nginx/html/

Dieses Dockerfile fügt eine neue RUN-Anweisung hinzu, die den Paketindex aktualisiert und das nano-Paket mithilfe des apt-get-Paketmanagers installiert.

Erläuterung der neuen Zeile:

  • RUN apt-get update && apt-get install -y nano: Diese Zeile aktualisiert die Paketliste (apt-get update) und installiert dann nano (apt-get install -y nano). Das Flag -y beantwortet automatisch alle Eingabeaufforderungen während der Installation mit "Ja".
  1. Speichere die Datei in der WebIDE mit Strg+S (oder Cmd+S auf dem Mac).
  2. Baue im WebIDE-Terminal das Docker-Image mit einem neuen Tag neu:
docker build -t my-nginx-nano .

Dieser Befehl erstellt ein neues Docker-Image mit dem Tag my-nginx-nano, das den nano-Editor enthält.

  1. Überprüfe, ob das neue Image erstellt wurde:
docker images

Du solltest das my-nginx-nano-Image in der Ausgabe sehen.

Testen des benutzerdefinierten Images mit Nano

In diesem Schritt startest du einen Container auf Basis deines neuen Images und bestätigst, dass das nano-Paket darin verfügbar ist.

  1. Starte im WebIDE-Terminal einen neuen Container mit dem folgenden Befehl:
docker run -d --name nano-container my-nginx-nano

Dieser Befehl startet einen neuen Container auf Basis des my-nginx-nano-Images und nennt ihn nano-container.

  1. Führe den folgenden Befehl aus, um die installierte nano-Version innerhalb des Containers zu überprüfen:
docker exec nano-container nano --version

Dieser Befehl führt nano --version innerhalb des laufenden Containers aus, damit du bestätigen kannst, dass das Paket installiert ist.

Erläuterung dieses Befehls:

  • docker exec: Dies führt einen Befehl in einem laufenden Container aus.
  • nano-container: Dies ist der Name unseres Containers.
  • nano --version: Dies gibt die installierte nano-Version aus dem Inneren des Containers aus.
  1. Du solltest eine Ausgabe sehen, die mit GNU nano beginnt, was bestätigt, dass das benutzerdefinierte Image nun den Editor enthält.

Verwendung von Umgebungsvariablen im Image

In diesem Schritt ändern wir unser Docker-Image, um Umgebungsvariablen für die Anpassung zu verwenden.

  1. Öffne in der WebIDE erneut das Dockerfile.

  2. Ändere den Inhalt des Dockerfile wie folgt:

FROM nginx
ENV NGINX_PORT 9000
RUN sed -i "s/listen[[:space:]]*80;/listen $NGINX_PORT;/g" /etc/nginx/conf.d/default.conf
COPY index.html /usr/share/nginx/html/

Dieses Dockerfile fügt eine ENV-Anweisung hinzu, die die Variable NGINX_PORT auf 9000 setzt. Es enthält außerdem eine RUN-Anweisung, die die Nginx-Konfiguration so ändert, dass dieser Port verwendet wird.

Erläuterung der neuen Zeilen:

  • ENV NGINX_PORT 9000: Dies setzt eine Umgebungsvariable NGINX_PORT mit dem Wert 9000.
  • RUN sed -i "s/listen[[:space:]]*80;/listen $NGINX_PORT;/g" /etc/nginx/conf.d/default.conf: Dies verwendet sed, um den Standardport (80) in der Nginx-Konfigurationsdatei durch unsere Umgebungsvariable zu ersetzen.

  1. Speichere die Datei in der WebIDE.

  2. Baue im WebIDE-Terminal das Docker-Image mit einem neuen Tag neu:

docker build -t my-nginx-env .
  1. Starte einen Container auf Basis des neuen Images:
docker run -d -p 9000:9000 --name env-container my-nginx-env

Dieser Befehl startet einen neuen Container auf Basis des my-nginx-env-Images und bildet Port 9000 auf dem Host auf Port 9000 im Container ab. Beachte, dass die Umgebungsvariable bereits im Dockerfile gesetzt ist, daher ist es nicht notwendig, sie im docker run-Befehl erneut anzugeben.

  1. Überprüfe, ob der Webserver auf dem angegebenen Port läuft:
curl http://localhost:9000

Du solltest den HTML-Inhalt der index.html-Datei im Terminal sehen.

Verwendung von ENTRYPOINT im Dockerfile

In diesem Schritt lernen wir, wie man die ENTRYPOINT-Anweisung in einem Dockerfile verwendet und einen anderen Port (9100) nutzt.

  1. Öffne in der WebIDE erneut das Dockerfile.

  2. Ändere den Inhalt des Dockerfile wie folgt:

FROM nginx
COPY index.html /usr/share/nginx/html/
COPY start.sh /start.sh
RUN chmod +x /start.sh
ENTRYPOINT ["/start.sh"]

Dieses Dockerfile entfernt die Umgebungsvariable und den sed-Befehl. Stattdessen handhaben wir die Konfiguration zur Laufzeit mithilfe eines ENTRYPOINT-Skripts. Dies macht unser Image flexibler.

  1. Erstelle eine neue Datei namens start.sh im selben Verzeichnis mit folgendem Inhalt:
#!/bin/bash
## Set a default port if NGINX_PORT is not set
export NGINX_PORT=${NGINX_PORT:-9100}
## Replace the port in the nginx configuration
sed -i "s/listen[[:space:]]*80;/listen $NGINX_PORT;/g" /etc/nginx/conf.d/default.conf
echo "Starting Nginx on port $NGINX_PORT"
nginx -g 'daemon off;'

Dieses Skript setzt einen Standardport, ändert die Nginx-Konfiguration beim Container-Start, gibt eine Nachricht aus, auf welchem Port Nginx laufen wird, und startet dann Nginx.

  1. Speichere beide Dateien in der WebIDE.

  2. Baue im WebIDE-Terminal das Docker-Image mit einem neuen Tag neu:

docker build -t my-nginx-entrypoint .
  1. Starte einen Container auf Basis des neuen Images. Wir setzen den Port mithilfe einer Umgebungsvariable auf 9100.
docker run -d -p 9100:9100 -e NGINX_PORT=9100 --name entrypoint-container my-nginx-entrypoint
  1. Überprüfe die Container-Logs, um die Startnachricht zu sehen:
docker logs entrypoint-container

Du solltest die Nachricht "Starting Nginx on port 9100" in der Ausgabe sehen.

  1. Überprüfe, ob der Webserver korrekt auf dem neuen Port läuft:
curl http://localhost:9100

Du solltest den HTML-Inhalt der index.html-Datei im Terminal sehen.

Zusammenfassung

In diesem Lab hast du gelernt, wie man benutzerdefinierte Docker-Images erstellt, die einen Mehrwert für deine Anwendungen bieten. Du hast mit einem einfachen Image mit Webserver begonnen und bist dazu übergegangen, benutzerdefinierte Software hinzuzufügen und Umgebungsvariablen für die Konfiguration zu verwenden. Während des gesamten Labs hast du die WebIDE (VS Code) zum Bearbeiten von Dateien verwendet, was den Prozess intuitiver und benutzerfreundlicher gestaltet hat.

Hier ist eine Zusammenfassung dessen, was du erreicht hast:

  1. Eine Projektumgebung eingerichtet und grundlegende Terminalbefehle erlernt.
  2. Ein einfaches Docker-Image mit Nginx und einer benutzerdefinierten HTML-Seite erstellt.
  3. Docker-Container erstellt und ausgeführt sowie Port-Mapping und Container-Benennung kennengelernt.
  4. Ein Docker-Image modifiziert, um zusätzliche Software (curl) einzubinden.
  5. docker exec verwendet, um Befehle innerhalb eines Containers auszuführen.
  6. Umgebungsvariablen in dein Docker-Image integriert, um die Konfiguration zu vereinfachen.
Verwandt Docker Kurse
Docker für Anfänger

Docker für Anfänger

dockerdevops
Docker Praxis-Challenges

Docker Praxis-Challenges

dockerdevops
Docker Praxis-Labs

Docker Praxis-Labs

dockerdevops