Tutorial

Installieren und Verwenden von Docker Compose unter Ubuntu 20.04

Published on July 16, 2020

Deutsch

Installieren und Verwenden von Docker Compose unter Ubuntu 20.04

Einführung

Docker vereinfacht die Verwaltung von Anwendungsprozessen in Containern. Obwohl Container in gewisser Hinsicht virtuellen Rechnern ähneln, sind sie leichter und ressourcenschonender. Dies ermöglicht Entwicklern, eine Anwendungsumgebung in mehrere isolierte Dienste zu unterteilen.

Bei Anwendungen, die von mehreren Diensten abhängig sind, kann die Organisation aller Container zum gemeinsamen Starten, Kommunizieren und Herunterfahren schnell unhandlich werden. Docker Compose ist ein Tool, mit dem Sie Anwendungsumgebungen mit mehreren Containern basierend auf in einer YAML-Datei festgelegten Definitionen ausführen können. Er verwendet Dienst-Definitionen zum Aufbau voll anpassbarer Umgebungen mit mehreren Containern, die Netzwerke und Datenvolumes teilen können.

In diesem Leitfaden zeigen wir Ihnen, wie Sie Docker Compose auf einem Ubuntu 20.04-Server installieren und wie Sie mit der Verwendung dieses Tools beginnen können.

Voraussetzungen

Um diese Anleitung mitzuverfolgen, benötigen Sie:

Zugriff auf einen lokalen Ubuntu-20.04-Rechner oder einen Entwicklungsserver als Nicht-root-Benutzer und mit sudo-Berechtigungen. Wenn Sie einen Remote-Server verwenden, ist es ratsam, eine aktive Firewall installiert zu haben. Um diese Einzurichten, lesen Sie bitte unseren Leitfaden zur Ersteinrichtung eines Servers für Ubuntu 20.04.
Auf Ihrem Server oder Ihrem lokalen Rechner gemäß den Schritten 1 und 2 von Installieren und Verwenden von Docker unter Ubuntu 20.04 installiertes Docker.

Schritt 1 – Installieren von Docker Compose

Um sicherzustellen, dass wir die aktuellste stabile Version von Docker Compose erhalten, werden wir diese Software von ihrem offiziellen Github-Repository herunterladen.

Bestätigen Sie zunächst die auf ihrer Seite verfügbare neueste Version. Zum Zeitpunkt des Schreibens dieses Artikels ist die aktuellste stabile Version 1.26.0.

Mit dem folgenden Befehl wird die Version 1.26.0 herunterladen und die ausführbare Datei unter /usr/local/bin/docker-compose gespeichert, wodurch diese Software global als docker-compose zugänglich wird:

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

Legen Sie als Nächstes die richtigen Berechtigungen fest, damit der Befehl docker-compose ausführbar ist:

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

Um zu überprüfen, ob die Installation erfolgreich war, können Sie Folgendes ausführen:

docker-compose --version

Sie sehen eine Ausgabe, die dieser ähnelt:

Output
docker-compose version 1.26.0, build 8a1c60f6

Docker Compose ist nun erfolgreich auf Ihrem System installiert. Im nächsten Abschnitt sehen wir uns an, wie Sie eine docker-compose.yml-Datei einrichten und mit diesem Tool eine containerisierte Umgebung zum Laufen bringen.

Schritt 2 — Einrichten einer `docker-compose.yml`-Datei

Um zu zeigen, wie eine docker-compose.yml-Datei eingerichtet und mit Docker Compose gearbeitet wird, erstellen wir unter Verwendung des offiziellen Nginx-Images vom Docker Hub, der öffentlichen Docker-Registry, eine Webserverumgebung Diese containerisierte Umgebung wird eine einzelne statische HTML-Datei bereitstellen.

Beginnen Sie mit der Erstellung eines neuen Verzeichnisses in Ihrem Home-Ordner und verschieben Sie dieses dann zu:

mkdir ~/compose-demo
cd ~/compose-demo

Richten Sie in diesem Verzeichnis einen Anwendungsordner ein, der als Dokumentenstamm für Ihre Nginx-Umgebung dient:

mkdir app

Erstellen Sie mit Ihrem bevorzugten Texteditor eine neue index.html-Datei innerhalb des Ordners app:

nano app/index.html

Geben Sie den folgenden Inhalt in diese Datei ein:

~/compose-demo/app/index.html

<!doctype html>
<html lang="en">
<head>
    <meta charset="utf-8">
    <title>Docker Compose Demo</title>
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/gh/kognise/water.css@latest/dist/dark.min.css">
</head>
<body>

	<h1>This is a Docker Compose Demo Page.</h1>
	<p>This content is being served by an Nginx container.</p>

</body>
</html>

Speichern und schließen Sie die Datei, wenn Sie fertig sind. Wenn Sie nano verwenden, können Sie STRG+X drücken, dann Y eingeben und zur Bestätigung ENTER drücken.

Erstellen Sie als Nächstes die Datei docker-compose.yml:

nano docker-compose.yml

Geben Sie den folgenden Inhalt in Ihre Datei docker-compose.yml ein:

docker-compose.yml

version: '3.7'
services:
  web:
    image: nginx:alpine
    ports:
      - "8000:80"
    volumes:
      - ./app:/usr/share/nginx/html

Die Datei docker-compose.yml beginnt typischerweise mit der version-Definition. Dadurch wird Docker Compose mitgeteilt, welche Konfigurationsversion wir verwenden.

Dann haben wir den services-Block, in dem wir die Dienste einrichten, die Teil dieser Umgebung sind. In unserem Fall haben wir einen einzigen Dienst namens web. Dieser Dienst verwendet das Image nginx:alpine und richtet mit der Anweisung ports eine Portumleitung ein. Alle Anfragen auf Port 8000 des Host-Rechners (das System, von dem aus Docker Compose ausgeführt wird) werden auf den Web-Container auf Port 80 umgeleitet, wo Nginx ausgeführt wird.

Die Anweisung volumes erstellt ein gemeinsames Volumen zwischen dem Host-Rechner und dem Container. Dadurch wird der lokale Ordner app mit dem Container geteilt und das Volumen befindet sich unter /usr/share/nginx/html innerhalb des Containers, der dann den Standard-Dokumentenstamm für Nginx überschreibt.

Speichern und schließen Sie die Datei.

Wir haben eine Demo-Seite und eine Datei docker-compose.yml eingerichtet, um eine containerisierte Webserverumgebung zu erstellen, die sie bedienen wird. Im nächsten Schritt stellen wir diese Umgebung mit Docker Compose bereit.

Schritt 3 — Ausführen von Docker Compose

Mit der docker-compose.yml-Datei können wir nun Docker Compose ausführen, um unserer Umgebung aufzurufen. Der folgende Befehl lädt die erforderlichen Docker-Images herunter, erstellt einen Container für den web-Dienst und führt die containerisierte Umgebung im Hintergrundmodus aus:

docker-compose up -d

Docker Compose sucht zunächst nach dem definierten Image auf Ihrem lokalen System, und wenn es das Image nicht lokalisieren kann, wird es das Image vom Docker Hub herunterladen. Die Ausgabe sieht dann so aus:

Output
Creating network "compose-demo_default" with the default driver
Pulling web (nginx:alpine)...
alpine: Pulling from library/nginx
cbdbe7a5bc2a: Pull complete
10c113fb0c77: Pull complete
9ba64393807b: Pull complete
c829a9c40ab2: Pull complete
61d685417b2f: Pull complete
Digest: sha256:57254039c6313fe8c53f1acbf15657ec9616a813397b74b063e32443427c5502
Status: Downloaded newer image for nginx:alpine
Creating compose-demo_web_1 ... done

Ihre Umgebung ist nun aktiviert und wird im Hintergrund ausgeführt. Um zu überprüfen, ob der Container aktiv ist, können Sie Folgendes ausführen:

docker-compose ps

Dieser Befehl zeigt Ihnen Informationen über die ausgeführten Container und ihren Zustand sowie alle derzeit bestehenden Portumleitungen an:

Output       Name                     Command               State          Ports        
----------------------------------------------------------------------------------
compose-demo_web_1   /docker-entrypoint.sh ngin ...   Up      0.0.0.0:8000->80/tcp

Sie können nun auf die Demo-Anwendung zugreifen, indem Sie Ihren Browser entweder auf localhost:8000 verweisen, wenn Sie diese Demo auf Ihrem lokalen Rechner ausführen, oder auf your_server_domain_or_IP:8000, wenn Sie diese Demo auf einem Remote-Server ausführen.

Sie sehen in etwa folgende Seite:

Docker Compose Demo-Seite

Da das gemeinsame Volumen, das Sie in der Datei docker-compose.yml eingerichtet haben, Ihre app-Orderndateien mit dem Dokumentenstamm des Containers synchronisiert hält. Wenn Sie Änderungen an der Datei index.html vornehmen, werden diese automatisch vom Container übernommen und somit in Ihrem Browser angezeigt, wenn Sie die Seite neu laden.

Im nächsten Schritt sehen Sie, wie Ihre containerisierte Umgebung mit den Docker Compose-Befehlen verwaltet wird.

Schritt 4 — Kennenlernen der Befehle von Docker Compose

Sie haben gesehen, wie Sie eine docker-compose.yml-Datei einrichten und Ihre Umgebung mit docker-compose aufrufen. Nun sehen Sie, wie Sie die Docker Compose-Befehle verwenden, um Ihre containerisierte Umgebung zu verwalten und mit ihr zu interagieren.

Um die von Ihrem Nginx-Container erzeugten Protokolle zu überprüfen, können Sie den Befehl logs verwenden:

docker-compose logs

Sie sehen eine Ausgabe, die dieser ähnelt:

Output
Attaching to compose-demo_web_1
web_1  | /docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration
web_1  | /docker-entrypoint.sh: Looking for shell scripts in /docker-entrypoint.d/
web_1  | /docker-entrypoint.sh: Launching /docker-entrypoint.d/10-listen-on-ipv6-by-default.sh
web_1  | 10-listen-on-ipv6-by-default.sh: Getting the checksum of /etc/nginx/conf.d/default.conf
web_1  | 10-listen-on-ipv6-by-default.sh: Enabled listen on IPv6 in /etc/nginx/conf.d/default.conf
web_1  | /docker-entrypoint.sh: Launching /docker-entrypoint.d/20-envsubst-on-templates.sh
web_1  | /docker-entrypoint.sh: Configuration complete; ready for start up
web_1  | 172.22.0.1 - - [02/Jun/2020:10:47:13 +0000] "GET / HTTP/1.1" 200 353 "-" "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4103.61 Safari/537.36" "-"

Wenn Sie die Ausführung der Umgebung unterbrechen möchten, ohne den aktuellen Zustand Ihrer Container zu ändern, können Sie Folgendes verwenden:

docker-compose pause

Output
Pausing compose-demo_web_1 ... done

Um die Ausführung nach einer Unterbrechung fortzusetzen:

docker-compose unpause

Output
Unpausing compose-demo_web_1 ... done

Der Befehl stop beendet die Ausführung des Containers, zerstört jedoch keine Daten, die mit Ihren Containern verknüpft sind:

docker-compose stop

Output
Stopping compose-demo_web_1 ... done

Wenn Sie die mit dieser containerisierten Umgebung verknüpften Container, Netzwerke und Volumen entfernen möchten, verwenden Sie den Befehl down:

docker-compose down

Output
Removing compose-demo_web_1 ... done
Removing network compose-demo_default

Beachten Sie, dass dadurch nicht das Basis-Image entfernt wird, das von Docker Compose zum Hochfahren Ihrer Umgebung verwendet wird (in unserem Fall nginx:alpine). Auf diese Weise wird der Prozess jedes Mal, wenn Sie Ihre Umgebung mit einem docker-compose up wieder hochfahren, viel schneller sein, da sich das Image bereits auf Ihrem System befindet.

Falls Sie auch das Basis-Image von Ihrem System entfernen möchten, können Sie Folgendes verwenden:

docker image rm nginx:alpine

OutputUntagged: nginx:alpine
Untagged: nginx@sha256:b89a6ccbda39576ad23fd079978c967cecc6b170db6e7ff8a769bf2259a71912
Deleted: sha256:7d0cdcc60a96a5124763fddf5d534d058ad7d0d8d4c3b8be2aefedf4267d0270
Deleted: sha256:05a0eaca15d731e0029a7604ef54f0dda3b736d4e987e6ac87b91ac7aac03ab1
Deleted: sha256:c6bbc4bdac396583641cb44cd35126b2c195be8fe1ac5e6c577c14752bbe9157
Deleted: sha256:35789b1e1a362b0da8392ca7d5759ef08b9a6b7141cc1521570f984dc7905eb6
Deleted: sha256:a3efaa65ec344c882fe5d543a392a54c4ceacd1efd91662d06964211b1be4c08
Deleted: sha256:3e207b409db364b595ba862cdc12be96dcdad8e36c59a03b7b3b61c946a5741a

Anmerkung: Eine ausführliche Referenz zu den Docker-Befehlen finden Sie in unserem Leitfaden zum Installieren und Verwenden von Docker.

Zusammenfassung

In diesem Leitfaden haben wir gesehen, wie wir Docker Compose installieren und eine containerisierte Umgebung basierend auf einem Nginx Webserver-Image einrichten. Wir haben auch gesehen, wie diese Umgebung mit den Compose-Befehlen verwaltet wird.

Eine vollständige Referenz aller verfügbaren docker-compose Befehle finden Sie in der offiziellen Dokumentation.

Thanks for learning with the DigitalOcean Community. Check out our offerings for compute, storage, networking, and managed databases.

Learn more about us

About the authors