Wie man den docker compose build Befehl zum Erstellen von Services verwendet

Einführung

In diesem Lab lernen Sie, wie Sie den Befehl docker compose build effektiv nutzen können, um Services zu erstellen, die in einer Docker Compose-Datei definiert sind. Sie beginnen mit der Vorbereitung einer einfachen Docker Compose-Datei, um eine Multi-Container-Anwendung zu definieren.

Nach dem Setup erstellen Sie die Services mit dem Befehl docker compose build. Anschließend untersuchen Sie, wie Sie Services nach Änderungen an den entsprechenden Dockerfiles neu erstellen können. Abschließend lernen Sie, wie Sie Services mit Build-Argumenten erstellen und die Option --no-cache für einen sauberen Build verwenden können.

Skills Graph

Eine einfache Docker Compose-Datei vorbereiten

In diesem Schritt lernen Sie, wie Sie eine grundlegende Docker Compose-Datei erstellen, um Multi-Container-Docker-Anwendungen zu definieren und zu verwalten. Docker Compose ist ein Tool zum Definieren und Ausführen von Multi-Container-Docker-Anwendungen. Mit Compose verwenden Sie eine YAML-Datei, um die Services Ihrer Anwendung zu konfigurieren. Mit einem einzigen Befehl erstellen und starten Sie dann alle Services aus Ihrer Konfiguration.

Zuerst installieren wir Docker Compose. Da es in der LabEx-Umgebung nicht vorinstalliert ist, müssen wir das Binary herunterladen.

sudo curl -L "https://github.com/docker/compose/releases/download/v2.20.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

Dieser Befehl lädt das Docker Compose-Binary von der offiziellen GitHub-Releases-Seite herunter und speichert es unter /usr/local/bin/docker-compose. Die Teile $(uname -s) und $(uname -m) erkennen automatisch Ihr Betriebssystem und die Architektur, um das korrekte Binary herunterzuladen.

Als nächstes müssen wir dem heruntergeladenen Binary Ausführungsrechte erteilen.

sudo chmod +x /usr/local/bin/docker-compose

Dieser Befehl macht den docker-compose-Befehl ausführbar.

Nun überprüfen wir die Installation, indem wir die Version anzeigen lassen.

docker-compose --version

Sie sollten eine Ausgabe ähnlich zu Docker Compose version v2.20.2 sehen, was bestätigt, dass Docker Compose korrekt installiert ist.

Jetzt erstellen wir eine einfache Docker Compose-Datei. Wir definieren einen Service, der das nginx-Image verwendet.

Navigieren Sie zu Ihrem Projektverzeichnis.

cd ~/project

Erstellen Sie eine neue Datei namens docker-compose.yml mit dem nano-Editor.

nano docker-compose.yml

Fügen Sie folgenden Inhalt zur Datei hinzu:

version: "3.8"
services:
  web:
    image: nginx:latest
    ports:
      - "80:80"

Lassen Sie uns diese Datei aufschlüsseln:

• version: '3.8' gibt die Version des Docker Compose-Dateiformats an.
• services: definiert die verschiedenen Services, aus denen Ihre Anwendung besteht.
• web: ist der Name unseres Services. Sie können jeden beliebigen Namen wählen.
• image: nginx:latest spezifiziert das Docker-Image, das für diesen Service verwendet werden soll. In diesem Fall verwenden wir die neueste Version des offiziellen Nginx-Images.
• ports: bildet Ports zwischen dem Host-Rechner und dem Container ab. "80:80" bildet Port 80 auf dem Host auf Port 80 im Container ab.

Speichern Sie die Datei mit Strg + X, dann Y und Enter.

Nun laden wir das nginx:latest-Image herunter, das wir in unserer docker-compose.yml-Datei angegeben haben. Obwohl Docker Compose Images automatisch herunterladen kann, wenn Sie docker-compose up ausführen, ist es besonders in einer Lab-Umgebung ratsam, Images vorab explizit herunterzuladen, um sicherzustellen, dass sie verfügbar sind.

docker pull nginx:latest

Dieser Befehl lädt das nginx:latest-Image von Docker Hub herunter. Sie sehen eine Ausgabe, die den Download-Fortschritt anzeigt.

Services mit docker compose build erstellen

Im vorherigen Schritt haben wir eine einfache docker-compose.yml-Datei erstellt, die ein vorhandenes Docker-Image (nginx) verwendet. Docker Compose kann auch Images aus einer Dockerfile erstellen. Dies ist nützlich, wenn Sie ein Image anpassen oder ein Image für Ihre eigene Anwendung erstellen müssen.

In diesem Schritt werden wir unsere docker-compose.yml-Datei anpassen, um ein Image aus einer Dockerfile zu erstellen, anstatt ein vorgefertigtes Image zu verwenden.

Zuerst erstellen wir eine einfache Dockerfile im Verzeichnis ~/project.

nano ~/project/Dockerfile

Fügen Sie folgenden Inhalt zur Dockerfile hinzu:

FROM ubuntu:latest
RUN apt-get update && apt-get install -y cowsay
CMD ["cowsay", "Hello, Docker Compose!"]

Lassen Sie uns diese Dockerfile erklären:

• FROM ubuntu:latest spezifiziert das Basis-Image für unser neues Image. Wir verwenden die neueste Version des offiziellen Ubuntu-Images.
• RUN apt-get update && apt-get install -y cowsay aktualisiert die Paketliste und installiert das Paket cowsay. Der Befehl cowsay zeigt eine Nachricht in einer Sprechblase an, die von einer Kuh gezeichnet wird.
• CMD ["cowsay", "Hello, Docker Compose!"] setzt den Standardbefehl, der ausgeführt wird, wenn ein Container aus diesem Image gestartet wird.

Speichern Sie die Dockerfile mit Strg + X, dann Y und Enter.

Nun passen wir unsere docker-compose.yml-Datei an, um diese Dockerfile zu verwenden. Öffnen Sie die Datei zur Bearbeitung:

nano ~/project/docker-compose.yml

Ändern Sie den Inhalt wie folgt:

version: "3.8"
services:
  cow:
    build: .

In dieser aktualisierten docker-compose.yml:

• Wir haben den Service-Namen von web in cow geändert, um dessen Zweck besser widerzuspiegeln.
• Wir haben die image:-Direktive durch build: . ersetzt. Die build: .-Direktive weist Docker Compose an, das Image für diesen Service mit der Dockerfile im aktuellen Verzeichnis (.) zu erstellen.

Speichern Sie die docker-compose.yml-Datei mit Strg + X, dann Y und Enter.

Nun können wir den Befehl docker-compose build verwenden, um das Image für den cow-Service zu erstellen. Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden.

cd ~/project
docker-compose build

Dieser Befehl liest die docker-compose.yml-Datei, findet den cow-Service und erstellt das Image basierend auf der Dockerfile im aktuellen Verzeichnis. Sie sehen eine Ausgabe, die die Schritte des Build-Prozesses zeigt, einschließlich des Herunterladens des Ubuntu-Basis-Images, der Aktualisierung von Paketen und der Installation von cowsay.

Nach Abschluss des Builds können Sie überprüfen, ob das Image erstellt wurde, indem Sie Ihre lokalen Docker-Images auflisten.

docker images

Sie sollten ein Image mit einem Namen wie project_cow sehen (Docker Compose benennt Images automatisch basierend auf dem Verzeichnisnamen und dem Service-Namen) und einem Tag wie latest.

Services nach Änderungen an der Dockerfile neu erstellen

Im vorherigen Schritt haben wir ein Docker-Image mit einer Dockerfile und docker-compose build erstellt. Was passiert, wenn wir Änderungen an der Dockerfile vornehmen? Docker verwendet einen Caching-Mechanismus, um den Build-Prozess zu beschleunigen. Wenn eine Ebene in der Dockerfile unverändert bleibt, verwendet Docker die zwischengespeicherte Version anstatt sie neu zu erstellen. Wenn sich jedoch eine Ebene oder nachfolgende Ebenen ändern, wird Docker diese Ebenen neu erstellen.

In diesem Schritt werden wir unsere Dockerfile modifizieren und das Image anschließend neu erstellen, um zu sehen, wie Docker mit Änderungen umgeht.

Zuerst ändern wir die Dockerfile, um die von cowsay angezeigte Nachricht zu modifizieren. Öffnen Sie die Dockerfile zur Bearbeitung:

nano ~/project/Dockerfile

Ändern Sie die CMD-Zeile wie folgt:

FROM ubuntu:latest
RUN apt-get update && apt-get install -y cowsay
CMD ["cowsay", "Hello again, Docker Compose!"]

Wir haben die Nachricht von "Hello, Docker Compose!" zu "Hello again, Docker Compose!" geändert.

Speichern Sie die Dockerfile mit Strg + X, dann Y und Enter.

Nun erstellen wir das Image erneut mit dem Befehl docker-compose build. Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden.

cd ~/project
docker-compose build

Beobachten Sie die Ausgabe des Build-Prozesses. Sie werden feststellen, dass die ersten beiden Schritte (FROM ubuntu:latest und RUN apt-get update && apt-get install -y cowsay) wahrscheinlich die zwischengespeicherten Ebenen aus dem vorherigen Build verwenden. Der letzte Schritt (CMD ["cowsay", "Hello again, Docker Compose!"]) wird jedoch neu erstellt, da wir diese Zeile in der Dockerfile geändert haben.

Nach Abschluss des Builds können Sie überprüfen, ob das Image aktualisiert wurde, indem Sie Ihre lokalen Docker-Images auflisten.

docker images

Das project_cow-Image sollte nun die Änderungen aus der Dockerfile widerspiegeln. Während die Image-ID sich ändern kann, bleiben Name und Tag gleich.

Um die Änderung weiter zu bestätigen, können wir einen Container aus diesem neu erstellten Image ausführen und die Ausgabe betrachten.

docker run project_cow

Sie sollten die cowsay-Ausgabe mit der aktualisierten Nachricht sehen: "Hello again, Docker Compose!".

Services mit Build-Argumenten und ohne Cache erstellen

In diesem Schritt werden wir zwei erweiterte Build-Optionen mit Docker Compose untersuchen: die Verwendung von Build-Argumenten und das Erstellen ohne Cache.

Build-Argumente ermöglichen es Ihnen, Variablen an den Docker-Build-Prozess zu übergeben. Dies ist nützlich, um den Build basierend auf verschiedenen Umgebungen oder Konfigurationen anzupassen, ohne die Dockerfile selbst zu ändern.

Zuerst passen wir unsere Dockerfile an, um ein Build-Argument zu akzeptieren. Öffnen Sie die Dockerfile zur Bearbeitung:

nano ~/project/Dockerfile

Ändern Sie den Inhalt wie folgt:

FROM ubuntu:latest
ARG MESSAGE="Hello from build argument!"
RUN apt-get update && apt-get install -y cowsay
CMD ["cowsay", "$MESSAGE"]

Wir haben eine ARG MESSAGE-Anweisung hinzugefügt, um ein Build-Argument namens MESSAGE mit einem Standardwert zu definieren. Wir haben auch die CMD-Anweisung geändert, um dieses Argument zu verwenden.

Speichern Sie die Dockerfile mit Strg + X, dann Y und Enter.

Nun passen wir unsere docker-compose.yml-Datei an, um einen Wert an dieses Build-Argument zu übergeben. Öffnen Sie die Datei zur Bearbeitung:

nano ~/project/docker-compose.yml

Ändern Sie den Inhalt wie folgt:

version: "3.8"
services:
  cow:
    build:
      context: .
      args:
        MESSAGE: "Custom message from Compose!"

Wir haben die build:-Direktive in ein Objekt mit context: und args: geändert.

• context: . gibt den Build-Kontext an, also das Verzeichnis mit der Dockerfile.
• args: ist eine Map von Build-Argumenten, die an die Dockerfile übergeben werden. Wir übergeben den Wert "Custom message from Compose!" an das MESSAGE-Argument.

Speichern Sie die docker-compose.yml-Datei mit Strg + X, dann Y und Enter.

Nun erstellen wir das Image mit dem Build-Argument. Stellen Sie sicher, dass Sie sich im Verzeichnis ~/project befinden.

cd ~/project
docker-compose build

Beobachten Sie die Build-Ausgabe. Sie sollten sehen, dass das Build-Argument während des Build-Prozesses verwendet wird.

Nach Abschluss des Builds führen wir einen Container aus diesem Image aus, um die Ausgabe zu sehen.

docker run project_cow

Sie sollten die cowsay-Ausgabe mit der Nachricht "Custom message from Compose!" sehen. Dies bestätigt, dass das Build-Argument erfolgreich übergeben und verwendet wurde.

Manchmal möchten Sie Docker zwingen, alle Ebenen neu zu erstellen und den Cache zu ignorieren. Dies ist nützlich, wenn Sie Caching-Probleme vermuten oder einen sauberen Build sicherstellen möchten. Sie können dies mit dem --no-cache-Flag beim docker-compose build-Befehl tun.

Versuchen wir, das Image mit dem --no-cache-Flag neu zu erstellen.

docker-compose build --no-cache

Beobachten Sie die Build-Ausgabe erneut. Diesmal werden Sie sehen, dass Docker keine zwischengespeicherten Ebenen verwendet und jeden Schritt in der Dockerfile neu erstellt. Dieser Prozess dauert länger als ein Build mit Cache.

Nach Abschluss des Builds können Sie den Container erneut ausführen, um zu bestätigen, dass die Nachricht immer noch diejenige ist, die über das Build-Argument übergeben wurde.

docker run project_cow

Sie sollten weiterhin "Custom message from Compose!" sehen. Das --no-cache-Flag betrifft nur den Build-Prozess, nicht die in docker-compose.yml definierte Konfiguration.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie eine einfache Docker Compose-Datei vorbereiten, indem Sie Docker Compose installieren und eine docker-compose.yml-Datei erstellen, um einen Dienst mit dem nginx-Image zu definieren. Anschließend haben Sie geübt, Dienste mit dem Befehl docker compose build zu erstellen, einschließlich des Neuerstellens von Diensten nach Änderungen an der Dockerfile sowie des Erstellens von Diensten mit Build-Argumenten und ohne Verwendung des Caches.