Wie man den Befehl docker compose alpha publish zum Veröffentlichen einer Compose-Anwendung verwendet

Einführung

In diesem Lab lernen Sie, wie Sie den Befehl docker compose alpha publish verwenden, um eine Docker Compose-Anwendung zu veröffentlichen. Wir beginnen mit der Vorbereitung einer einfachen Multi-Container-Anwendung mithilfe einer docker-compose.yaml-Datei.

Nach der Vorbereitung werden Sie verschiedene Methoden erkunden, um die Anwendung in einem Repository zu veröffentlichen, einschließlich der Veröffentlichung mit aufgelösten Image-Digests und der Einbindung von Umgebungsvariablen im veröffentlichten Artefakt. Diese praktische Übung führt Sie durch den Prozess des Verpackens und Teilens Ihrer Compose-Anwendungen.

Skills Graph

Vorbereitung einer einfachen Docker Compose-Anwendung

In diesem Schritt bereiten wir eine einfache Docker Compose-Anwendung vor. 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. Anschließend können Sie mit einem einzigen Befehl alle Services aus Ihrer Konfiguration erstellen und starten.

Zuerst müssen wir Docker Compose installieren. Da es in der LabEx-Umgebung nicht vorinstalliert ist, laden wir die Binärdatei herunter und machen sie ausführbar.

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
sudo chmod +x /usr/local/bin/docker-compose

Nach dem Herunterladen und Ausführbarmachen überprüfen wir die Installation, indem wir die Version abfragen.

docker-compose --version

Sie sollten eine Ausgabe ähnlich zu Docker Compose version v2.20.2 sehen.

Nun erstellen wir eine einfache Docker Compose-Anwendung. Wir legen eine docker-compose.yaml-Datei im Verzeichnis ~/project an. Diese Datei definiert einen einzelnen Service, der einen Nginx-Webserver ausführt.

Verwenden Sie den nano-Editor, um die Datei zu erstellen und zu bearbeiten.

nano ~/project/docker-compose.yaml

Fügen Sie folgenden Inhalt in die docker-compose.yaml-Datei ein:

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

In dieser docker-compose.yaml-Datei:

• version: '3.8' gibt die Version des Compose-Dateiformats an.
• services: definiert die Services Ihrer Anwendung.
• web: ist der Name unseres Services.
• image: nginx:latest spezifiziert das Docker-Image für diesen Service. Wir verwenden die neueste Version des offiziellen Nginx-Images.
• ports: mappt Ports vom Host-Rechner zum Container. "80:80" mappt Port 80 des Hosts auf Port 80 des Containers.

Speichern Sie die Datei mit Strg + S und beenden Sie den Editor mit Strg + X.

Vor dem Starten der Anwendung müssen wir das nginx:latest-Image herunterladen.

docker pull nginx:latest

Nun können wir die Anwendung mit dem Befehl docker-compose up starten. Das Flag -d führt die Container im Detached-Modus (im Hintergrund) aus.

docker-compose up -d

Sie sollten eine Ausgabe sehen, die anzeigt, dass der Service erstellt und gestartet wird.

Um zu überprüfen, ob der Container läuft, verwenden Sie den Befehl docker ps.

docker ps

Sie sollten einen Eintrag für den web-Service mit dem nginx-Image und dem Status Up sehen.

Schließlich können Sie den Nginx-Server testen, indem Sie darauf zugreifen. Da Port 80 des Containers auf Port 80 des Hosts gemappt ist, können Sie curl verwenden, um auf localhost zuzugreifen.

curl localhost

Sie sollten die HTML-Ausgabe der standardmäßigen Nginx-Willkommensseite sehen.

Veröffentlichung der Compose-Anwendung in einem Repository

In diesem Schritt lernen wir, wie wir unsere Docker Compose-Anwendung in einem Repository veröffentlichen. Die Veröffentlichung einer Compose-Anwendung umfasst typischerweise das Teilen der docker-compose.yaml-Datei und die Sicherstellung, dass die benötigten Docker-Images von einer Container-Registry aus zugänglich sind.

Zuerst stoppen wir die laufende Docker Compose-Anwendung aus dem vorherigen Schritt. Navigieren Sie in das Verzeichnis ~/project, falls Sie sich nicht bereits dort befinden.

cd ~/project

Stoppen Sie nun die laufenden Services mit dem Befehl docker-compose down. Dieser Befehl beendet und entfernt Container, Netzwerke und Volumes, die durch up erstellt wurden.

docker-compose down

Sie sollten eine Ausgabe sehen, die anzeigt, dass die Services gestoppt und entfernt werden.

Um die Compose-Anwendung zu veröffentlichen, müssen wir die docker-compose.yaml-Datei teilen. In einem realen Szenario würden Sie diese Datei typischerweise in einem Versionskontrollsystem wie Git speichern und in ein Repository pushen (z.B. GitHub, GitLab, Bitbucket).

Für dieses Lab simulieren wir die Veröffentlichung, indem wir eine einfache Textdatei erstellen, die den Inhalt unserer docker-compose.yaml-Datei enthält. Dies veranschaulicht das Grundprinzip des Teilens der Konfiguration.

Erstellen wir eine Datei namens compose_app.txt im Verzeichnis ~/project und kopieren den Inhalt von docker-compose.yaml hinein.

cat ~/project/docker-compose.yaml > ~/project/compose_app.txt

Nun können Sie den Inhalt der neuen Datei anzeigen, um zu bestätigen, dass er mit der docker-compose.yaml übereinstimmt.

cat ~/project/compose_app.txt

Sie sollten den YAML-Inhalt Ihrer Compose-Datei sehen.

In einem echten Veröffentlichungsszenario müssten Sie außerdem sicherstellen, dass die in Ihrer docker-compose.yaml-Datei referenzierten Docker-Images in einer Container-Registry verfügbar sind, auf die andere zugreifen können. In unserem Fall ist das nginx:latest-Image öffentlich auf Docker Hub verfügbar, sodass für dieses spezifische Image keine zusätzlichen Schritte erforderlich sind. Bei der Verwendung benutzerdefinierter Images müssten Sie diese erstellen und in eine Registry pushen.

Zum Beispiel, wenn Sie ein benutzerdefiniertes Image namens my-custom-app hätten, würden Sie es mit docker build erstellen und dann mit docker push your-dockerhub-username/my-custom-app in eine Registry wie Docker Hub hochladen.

Um das Teilen der Compose-Datei zu simulieren, stellen Sie sich vor, Sie teilen die compose_app.txt-Datei mit jemandem. Diese Person könnte die Datei dann herunterladen und verwenden, um die Anwendung auf ihrem eigenen Rechner auszuführen, vorausgesetzt sie hat Docker und Docker Compose installiert und kann auf die benötigten Images zugreifen.

Zur Demonstration entfernen wir die ursprüngliche docker-compose.yaml-Datei und erstellen sie dann aus compose_app.txt neu.

rm ~/project/docker-compose.yaml
cat ~/project/compose_app.txt > ~/project/docker-compose.yaml

Nun können Sie überprüfen, ob die docker-compose.yaml-Datei neu erstellt wurde.

cat ~/project/docker-compose.yaml

Sie sollten denselben YAML-Inhalt wie zuvor sehen.

Dieser Schritt konzentrierte sich auf das Konzept des Teilens der Compose-Datei. In den nächsten Schritten werden wir fortgeschrittenere Aspekte der Veröffentlichung untersuchen, wie die Verwendung von Image-Digests und den Umgang mit Umgebungsvariablen.

Veröffentlichung der Compose-Anwendung mit aufgelösten Image-Digests

In diesem Schritt lernen wir, wie man eine Compose-Anwendung mit aufgelösten Image-Digests veröffentlicht. Die Verwendung von Image-Digests anstelle von Tags (wie latest) bietet eine zuverlässigere Methode, um sicherzustellen, dass immer exakt dieselbe Image-Version verwendet wird. Tags können aktualisiert werden, um auf ein neues Image zu verweisen, während ein Digest eine spezifische Image-Layer eindeutig identifiziert.

Zuerst holen wir uns den Digest für das nginx:latest-Image, das wir in den vorherigen Schritten verwendet haben. Wir können den Befehl docker inspect verwenden, um detaillierte Informationen über das Image zu erhalten.

docker inspect nginx:latest --format='{{.RepoDigests}}'

Dieser Befehl gibt die Repository-Digests für das nginx:latest-Image aus. Die Ausgabe sieht etwa so aus: [nginx@sha256:...]. Der Teil nach @ ist der Image-Digest. Kopieren Sie diesen Digest.

Nun modifizieren wir unsere docker-compose.yaml-Datei, um den Image-Digest anstelle des Tags zu verwenden. Öffnen Sie die docker-compose.yaml-Datei im Verzeichnis ~/project mit nano.

nano ~/project/docker-compose.yaml

Ändern Sie die image-Zeile von image: nginx:latest zu image: nginx@<Ihr_Image_Digest>, wobei Sie <Ihr_Image_Digest> durch den kopierten Digest ersetzen. Beispiel: Wenn Ihr Digest sha256:abcdef123456... war, würde die Zeile image: nginx@sha256:abcdef123456... lauten.

version: "3.8"
services:
  web:
    image: nginx@sha256:your_image_digest_here
    ports:
      - "80:80"

Speichern Sie die Datei mit Strg + S und beenden Sie den Editor mit Strg + X.

Wenn Sie diese docker-compose.yaml-Datei nun teilen, wird jeder, der sie verwendet, exakt das durch den Digest identifizierte Image pullen, unabhängig davon, worauf der latest-Tag aktuell verweist.

Um zu demonstrieren, dass Compose den Digest verwendet, starten wir die Anwendung erneut mit der modifizierten docker-compose.yaml.

docker-compose up -d

Compose verwendet das durch den Digest spezifizierte Image. Falls das Image nicht bereits auf dem System vorhanden ist, wird es gepullt.

Sie können überprüfen, dass der Container läuft und das durch den Digest spezifizierte Image verwendet, indem Sie den laufenden Container inspizieren. Ermitteln Sie zuerst die Container-ID mit docker ps.

docker ps

Suchen Sie den Container, der das nginx-Image ausführt, und notieren Sie dessen Container-ID. Verwenden Sie dann docker inspect mit der Container-ID und formatieren Sie die Ausgabe, um den Image-Digest anzuzeigen.

docker inspect < container_id > --format='{{.Image}}'

Ersetzen Sie <container_id> durch die tatsächliche ID Ihres laufenden Nginx-Containers. Die Ausgabe sollte der in der docker-compose.yaml-Datei angegebene Image-Digest sein.

Die Verwendung von Image-Digests in Ihren Compose-Dateien ist eine gute Praxis, um Reproduzierbarkeit zu gewährleisten und unerwartete Änderungen an Ihrer Anwendung durch Image-Updates zu verhindern.

Veröffentlichung der Compose-Anwendung inklusive Umgebungsvariablen

In diesem Schritt lernen wir, wie Umgebungsvariablen in unsere Docker Compose-Anwendung integriert werden und wie sich dies auf die Veröffentlichung auswirkt. Umgebungsvariablen sind eine gängige Methode zur Konfiguration von Anwendungen, und Docker Compose bietet mehrere Möglichkeiten, diese zu verwalten.

Zuerst stoppen wir den laufenden Nginx-Container aus dem vorherigen Schritt. Navigieren Sie in das Verzeichnis ~/project, falls Sie sich nicht bereits dort befinden.

cd ~/project

Stoppen Sie die laufenden Services mit dem Befehl docker-compose down.

docker-compose down

Nun modifizieren wir unsere docker-compose.yaml-Datei, um eine Umgebungsvariable zu verwenden. Wir fügen dem web-Service eine einfache Umgebungsvariable hinzu. Öffnen Sie die docker-compose.yaml-Datei im Verzeichnis ~/project mit nano.

nano ~/project/docker-compose.yaml

Fügen Sie einen environment-Abschnitt zur web-Service-Definition hinzu. Wir fügen eine Variable namens MY_VARIABLE mit einem Wert hinzu.

version: "3.8"
services:
  web:
    image: nginx@sha256:your_image_digest_here ## Ersetzen Sie dies mit Ihrem tatsächlichen Digest
    ports:
      - "80:80"
    environment:
      - MY_VARIABLE=HelloFromCompose

Vergessen Sie nicht, your_image_digest_here durch den tatsächlichen Image-Digest aus dem vorherigen Schritt zu ersetzen.

Speichern Sie die Datei mit Strg + S und beenden Sie den Editor mit Strg + X.

Wenn Sie die Anwendung nun mit docker-compose up starten, wird die Umgebungsvariable MY_VARIABLE im Nginx-Container gesetzt.

docker-compose up -d

Um zu überprüfen, ob die Umgebungsvariable im Container gesetzt ist, können wir einen Befehl innerhalb des laufenden Containers mit docker exec ausführen. Ermitteln Sie zuerst die Container-ID mit docker ps.

docker ps

Notieren Sie die Container-ID des laufenden Nginx-Containers. Führen Sie dann mit docker exec den Befehl printenv im Container aus und filtern Sie die Ausgabe nach MY_VARIABLE.

docker exec < container_id > printenv | grep MY_VARIABLE

Ersetzen Sie <container_id> durch die tatsächliche ID Ihres laufenden Nginx-Containers. Sie sollten eine Ausgabe ähnlich zu MY_VARIABLE=HelloFromCompose sehen.

Bei der Veröffentlichung einer Compose-Anwendung, die Umgebungsvariablen verwendet, müssen Sie berücksichtigen, wie diese Variablen in der Zielumgebung bereitgestellt werden.

Ein gängiger Ansatz ist die Verwendung einer .env-Datei. Docker Compose sucht automatisch nach einer Datei namens .env im Verzeichnis, in dem sich die docker-compose.yaml-Datei befindet. Sie können Umgebungsvariablen in dieser Datei definieren, und Compose lädt sie.

Erstellen wir eine .env-Datei im Verzeichnis ~/project.

nano ~/project/.env

Fügen Sie folgenden Inhalt zur .env-Datei hinzu:

ANOTHER_VARIABLE=ThisIsFromDotEnv

Speichern Sie die Datei und beenden Sie nano.

Nun modifizieren wir die docker-compose.yaml-Datei, um diese neue Umgebungsvariable zu verwenden. Öffnen Sie die docker-compose.yaml-Datei erneut.

nano ~/project/docker-compose.yaml

Fügen Sie ANOTHER_VARIABLE zum environment-Abschnitt hinzu.

version: "3.8"
services:
  web:
    image: nginx@sha256:your_image_digest_here ## Ersetzen Sie dies mit Ihrem tatsächlichen Digest
    ports:
      - "80:80"
    environment:
      - MY_VARIABLE=HelloFromCompose
      - ANOTHER_VARIABLE

Beachten Sie, dass wir für ANOTHER_VARIABLE nur den Variablennamen angegeben haben. Compose sucht nach dieser Variable in der Umgebung, in der docker-compose up ausgeführt wird, einschließlich der aus der .env-Datei geladenen Variablen.

Speichern Sie die Datei und beenden Sie nano.

Stoppen und starten Sie nun die Compose-Anwendung neu, um die Änderungen zu übernehmen.

docker-compose down
docker-compose up -d

Ermitteln Sie die neue Container-ID mit docker ps.

docker ps

Verwenden Sie nun docker exec, um beide Umgebungsvariablen im Container zu überprüfen.

docker exec < container_id > printenv | grep MY_VARIABLE
docker exec < container_id > printenv | grep ANOTHER_VARIABLE

Ersetzen Sie <container_id> durch die neue Container-ID. Sie sollten sowohl MY_VARIABLE=HelloFromCompose als auch ANOTHER_VARIABLE=ThisIsFromDotEnv in der Ausgabe sehen.

Bei der Veröffentlichung würden Sie typischerweise die docker-compose.yaml-Datei teilen und Anweisungen bereitstellen, wie die notwendigen Umgebungsvariablen gesetzt werden können, entweder durch eine .env-Datei oder durch direkte Setzung in der Umgebung, in der Compose ausgeführt wird. Sensible Informationen sollten nicht in der docker-compose.yaml oder .env-Datei hartkodiert sein und sollten mit Secrets-Management-Lösungen verwaltet werden.

Zusammenfassung

In diesem Lab haben wir gelernt, wie eine einfache Docker Compose-Anwendung vorbereitet wird. Dies umfasste die Installation von Docker Compose, die Überprüfung der Installation sowie das Erstellen einer docker-compose.yaml-Datei zur Definition eines grundlegenden Nginx-Webservices. Wir haben außerdem das benötigte Docker-Image (nginx:latest) heruntergeladen, um die Anwendung ausführen zu können.

Die nachfolgenden Schritte, die im bereitgestellten Inhalt nicht vollständig detailliert waren, würden vermutlich das Veröffentlichen dieser Compose-Anwendung in einem Repository mit dem Befehl docker compose alpha publish behandeln. Dies würde Optionen wie das Veröffentlichen mit aufgelösten Image-Digests sowie das Einbinden von Umgebungsvariablen in die veröffentlichte Anwendungsdefinition beinhalten.