LabEx
LoginBeitreten

Benutzerdefinierte Docker-Images

DockerBeginner
Jetzt üben

Einführung

Docker ist ein leistungsstarkes Werkzeug zum Paketieren und Verteilen von Anwendungen in Form von Containern. Das Herzstück dieses Prozesses sind Docker-Images – vorkonfigurierte Pakete, die alles enthalten, was für die Ausführung einer Anwendung erforderlich ist, einschließlich Code, Abhängigkeiten und Konfigurationen. In diesem Lab lernen Sie, wie Sie eigene Docker-Images erstellen, um Ihre Anwendungen durch zusätzliche Software, Bibliotheken oder spezifische Einstellungen zu optimieren.

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

Projektumgebung einrichten

Beginnen wir damit, ein Projektverzeichnis zu erstellen und dorthin zu navigieren.

Wir nutzen die WebIDE (VS Code), um Dateien zu bearbeiten. Dies macht den Umgang mit Konfigurationsdateien intuitiver.

  1. Öffnen Sie ein Terminal in der WebIDE. Klicken Sie dazu im oberen Menü auf „Terminal“ und wählen Sie „New Terminal“.
  2. Führen Sie im Terminal die folgenden Befehle aus:
mkdir -p ~/project/docker
cd ~/project/docker
Terminal zeigt Befehle zur Erstellung des Projektverzeichnisses

Dies erstellt einen neuen Ordner namens docker im Verzeichnis ~/project und wechselt direkt in diesen Ordner.

  1. Überprüfen Sie, ob Sie sich im richtigen Verzeichnis befinden:
pwd

Als Ausgabe sollten Sie /home/labex/project/docker sehen.

Erläuterung der Befehle:

  • mkdir -p: Dieser Befehl erstellt ein Verzeichnis. Das Flag -p sorgt dafür, dass auch übergeordnete Verzeichnisse erstellt werden, falls sie noch nicht existieren.
  • cd: Dieser Befehl wechselt das aktuelle Arbeitsverzeichnis.
  • pwd: Dieser Befehl gibt den Pfad des aktuellen Arbeitsverzeichnisses aus.

Ein einfaches Docker-Image erstellen

Erstellen wir nun ein einfaches Docker-Image, das einen Nginx-Webserver ausführt.

  1. Navigieren Sie in der WebIDE zum Datei-Explorer (normalerweise das erste Symbol in der linken Seitenleiste).
  2. Klicken Sie mit der rechten Maustaste in den Bereich des Datei-Explorers und wählen Sie „New File“. Nennen Sie die Datei Dockerfile (mit großem 'D' und ohne Dateiendung).
  3. Öffnen Sie das Dockerfile per Klick und fügen Sie folgenden Inhalt hinzu:
FROM nginx
COPY index.html /usr/share/nginx/html/

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

Das Dockerfile verstehen:

  • FROM nginx: Diese Zeile legt das Basis-Image fest. In diesem Fall nutzen wir das offizielle Nginx-Image.
  • COPY index.html /usr/share/nginx/html/: Diese Zeile kopiert unsere lokale index.html in das Web-Verzeichnis innerhalb des Containers.
  1. Erstellen Sie eine neue Datei namens index.html im selben Verzeichnis.
  2. Öffnen Sie index.html und fügen Sie diesen 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 ausgeliefert wird.

  1. Öffnen Sie das Terminal in der WebIDE und erstellen (builden) Sie das Docker-Image mit folgendem Befehl:
docker build -t my-nginx .

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

Den Befehl verstehen:

  • docker build: Der Befehl zum Erstellen eines Images.
  • -t my-nginx: Das Flag -t (Tag) gibt dem Image einen Namen.
  • .: Der Punkt am Ende gibt den Build-Kontext an (das aktuelle Verzeichnis, in dem das Dockerfile liegt).
  1. Überprüfen Sie nach Abschluss des Vorgangs, ob das Image erfolgreich erstellt wurde:
docker images

Sie sollten my-nginx in der Liste der verfügbaren Images sehen.

Das benutzerdefinierte Image ausführen und testen

Lassen Sie uns nun einen Container auf Basis unseres neuen Images starten und testen.

  1. Starten Sie im WebIDE-Terminal den Container mit folgendem Befehl:
docker run -d -p 8080:80 --name my-nginx-container my-nginx

Diesen Befehl verstehen:

  • docker run: Erstellt und startet einen neuen Container.
  • -d: Führt den Container im „Detached“-Modus (im Hintergrund) aus.
  • -p 8080:80: Leitet den Port 8080 Ihres Host-Systems auf den Port 80 im Container um.
  • --name my-nginx-container: Weist dem Container einen eindeutigen Namen zu.
  • my-nginx: Der Name des Images, das wir verwenden möchten.
  1. Überprüfen Sie, ob der Container läuft:
docker ps

my-nginx-container sollte in der Liste erscheinen. Dieser Befehl zeigt alle aktiven Container an.

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

Sie sollten den HTML-Inhalt der Datei index.html im Terminal sehen.

Falls Sie sich fragen, was curl macht: Es ist ein Werkzeug zur Datenübertragung von oder zu einem Server. Hier nutzen wir es, um die Daten von unserem Webserver abzurufen.

Alternativ können Sie am oberen Rand der LabEx-VM auf das „+“-Symbol klicken, um einen neuen Webserver-Tab zu öffnen. Geben Sie dort den Port 8080 ein, um die Seite im Browser zu sehen.

Webserver Port-Einrichtung

Zusätzliche Software zum Image hinzufügen

Passen wir unser Docker-Image nun an, um weitere Software zu integrieren. Als Beispiel installieren wir das Werkzeug curl direkt im Image.

  1. Öffnen Sie das Dockerfile in der WebIDE.
  2. Ändern Sie den Inhalt des Dockerfile wie folgt ab:
FROM nginx
RUN apt-get update && apt-get install -y curl
COPY index.html /usr/share/nginx/html/

Dieses Dockerfile enthält nun eine RUN-Anweisung, die den Paketindex aktualisiert und curl über den Paketmanager apt-get installiert.

Die neue Zeile verstehen:

  • RUN apt-get update && apt-get install -y curl: Aktualisiert die Paketliste und installiert curl. Das Flag -y bestätigt alle Installationsabfragen automatisch mit „Ja“.
  1. Speichern Sie die Datei in der WebIDE mit Strg+S (oder Cmd+S auf dem Mac).
  2. Bauen Sie das Image im Terminal unter einem neuen Namen neu:
docker build -t my-nginx-curl .

Damit erstellen wir ein Image namens my-nginx-curl, das bereits curl vorinstalliert hat.

  1. Überprüfen Sie die Erstellung:
docker images

my-nginx-curl sollte nun in der Liste erscheinen.

Das Image mit Curl testen

Starten wir einen Container basierend auf dem neuen Image und testen die Funktionalität von curl innerhalb des Containers.

  1. Starten Sie einen neuen Container:
docker run -d --name curl-container my-nginx-curl
  1. Öffnen Sie eine interaktive Shell (Bash) innerhalb des laufenden Containers:
docker exec -it curl-container bash

Diesen Befehl verstehen:

  • docker exec: Führt einen Befehl in einem laufenden Container aus.
  • -it: Diese Flags ermöglichen eine interaktive Sitzung mit Terminal-Anbindung (TTY).
  • curl-container: Der Name unseres Ziel-Containers.
  • bash: Der Befehl, den wir ausführen (die Bash-Shell öffnen).
  1. Sie sehen nun eine neue Eingabeaufforderung, die anzeigt, dass Sie sich im Container befinden. Testen Sie dort curl:
curl http://localhost

Sie sollten den HTML-Inhalt der index.html sehen.

  1. Verlassen Sie die Shell des Containers:
exit

Sie befinden sich nun wieder auf Ihrem Host-System.

Umgebungsvariablen im Image verwenden

In diesem Schritt modifizieren wir das Image so, dass es Umgebungsvariablen zur Konfiguration nutzt.

  1. Öffnen Sie das Dockerfile erneut in der WebIDE.

  2. Ändern Sie den Inhalt 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 nutzt ENV, um die Variable NGINX_PORT auf 9000 zu setzen. Die RUN-Anweisung nutzt sed, um die Nginx-Konfiguration so anzupassen, dass dieser Port verwendet wird.

Die neuen Zeilen verstehen:

  • ENV NGINX_PORT 9000: Definiert eine Umgebungsvariable mit dem Wert 9000.
  • RUN sed -i ...: Nutzt den Stream-Editor sed, um den Standard-Port 80 in der Konfigurationsdatei durch den Wert der Variable zu ersetzen.

  1. Speichern Sie die Datei.

  2. Bauen Sie das Image neu:

docker build -t my-nginx-env .
  1. Starten Sie einen Container basierend auf diesem Image:
docker run -d -p 9000:9000 --name env-container my-nginx-env

Hier mappen wir Port 9000 des Hosts auf Port 9000 des Containers. Da die Variable bereits im Dockerfile festgeschrieben ist, müssen wir sie beim Start nicht erneut angeben.

  1. Testen Sie den Zugriff über den neuen Port:
curl http://localhost:9000

ENTRYPOINT im Dockerfile verwenden

Wir lernen nun, wie man die ENTRYPOINT-Anweisung nutzt, um die Konfiguration beim Start des Containers noch flexibler zu gestalten (wir nutzen beispielhaft Port 9100).

  1. Öffnen Sie das Dockerfile erneut.

  2. Ändern Sie den Inhalt auf:

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

Wir haben die festen sed-Befehle entfernt. Stattdessen nutzen wir ein Skript beim Start (ENTRYPOINT), was das Image wesentlich flexibler macht.

  1. Erstellen Sie eine neue Datei namens start.sh im selben Verzeichnis mit folgendem Inhalt:
#!/bin/bash
## Standard-Port setzen, falls NGINX_PORT nicht definiert ist
export NGINX_PORT=${NGINX_PORT:-9100}
## Port in der Nginx-Konfiguration ersetzen
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 Standardwert, passt die Konfiguration beim Container-Start an, gibt eine Statusmeldung aus und startet Nginx im Vordergrund.

  1. Speichern Sie beide Dateien.

  2. Bauen Sie das Image neu:

docker build -t my-nginx-entrypoint .
  1. Starten Sie den Container und setzen Sie den Port 9100 explizit über eine Umgebungsvariable:
docker run -d -p 9100:9100 -e NGINX_PORT=9100 --name entrypoint-container my-nginx-entrypoint
  1. Prüfen Sie die Logs, um die Startmeldung zu sehen:
docker logs entrypoint-container

Sie sollten "Starting Nginx on port 9100" in der Ausgabe sehen.

  1. Überprüfen Sie den Zugriff:
curl http://localhost:9100

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie maßgeschneiderte Docker-Images erstellen. Sie haben mit einem einfachen Webserver-Image begonnen und sich bis zur Installation von Software und der dynamischen Konfiguration mittels Umgebungsvariablen und Start-Skripten vorgearbeitet. Durch die Nutzung der WebIDE konnten Sie Dateien effizient und benutzerfreundlich bearbeiten.

Hier ist ein Rückblick auf Ihre Erfolge:

  1. Einrichtung einer Projektumgebung und Beherrschung grundlegender Terminal-Befehle.
  2. Erstellung eines Docker-Images mit Nginx und einer eigenen HTML-Seite.
  3. Build und Ausführung von Containern inklusive Port-Mapping.
  4. Erweiterung eines Images um zusätzliche Software (curl).
  5. Nutzung von docker exec für die Interaktion mit laufenden Containern.
  6. Einsatz von Umgebungsvariablen und ENTRYPOINT für flexible Konfigurationen.
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