Docker/Compose: Unterschied zwischen den Versionen

Aus Foxwiki
Wechseln zu:Navigation, Suche
Keine Bearbeitungszusammenfassung
 
(3 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 211: Zeile 211:
=== Siehe auch ===
=== Siehe auch ===
<div style="column-count:2">
<div style="column-count:2">
<categorytree hideroot=on mode="pages">Docker</categorytree>
<categorytree hideroot=on mode="pages">Docker/Compose</categorytree>
</div>
</div>
----
----
Zeile 230: Zeile 230:
# [https://docs.docker.com/reference/compose-file/ Compose-Dateireferenz]
# [https://docs.docker.com/reference/compose-file/ Compose-Dateireferenz]
# [https://docs.docker.com/reference/cli/docker/compose/ Compose CLI-Referenz]
# [https://docs.docker.com/reference/cli/docker/compose/ Compose CLI-Referenz]
 
[[Kategorie:Docker/Compose]]
[[Kategorie:Docker/Container]]
[[Kategorie:Docker/Container]]
</noinclude>
= TMP =
<noinclude>
<!--
----
{{Navigation|<zurück>|<nachste>}}
{{Navigation|BSI/200-3|BSI/200-3/Einleitung/Beispiele}}
----
-->
'''{{BASEPAGENAME}}'''
</noinclude>
== Beschreibung ==
Container-Setups mit »compose«
Das Einrichten von Docker-Containern mit docker run ist zwar unkompliziert, aber
wenn Sie immer wieder die gleiche Art von Containern benötigen, gibt es einen
noch komfortableren Weg: Das Kommando docker compose wertet die Textdatei
compose.yaml (ehemals docker-compose.yml) im aktuellen Verzeichnis aus und richtet
dann die entsprechenden Container ein. Das ist besonders praktisch, wenn Sie meh-
rere Container in einem Setup kombinieren möchten.
Damit Sie docker compose bzw. das damit verwandte Kommando podman-compose ver-
wenden können, müssen Sie lediglich die Syntax von compose.yaml erlernen. Auf
ebendiese Syntax konzentrieren wir uns in diesem Kapitel. Unzählige Anwendungs-
beispiele folgen dann in nahezu allen weiteren Kapiteln dieses Buchs. (Sie merken
schon, wir sind große Fans von docker compose!)
»docker compose« versus »docker-compose«
In der Vergangenheit war docker-compose ein von docker unabhängiges Kommando.
Bei aktuellen Versionen ist compose dagegen als Subkommando von docker imple-
mentiert und ist somit ohne Bindestrich aufzurufen.
»docker compose« versus »docker stack«
Als wäre die Differenzierung zwischen docker compose und docker-compose noch nicht
genug, eröffnet docker stack einen weiteren Weg, ein in compose.yaml formuliertes
Setup zum Leben zu erwecken:
Der traditionelle Weg besteht darin, mit dem Kommando docker compose die Con-
tainer einzurichten und zu starten.
Alternativ können Sie mit docker stack deploy äquivalente Services erzeugen und
ausführen. So wie docker compose es Ihnen erspart, docker run oder docker exec
mehrfach mit unzähligen Parametern auszuführen, ersetzt docker stack deploy
diverse Kommandos der Art docker service ...
5 Container-Setups mit »compose«
Auch wenn das Endergebnis letztlich sehr ähnlich ist (Sie können das in der Datei
beschriebene Setup nutzen), sind die Unterschiede hinter den Kulissen doch erheb-
lich: docker compose arbeitet direkt mit Containern.
docker stack deploy richtet dagegen eine Gruppe (einen Stack) von Services ein. Ser-
vices wurden konzipiert, um Docker-Dienste verteil- und skalierbar zu machen. Sie
müssen aber durchaus keinen Docker-Cluster einrichten (bzw. einen Schwarm, um
bei der offiziellen Nomenklatur zu bleiben), damit Sie docker stack deploy verwen-
den können. Es reicht aus, einmal docker swarm init auszuführen: Damit wird Ihre
Docker-Instanz zu einem Mini-Schwarm, der eben aus nur einem Mitglied besteht.
Die Einstiegshürde für docker stack deploy ist also nicht groß. Dennoch muss Ihnen
klar sein, dass die Verwendung von Services eine zusätzliche Abstraktionsebene
ins Spiel bringt. Für Docker-Einsteiger macht das die Anwendung unübersichtlicher,
ohne unmittelbare Vorteile mit sich zu bringen. Insofern ist es gerade für Einsteiger
ratsam, docker compose vorerst den Vorzug zu geben.
Fortgeschrittene Docker-Anwender betrachten Services dagegen als die besseren
Container. »Docker service is the new docker run«, hieß es einmal auf einem Docker-
Vortrag. docker stack deploy ist dann die vielseitigere Alternative zu docker compose .
Auf die Möglichkeiten, Docker-Anwendungen über mehrere Computer bzw. in der
Cloud zu verteilen, gehen wir in Kapitel 19, »Swarm«, sowie in Kapitel 20, »Kuberne-
tes«, ein.
podman-compose
Während compose heute ein integrales Subkommando von docker ist, war es in der
Vergangenheit ein von docker losgelöstes Script. Und genau das ist auch bei Podman
(noch) der Fall: Das mit docker compose weitgehend kompatible Tool podman-compose
ist in Wirklichkeit ein Python-Script, das extra installiert werden muss (siehe auch
Abschnitt 2.7, »Podman installieren«). Falls Sie mit Podman arbeiten, sollten Sie sich
davon überzeugen, dass dieser Installationsschritt klappt.
podman - compose version
podman - compose version : 1.0.6
Von docker-compose.yml zu compose.yaml
In der Vergangenheit wurde das Container-Setup in der Datei docker-compose.yml
beschrieben. Mittlerweile hat sich der Dateiname compose.yaml etabliert. Der alte
Dateiname wird zwar weiterhin unterstützt (auch von podman-compose), wir haben die
Beispiele für dieses Buch aber auf compose.yaml umgestellt.
5.1 YAML-Syntax
Bevor Sie docker compose oder docker stack deploy ausführen können, müssen Sie
eine Datei mit dem Namen compose.yml erstellen. Die Kennung *.yml bezeichnet das
YAML-Format (YAML Ain’t Markup Language). Die Syntaxregeln von YAML haben wir
Ihnen hier kurz zusammengefasst:
--- leitet einen neuen Abschnitt ein.
# startet einen Kommentar, der bis zum Ende der Zeile reicht.
Zeichenketten können in der Form "abc" oder 'abc' ausgedrückt werden. Dies ist
aber nur in Ausnahmefällen zwingend erforderlich – beispielsweise dann, wenn
die Zeichenkette Sonderzeichen enthält oder als ein anderer YAML-Ausdruck inter-
pretiert werden kann.
Mehrere mit - eingeleitete Ausdrücke bilden eine Liste:
- rot
- gr ü n
- blau
Alternativ können Listen auch in eckige Klammern gestellt werden:
[ rot , gr ü n , blau ]
Assoziative Listen (Key-Value-Paare) werden in der Form key: value gebildet:
name : Hermann Huber
age : 37
Auch hier gibt es eine platzsparende Variante, diesmal in geschwungenen Klam-
mern:
{ name : Hermann Huber , age : 37}
| leitet einen Textblock ein, in dem die Zeilenumbrüche erhalten bleiben:
codeblock : |
Zeile 1
Zeile 2
> leitet einen Textblock ein, in dem Zeilenumbrüche ignoriert werden. Leere Zeilen
bleiben aber erhalten:
textblock : >
Zusammeng e h örender
Text .
Hier beginnt der
zweite Absatz .
115
5 Container-Setups mit »compose«
Alle vorgestellten Elemente können ineinander verschachtelt werden. Die Struktur
wird durch Einrückungen hergestellt. Dabei müssen Leerzeichen verwendet werden
(keine Tabulatoren!). Beim Zugriff auf die Elemente werden die Bezeichner (Keys)
aneinandergereiht.
# Datei sample . yaml
data :
list :
- item1
- item2
key1 : >
Dieser Text ist dem
Schl ü ssel 'data . key1 ' zugeordn e t .
key2 : |
code line 1
code line 2
Einige fortgeschrittene Syntaxelemente von YAML, die jedoch in compose.yaml-
Dateien normalerweise keine Rolle spielen, sind in der Wikipedia dokumentiert:
https://en.wikipedia.org/wiki/YAML
Zum Auslesen von YAML-Dateien können Sie das Python-Script shyaml verwenden.
Unter Ubuntu installieren Sie das Kommando wie folgt:
sudo apt install python - pip
sudo pip install shyaml
shyaml get - value data . list < sample . yaml
- item1
- item2
Beim Experimentieren mit YAML-Dateien sind auch die YAML-Validatoren bzw.
-Parser auf den folgenden Websites hilfreich:
http://www.yamllint.com
https://yaml-online-parser.appspot.com
https://codebeautify.org/yaml-validator
5.2 Hello Compose!
Das folgende Einführungsbeispiel für die Syntax von compose.yaml beschreibt ein
Docker-Setup, das aus zwei Services besteht: zum einen aus einem Datenbankserver
(MariaDB in der gerade aktuellen Version), zum anderen aus dem CMS WordPress.
Ein Großteil der Einstellungen für die beiden Services sollte ohne Weiteres verständ-
lich sein:
Zur Speicherung der Datenbankdateien bzw. der HTML-Dateien werden jeweils
benannte Volumes verwendet. (Die Namen der Volumes müssen zweimal ange-
geben werden, einmal bei der Beschreibung der jeweiligen Services und ein zwei-
tes Mal – üblicherweise am Ende der Datei compose.yaml – in einem separaten
Abschnitt volumes.)
In MariaDB sollen die Datenbank wp und der dazugehörende Benutzer wpuser mit
dem Passwort geheim eingerichtet werden. Als root-Passwort kann eine zufällige
Zeichenkette verwendet werden – es ist für das Setup nicht relevant.
Damit WordPress auf die Datenbank zugreifen kann, müssen die entsprechenden
WORDPRESS -Variablen initialisiert werden. DB_HOST verweist auf den Servicenamen db
und die Defaultportnummer des MariaDB-Servers.
Der für WordPress zuständige Webserver nutzt im Container Port 80. Dieser Port
soll mit Port 8082 des Host-Rechners verbunden werden.
# Datei compose . yaml
services :
db :
image : mariadb : latest
volumes :
- vol - db :/ var / lib /mysql
environm en t :
MYSQL_RAN D O M_ R O O T _P A S S W OR D :  1
MYSQL_DAT A B AS E :                        wp
MYSQL_USE R :                                wpuser
MYSQL_PAS S W OR D :                        geheim
restart : always
wordpres s :
image : wordpress : latest
volumes :
- vol - www :/ var / www / html /wp - content
ports :
- "8082:80 "
environm en t :
WORDPRESS _ D B_ H O S T :        db :3306
WORDPRESS _ D B_ U S E R :        wpuser
WORDPRESS _ D B_ N A M E :        wp
WORDPRESS _ D B_ P A S S WO R D : geheim
restart : always
volumes :
vol - www :
vol - db :
5 Container-Setups mit »compose«
docker compose
Um docker compose auszuprobieren, wechseln Sie zuerst in das Verzeichnis mit der
Datei compose.yaml – hier wordpress-beispiel . Beachten Sie, dass der Verzeichnisname
zur Benennung der Container, Volumes, Netzwerke usw. verwendet wird.
docker compose up -d sucht im aktuellen Verzeichnis nach der Datei compose.yaml,
lädt die erforderlichen Images herunter (natürlich nur, wenn diese noch nicht zur
Verfügung stehen), erzeugt die Container, verbindet diese in einem eigens dafür
erzeugten Netzwerk und startet sie als Hintergrundprozesse (Option -d). Der gesamte
Vorgang dauert nur wenige Sekunden (plus gegebenenfalls die Zeit zum Download
der Images). Beachten Sie, dass die Container wegen restart: always auch nach
einem Reboot des Rechners automatisch neu gestartet werden.
cd wordpress - beispiel      ( Verzeichn i s mit compose . yaml )
docker compose up -d
Creating network wordpress - beispiel_ d e f a ul t " with the default
driver
Creating wordpress - beispiel _ wo r d p r es s _ 1 ... done
Creating wordpress - beispiel _ db _ 1              ... done
Das Kommando docker ps zeigt die beiden laufenden Container. (Die Ausgabe ist aus
Platzgründen stark gekürzt.) Nach wenigen Sekunden, die für die Initialisierung des
Containers erforderlich sind, können Sie WordPress unter der Adresse localhost:8082
nutzen.
docker ps
ID          PORTS                          NAMES
5211...    0.0.0.0:8082 - >80/tcp        wordpress -beispiel _ w o rd p r e s s_ 1
d9dc ...    3306/ tcp                      wordpress -beispiel _ d b _1
Um die Ausführung aller zusammengehörenden Container zu stoppen, führen Sie
docker compose stop aus. Analog setzt docker compose start die Ausführung fort.
Diese Kommandos setzen jeweils voraus, dass sich compose.yaml im aktuellen Ver-
zeichnis befindet.
Mit docker compose down stoppen und löschen Sie alle Container der Setups. Die Vol-
umes bleiben erhalten. Bei Bedarf können Sie die Container unter Beibehaltung der
bisherigen Daten mit docker compose up wieder neu einrichten:
docker compose down                ( Containe r stoppen und l ö schen )
...
docker compose up -d                ( Containe r neu einrichte n )
Wenn Sie die Container und die dazugehörenden Volumes löschen möchten, führen
Sie für das vorliegende Beispiel die folgenden Kommandos aus:
docker compose down
docker volume rm wordpress - beispiel_vol - db \
wordpress - beispiel_vol - www
podman-compose
Das Beispiel funktioniert unverändert auch mit Podman, wenn Sie docker compose
durch das Kommando podman-compose ersetzen. Es gibt aber einen kleinen Unter-
schied: Unter Docker bewirken die beiden Zeilen restart: always einen automati-
schen Neustart der Container nach einem Reboot des Rechners. Bei Podman gibt es
keinen Hintergrunddienst, der sich darum kümmern kann. Dementsprechend müs-
sen Sie das Container-Setup bei Bedarf selbst wieder neu starten.
docker stack deploy
Statt mit docker compose können Sie die Datei compose.yaml auch mit dem Kommando
docker stack deploy verarbeiten. docker stack setzt voraus, dass der Computer Mit-
glied eines Docker-Schwarms ist. Sie müssen aber durchaus keinen Docker-Cluster
bilden, um docker stack verwenden zu können. Es reicht vollkommen aus, wenn Sie
auf Ihrem Rechner einmalig docker swarm init ausführen. Damit bildet Ihr Compu-
ter einen Docker-Schwarm, der allerdings nur aus einem einzigen Mitglied besteht.
(Wie Sie »richtige« Docker-Cluster nutzen, die aus mehreren Computern zusammen-
gesetzt sind, zeigen wir Ihnen in Kapitel 19, »Swarm«.)
docker swarm init
Swarm initiali z e d : current node ( eqbx ...) is now a manager .
To add a worker to this swarm , run the following command :
docker swarm join --token SWMTKN -xxx 10.0.0.1: 2 3 7 7
To add a manager to this swarm , run
'docker swarm join - token manager ' and follow the instruct i on s .
Um die in compose.yaml beschriebenen Container samt einem Netzwerk einzurich-
ten, übergeben Sie an docker stack deploy mit der Option -c den Dateinamen der
Compose-Datei und als weiteren Parameter den Namen des Setups bzw. des Stacks.
Dieser Name wird den Netzwerk-, Volume- und Servicenamen vorangestellt. (docker
compose verwendet anstelle dieses Namens standardmäßig den Namen des Verzeich-
nisses, in dem sich compose.yaml befindet.)
docker stack deploy -c compose .yaml stacktest
Ignoring unsupport e d options : restart
Creating network stacktes t _ d ef a u l t
Creating service stacktes t _ w or d p r e ss
Creating service stacktes t _ d b
5 Container-Setups mit »compose«
docker stack ls beweist, dass der neue Stack eingerichtet wurde und aus zwei Ser-
vices besteht:
docker stack ls
NAME        SERVICES            ORCHESTR A T O R
stacktes t  2                  Swarm
Mit docker service ls können Sie sich nun davon überzeugen, dass die Services tat-
sächlich erzeugt und ausgeführt werden. Die Ausgabe wurde wie üblich um einige
Spalten gekürzt:
docker service ls
ID              NAME                              REPLICAS  PORTS        ...
skz4ab9p 7 1 v a stacktest _ d b                    1/1
ghdrn0z2 g i 5 n stacktest _ w o r dp r e s s      1/1        * :8082 - >80/ tcp
Entscheidend ist die REPLICAS -Spalte. Steht hier 0/1, ist beim Start ein Fehler auf-
getreten. Aufschluss über die Fehlerursache kann die ERROR-Spalte der Ausgabe von
docker service ps <sid/stackname> geben, wobei Sie die Service-ID oder den Namen
des Stacks als Parameter übergeben. Das Kommando gibt an, welche Tasks in einem
Service ausgeführt werden. Die ERROR-Spalte ist normalerweise so stark verkürzt, dass
sie nicht aufschlussreich ist. Abhilfe schafft dann die Option --no-trunc:
docker service ps sometest --no - trunc
... NAME              ... ERROR
stacktest _ d b .1    starting container failed : Invalid
address 10.0.1.14 : It does not belong
to any of this network ' s subnets
Mit docker ps können Sie sich davon überzeugen, dass für jeden Service ein entspre-
chender Container erstellt und gestartet wurde.
Anders als bei Containern gibt es bei Stacks keine Möglichkeit, sie zu stoppen und
später wieder zu starten. Sie können den gesamten Stack mit all seinen Services und
Netzwerken aber mit docker stack rm löschen:
docker stack rm stacktes t
Removing service stacktes t _ d b
Removing service stacktes t _ w or d p r e ss
Removing network stacktes t _ d ef a u l t
Die in compose.yaml angegebenen Volumes bleiben dabei erhalten. Daher ist es mög-
lich, den Stack später ohne Verlust von Daten wieder einzurichten und neuerlich
auszuführen:
docker stack deploy -c compose .yaml stacktest
Wenn Sie das Setup nicht mehr benötigen, löschen Sie sowohl den Stack als auch die
zugeordneten Volumes:
docker stack rm stacktes t
docker volume rm stacktest_vol -db stacktest_vol - www
Podman
Unter Podman fehlen Kommandos, die mit docker swarm und docker stack kompati-
bel sind. Dafür gibt es mit podman pod eine andere Möglichkeit, Container-Gruppen zu
erzeugen. In diesem Buch gehen wir auf podman pod gar nicht und auf docker stack
nur noch am Rande ein. (Dafür beschäftigen wir uns ausführlich mit Docker Swarm,
siehe Kapitel 19.) Unser Fokus bleibt stattdessen auf dem Compose-Feature, das in
beiden Systemen zur Verfügung steht und in der Praxis von größter Bedeutung ist.
Debugging
Im Idealfall geht beim Start der Container durch docker compose up alles gut. Was aber,
wenn Fehler auftreten?
Ein erstes Hilfsmittel zur Fehlersuche besteht darin, docker compose up ohne die
Option -d auszuführen. Damit erfolgen sämtliche Logging-Ausgaben aller Container
direkt in der Konsole. Sie können also zu einem gewissen Grad mitverfolgen, was in
den Containern vor sich geht.
Alternativ können Sie mit docker ps einen Blick in die Container-Liste werfen. Dort
erkennen Sie in der Regel sofort, ob es Container gibt, die nicht wie geplant laufen
oder die ständig neu gestartet werden. Mit docker logs <cname> können Sie dann
die Logging-Ausgaben der betroffenen Container lesen. docker compose logs zeigt das
kombinierte Logging aller Container der Gruppe.
Wie üblich können Sie mit docker exec einen zusätzlichen interaktiven Shell-Prozess
starten und so in einen laufenden Container »hineinsehen«:
docker exec -it test_wor dp r e s s _1 / bin / sh
ps -ax
PID TTY                STAT        TIME COMMAND
1 ?                  Ss          0:00 apache2 -DFOREGRO U N D
66 ?                  S            0:00 apache2 -DFOREGRO U N D
...
78 pts /0            Ss          0:00 / bin / sh
83 pts /0            R+          0:00 ps -ax
5 Container-Setups mit »compose«
Interaktive Nutzung
Es ist keine gute Idee, in compose.yaml ein Image anzugeben, in dem kein Prozess dau-
erhaft läuft:
# Datei compose . yaml
# Containe r / Service endet sofort , weil es
# keinen Hintergr u nd p r o z es s gibt
services :
myservic e 1 :
image : alpine
Führen Sie nun docker compose up aus, wird der betreffende Container zwar einge-
richtet und gestartet, aber die Ausführung endet sofort wieder. Analog sieht es aus,
wenn Sie docker stack deploy ausführen: Der Service wird eingerichtet und gestartet,
aber mangels Hintergrundprozess endet die Ausführung sofort wieder. Die Schwarm-
logik von Docker versucht nun immer wieder, den Service zu starten – aber das hilft
natürlich auch nicht. Die REPLICAS -Spalte von docker service ls zeigt 0/1, und docker
service ps listet diverse Startversuche auf, zeigt aber keine Fehlermeldungen:
docker stack deploy -c compose .yaml test4
docker service ls
ID              NAME                              REPLICAS  IMAGE
1 t8cfulkp x o z test4_mys e r v i ce 1            0/1        alpine :latest
docker service ps 1t8cfulkp x o z
ID              ... DESIRED STATE              CURRENT STATE              ERROR
kolqn5wn z g p 2    Ready                      Ready 4 seconds ago
yrzb2d0g 4 a r c    Shutdown                  Complete 10 seconds ago
y3ojrkgf v 6 s w    Shutdown                  Complete a minute ago
y54o8unh q f 8 s    Shutdown                  Complete a minute ago
xayg2nje h i y j    Shutdown                  Complete 2 minutes ago
Es wird wohl eher ein Ausnahmefall sein, aber es ist möglich, mit docker compose
einen Container für die interaktive Nutzung zu erzeugen. Dazu führen Sie mit docker
compose das Kommando run <servicename> anstelle von up aus. Die zusätzliche Option
--rm bewirkt, dass der Container nach dem Verlassen der Shell gelöscht wird.
docker compose run --rm myservice 1
cat / etc / os -release
NAME =" Alpine Linux "
PRETTY_N A ME =" Alpine Linux v3 .13"
...
exit
Eine vergleichbare interaktive Nutzungsvariante für docker stack deploy gibt es
nicht. docker stack setzt auf dem Konzept von Services auf. Der interaktive Betrieb
eines Service wäre aber unsinnig.
5.3 Die Datei compose.yaml
In diesem Abschnitt fassen wir die wichtigsten Schlüsselwörter zusammen, die in der
Datei compose.yaml vorkommen. Eine vollständige Referenz finden Sie hier:
https://docs.docker.com/compose/compose-file
Wir beziehen uns in diesem Buch grundsätzlich auf Compose Version 2 gemäß der
aktuell geltenden Spezifikation:
https://github.com/compose-spec/compose-spec/blob/master/spec.md
compose.yaml beginnt in der Regel mit dem Bezeichner services , auf den eingerückt
frei wählbare Namen mehrerer Dienste folgen. Die Eigenschaften jedes Dienstes wer-
den, nochmals eingerückt, durch diverse Schlüsselwörter festgelegt:
# Grunds ä tzlicher Aufbau von compose .yaml
services :
dienstna m e 1 :
schl ü sselwort 1 : einstell u n g1
schl ü sselwort 2 : einstell u n g2
...
dienstna m e 2 :
schl ü sselwort 1 : einstell u n g1
schl ü sselwort 2 : einstell u n g2
...
In manchen Fällen folgen dem Top-Level-Abschnitt services weitere Top-Level-
Abschnitte, z. B. volumes, networks oder secrets. Diese sind in der Regel mit gleichna-
migen Schlüsselwörtern innerhalb eines Service verbunden. Entsprechende Beispiele
folgen in den weiteren Abschnitten.
Image oder Dockerfile?
Das Schlüsselwort image gibt an, welches Basis-Image verwendet werden soll. Dabei
sind Image-Namen in allen Varianten (registryname/reponame/imagename:tag) sowie
Image-IDs erlaubt.
image : ubuntu :22.04
5 Container-Setups mit »compose«
Sofern Sie nicht docker stack deploy verwenden, können Sie anstelle eines Images
auch den Pfad zu einem Verzeichnis angeben, in dem sich die Datei Dockerfile be-
findet:
build : verzeichn i s
docker compose berücksichtigt dann die Angaben in dieser Datei, erzeugt ein entspre-
chendes Image und verwendet dieses als Basis. Wenn Sie das Dockerfile im gleichen
Verzeichnis wie compose.yaml gespeichert haben, geben Sie anstelle des Pfads einfach
einen Punkt an.
Netzwerke
docker compose bzw. docker stack deploy richtet für die auszuführenden Container
bzw. Services automatisch ein eigenes Netzwerk ein. Wenn Sie darüber hinaus zusätz-
liche Netzwerke einrichten und in Ihren Diensten nutzen möchten, müssen Sie mit
dem Top-Level-Schlüsselwort networks eigene Netzwerke definieren und im services -
Abschnitt mit einem weiteren networks -Schlüsselwort darauf verweisen.
Im folgenden Beispiel kann der Dienst web mit dem Netzwerk myownnet kommunizie-
ren. Dabei handelt es sich um das in Docker immer verfügbare Host-Netzwerk (siehe
docker network ls).
services :
web :
...
networks :
- myownnet
# Top - Level - Abschnitt zur Definiti o n zus ä tzlicher Netzwerk e
networks :
myownnet :
external :
name : host
Netzwerkports
Dem Schlüsselwort ports folgt eine Liste von Port-Zuordnungen in der Syntax
portnummer (den Port einfach weiterleiten) oder lokal:dienst (einen Port des Dienstes
auf einen anderen Port des lokalen Computers umleiten). Die folgende Einstellung
macht die Ports 80 und 443 des Docker-Containers bzw. -Service auf den Ports 8080
und 8443 des Docker-Hosts zugänglich:
ports :
- "8080:80 "
- "8443:44 3 "
Wenn Sie einen Port nur innerhalb desjenigen Netzwerks freigeben möchten, das
docker compose bzw. docker stack deploy für die Container bzw. Services des Projekts
einrichtet, geben Sie diese Ports mit expose an:
expose :
- "7500"
- "7501"
Volumes
Dem Schlüsselwort volumes folgt ebenfalls eine Liste, in der Sie angeben, an welchen
lokalen Orten im Docker-Host die Volume-Verzeichnisse des Images abgelegt werden
sollen. Der folgende Eintrag bewirkt, dass das Volume /var/lib/mysql des Images auf
dem Docker-Host im Verzeichnis /data/db gespeichert werden soll. Dieses Verzeich-
nis muss bereits existieren, wenn docker compose ausgeführt wird.
volumes :
- / data / db :/ var / lib / mysql
Der Pfad für das lokale Volume-Verzeichnis darf in der Form ./<name> auch relativ
zum Ort der Datei compose.yaml angegeben werden. Unter Fedora und RHEL müssen
Sie für Volumes, die nicht innerhalb des Standardverzeichnisses für Docker bzw. Pod-
man gespeichert werden (also z. B. nicht in /var/lib/docker ), das zusätzliche Flag :z
angeben.
Volumes im Heimatverzeichnis
Der lokale Volume-Pfad (also der Teil vor dem Doppelpunkt) wird relativ zur Datei
compose.yaml ausgewertet. Wenn Sie einen Pfad relativ zum Heimatverzeichnis des
aktiven Benutzers wünschen, leiten Sie den Pfad mit ~ ein.
docker compose interpretiert die bloße Angabe von <name> nicht als relativen Pfad,
sondern als Namen für ein benanntes Volume! docker compose erwartet in diesem
Fall einen zusätzlichen Top-Level-Abschnitt volumes , in dem die Details des Volumes
<name> definiert sind. Ein entsprechendes Beispiel folgt im nächsten Abschnitt.
Beachten Sie, dass auch einzelne Dateien als Volumes betrachtet werden. In diesem
Fall muss die betreffende lokale Datei bereits existieren. Achten Sie aber darauf, dass
Sie nicht Verzeichnisse und Dateien vermischen. Sie können also nicht eine lokale
Datei einem Image-Verzeichnis zuordnen oder ein lokales Verzeichnis einer Image-
Datei.
volumes :
- ./ default .conf :/ etc / nginx / conf . d /default . conf
5 Container-Setups mit »compose«
UID und GID in lokalen Volumes (Docker Engine unter Linux)
Wenn Sie ein lokales Verzeichnis in Ihrem Heimatverzeichnis zur Speicherung von
Volumes verwenden, werden neue, vom Container erzeugte Dateien nicht Ihrem
eigenen Benutzer bzw. Ihrer Gruppe zugeordnet. Außerhalb des Docker-Containers
können Sie diese Dateien nicht verändern und möglicherweise nicht einmal lesen
(z. B. bei einem Backup).
Das hier beschriebene Problem tritt nur auf, wenn Sie unter Linux mit einer Stan-
dardinstallation der Docker Engine arbeiten. Es tritt nicht auf, wenn Sie mit Rootless
Docker oder mit Podman arbeiten.
Am einfachsten ist das Problem anhand eines konkreten Beispiels zu verstehen:
Die folgende Datei compose.yaml beschreibt einen Alpine-Container, der das gerade
aktuelle Verzeichnis mit dem /home-Verzeichnis des Containers verbindet. In diesem
Verzeichnis wird die neue Datei newfile erzeugt.
# Datei compose . yaml
services :
secrette s t :
image : alpine
volumes :
- ./:/ home : z
command : [" touch " , "/ home / newfile "]
Wenn Sie das Setup unter Linux ausführen, gehört die neue Datei nicht Ihnen, son-
dern dem Benutzer root. Das liegt daran, dass der Docker-Dämon mit root-Rechten
läuft.
docker compose up
ls -l newfile
-rw - r - -r - - 1 root      root          0 17. Jun 09:46 newfile
Wenn Sie dagegen mit Rootless Docker oder mit Podman arbeiten, gehört die Datei
Ihnen:
podman - compose up
ls -l newfile
-rw - r - -r - -. 1 kofler kofler            0 17. Jun 09:50 newfile
Wenn Sie im Zusammenspiel mit Docker und Linux vermeiden möchten, dass neue
Dateien root gehören, können Sie compose.yaml um das Schlüsselwort user erweitern
und dort eine UID (User Identification Number) oder GID (Group Identification Num-
ber) angeben. user legt fest, in welchem Account der Container-Prozess ausgeführt
wird. Der Account kann auch durch das Schlüsselwort USER im zugrundeliegenden
Dockerfile festgelegt werden.
# Datei compose . yaml
services :
secrette s t :
image : alpine
volumes :
- ./:/ home : z
command : [" touch " , "/ home / newfile "]
user : "1000:10 00 "
Das obige Listing setzt voraus, dass Ihre UID und GID jeweils 1000 ist. Das trifft für
den ersten angelegten Benutzer zu. Allgemeingültiger ist die folgende Variante, die
aber voraussetzt, dass Sie die Variable UID_GID vor dem Aufruf von docker compose
initialisieren:
# in compose . yaml
...
user : $ { UID_GID }
Sie müssen nun docker compose wie folgt aufrufen:
UID_GID =" $ ( id -u ) : $( id -g) " docker compose up
Leider ist die Vorgehensweise mit user inkompatibel mit podman-compose. Das Script
verarbeitet das Schlüsselwort user zwar prinzipiell korrekt, allerdings tritt nun bei der
Ausführung des Containers der Fehler permission denied auf.
Benannte Volumes
Zur Definition benannter Volumes stellen Sie dem Volume-Verzeichnis einfach den
gewünschten Namen (im folgenden Beispiel webdata) voran. Allerdings müssen Sie
das Volume ein zweites Mail in der Top-Level-Ebene volumes angeben. Dort können
Sie gegebenenfalls besondere Eigenschaften des Volumes festlegen:
# Datei compose . yaml im Verzeichn i s test2
services :
nginx :
volumes :
- webdata :/ var / www /html /
...
volumes :
webdata :
5 Container-Setups mit »compose«
Docker kümmert sich darum, das Volume einzurichten. Der Volume-Name setzt sich
aus dem aktuellen Verzeichnisnamen, dem in der Datei compose.yaml angegebenen
Namen sowie data_ zusammen. Sofern Sie Docker mit root-Rechten ausführen und
das aktuelle Verzeichnis test2 lautet, ergibt sich der folgende Pfad:
/ var / lib / docker / volumes / test2_web d a t a / _data
Volumes für Services
In einem Docker-Schwarm entscheidet der Schwarm-Manager, auf welchem Knoten
ein Service ausgeführt wird. Der Ort kann sich also jederzeit ändern. Bei der Ver-
wendung von Volumes führt das zu Problemen: Ein beim ersten Ablauf auf Knoten
A eingerichtetes Volume existiert ja nicht auf Knoten B, wo der Service vielleicht
beim nächsten Mal läuft.
Um dieses Problem zu umgehen, können Sie in den Deploy-Einstellungen mit deploy.
placement.constraints Regeln festlegen, auf welchem Knoten der Service laufen
soll.
Umgebungsvariablen
Dem Schlüsselwort environment folgen wahlweise Key-Value-Paare oder Listenele-
mente in der Form var=wert. Die so definierten Umgebungsvariablen gelten bei der
Ausführung des Kommandos im Container. Die beiden folgenden Listings sind gleich-
wertig:
environme n t :
WORDPRES S _ D B_ H O S T : mariadb
WORDPRES S _ D B_ N A M E : dockerbu c h
environme n t :
- WORDPRES S _D B _ H OS T = mariadb
- WORDPRES S _D B _ N AM E = dockerbu ch
Wenn Sie viele Umgebungsvariablen setzen müssen, können Sie die Einstellungen
mit env_file: dateiname auch aus einer Datei lesen.
Kommandoausführung
Normalerweise wird in Containern bzw. Services das Kommando ausgeführt, das im
Image durch ENTRYPOINT und/oder CMD vorgegeben ist (siehe auch den Abschnitt »Con-
tainer-Startkommando« in Abschnitt 4.2, »Dockerfile-Syntax«). Bei einem Apache-
Image wird das ein Startkommando für den Webserver sein, bei einem MySQL-Image
der Dienst des MySQL-Servers etc.
Wenn davon abweichend ein anderes Kommando ausgeführt werden soll, geben Sie
dieses mit den Schlüsselwörtern entrypoint und/oder command an. Beachten Sie, dass
Sie Kommandos, die aus mehreren Teilen zusammengesetzt sind, entweder als Liste
oder in der Form ["teil1", "teil2", "teil3"] übergeben müssen.
entrypoin t : [" some -script . sh "]
command :    ["/ bin /bash "]
# mehrteil i g e s Kommando
command : [" php " , " -a "]
# gleichwe r t i g
command :
- " php "
- " -a "
Restart-Verhalten (Docker-spezifisch)
Bei Containern, die mit docker compose erzeugt werden, können Sie mit dem Schlüs-
selwort restart einstellen, ob sie bei einem Rechnerneustart oder nach einem Fehler
automatisch neu gestartet werden sollen. Das Defaultverhalten lautet no. Die anderen
zulässigen Einstellungen lauten always, on-failure und unless-stopped . (Eine genaue
Erläuterung der Schlüsselwörter finden Sie in Abschnitt 6.6, »Container automatisch
starten«.)
restart : always
Das restart -Schlüsselwort wird von docker stack deploy ignoriert. Für Stack-Services
gilt standardmäßig, dass sie bei Bedarf automatisch neu gestartet werden. Davon
abweichende Einstellungen können Sie mit deploy.restart_policy festlegen (siehe
»Deploy-Einstellungen«).
Deploy-Einstellungen
Das Schlüsselwort deploy steuert, wie Services durch docker stack deploy eingerich-
tet werden. Diese Einstellungen gelten nur für den Schwarmmodus. docker compose
ignoriert das deploy-Schlüsselwort und alle von ihm abgeleiteten Einstellungen!
Die folgende Liste fasst die wichtigsten Schlüsselwörter zusammen:
deploy.mode gibt an, wie der Service ausgeführt wird. Die Defaulteinstellung lautet
replicated . Damit kann angegeben werden, wie viele Instanzen ausgeführt werden.
Der Schwarm-Manager entscheidet dann, auf welchen Docker-Rechnern die Instan-
zen gestartet werden.
129
5 Container-Setups mit »compose«
Die alternative Einstellung global bestimmt, dass auf jedem Knoten im Schwarm
exakt eine Instanz des Service ausgeführt werden soll.
deploy.placement.constraint legt eine Liste von Regeln fest, die bestimmt, auf wel-
chem Knoten der Service laufen soll. Die folgenden Zeilen geben Beispiele für
mögliche Regeln:
- node . id == <xxxx >
- node . hostname == <name >
- node . role == manager | worker
deploy.replicas gibt an, wie viele Instanzen des Service gleichzeitig laufen sollen
(normalerweise nur eine Instanz).
deploy.resources.limits.cpus limitiert die CPU-Nutzung des Service. Die Einstel-
lung 0.25 bedeutet, dass der Service ein CPU-Core durchschnittlich zu 25 % auslas-
ten darf.
deploy.resources.limits.memory legt eine Obergrenze für den Speicherbedarf des
Service fest.
deploy.restart_policy.condition: any|on-failure|none gibt an, unter welchen
Umständen ein Service automatisch neu gestartet werden soll. Standardmäßig
gilt any.
deploy.restart_policy.delay bestimmt, wie viele Sekunden Docker warten soll,
bevor es einen Service neu startet (standardmäßig 0).
deploy.restart_policy.max_attempts limitiert die Anzahl der Neustarts. (Standard-
mäßig gibt es kein Limit.)
In compose.yaml müssen die Einstellungen wie üblich durch Einrückungen formuliert
werden:
services :
nginx :
image : nginx : alpine
deploy :
placement :
constrai n t s :
- node . hostname == " dockerhos t 7 "
replicas : 5
resources :
limits :
cpus : '0.25 '
memory : 50 M
restart_p o l i cy :
conditio n : on - failure
delay : 2 s
5.4 Passwörter und andere Geheimnisse
In Abschnitt 5.2, »Hello Compose!«, haben wir das MySQL-Passwort als Umgebungs-
variable an die beiden Container bzw. Services übergeben. Sicherheitstechnisch ist
das natürlich nicht perfekt. Besser ist es, Passwörter, SSH-Schlüssel, SSL-Zertifikate
und vergleichbare Daten als sogenannte Geheimnisse zwischen Docker-Containern
bzw. -Services zu übertragen.
docker compose sieht dazu das Schlüsselwort secrets vor. Sie müssen es in docker-
compose.yml zumindest zweimal angeben: einmal innerhalb des Service, den Sie defi-
nieren wollen, und ein zweites Mal als Top-Level-Abschnitt. Im folgenden Beispiel ist
der Inhalt der lokalen Datei ./top-secret.txt (wobei der Pfad relativ zu compose.yaml
ist) im Container unter dem Pfad /run/secrets/mypassword zugänglich. Die Datei ent-
hält die Zeichenkette nobody knows :-).
# Datei compose . yaml
services :
secrette s t :
image : alpine
secrets :
- mypasswo r d
command : [" cat " , "/ run / secrets / mypasswor d "]
secrets :
mypasswo r d :
file : ./ top - secret . txt
Wenn Sie das Beispiel ausprobieren, wird mit cat der Inhalt der Datei /run/secrets/
mypassword ausgegeben. Anschließend endet die Container-Ausführung.
docker compose up
Recreati n g alpine - secret_s e c re t t e s t_ 1 ... done
Attachin g to alpine - secret_s ec r e t t es t _ 1
secrette s t _ 1 | nobody knows : -)
alpine - secret_s e cr e t t e st _ 1 exited with code 0
Probleme mit podman-compose
Die Beispiele in diesem Abschnitt funktionieren mit docker compose, aber nicht
mit podman-compose. Sowohl podman als auch das darauf aufbauende Script podman-
compose hatten zuletzt (Juni 2023, Podman 4.5) massive Probleme mit dem richtigen
Umgang mit Secrets:
https://github.com/containers/podman-compose/issues/655
https://github.com/containers/podman/pull/18878
Es ist zu hoffen, dass die fehlerhafte Implementierung dieses Features in zukünftigen
Podman-Versionen behoben wird.
5 Container-Setups mit »compose«
MariaDB/MySQL-Passwörter zwischen zwei Containern austauschen
Etwas raffinierter ist das folgende Beispiel. Hier erstellen Sie zunächst im glei-
chen Verzeichnis, in dem sich auch compose.yaml befindet, die beiden Textdateien
mysql-user-pw.txt und mysql-root-pw.txt. Diese enthalten zwei Passwörter.
In den Services wordpress und mariadb geben Sie jeweils mit secrets an, welche
der Geheimnisdateien Sie verwenden möchten. Die im WordPress- bzw. MariaDB-
Image vorgesehenen Umgebungsvariablen WORDPRESS_DB_PASSWORD_FILE , MYSQL_ROOT_
PASSWORD_FILE und MYSQL_PASSWORD_FILE initialisieren Sie mit den entsprechenden Pfa-
den zu /run/secrets/<name>. Der sonstige Aufbau des Listings entspricht der Datei
compose.yaml aus Abschnitt 5.2, »Hello Compose«.
# Datei compose . yaml ( Listing gek ü rzt )
services :
db :
image : mariadb : latest
secrets :
- mysql_ro o t
- mysql_us e r
environm en t :
MYSQL_ROO T _ PA S S W O RD _ F I L E :    / run / secrets / mysql_roo t
MYSQL_PAS S W OR D _ F I LE :              / run / secrets / mysql_use r
...
wordpres s :
image : wordpress : latest
secrets :
- mysql_us e r
environm en t :
WORDPRESS _ D B_ P A S S WO R D _ F IL E : / run / secrets / mysql_use r
...
secrets :
mysql_ro o t :
file : ./ mysql - root - pw . txt
mysql_us e r :
file : ./ mysql - user - pw . txt
5.5 Neue Projekte einrichten (docker init)
Bei aktuellen Docker-Versionen können Sie mit docker init ein neues Projekt ein-
richten. Das Kommando wird interaktiv ausgeführt. Im ersten Schritt erscheint eine
Frage, um welche Art von Projekt es sich handelt. Zum Zeitpunkt unserer Tests
standen nur drei Typen zur Auswahl: Go, Python (für Webapplikationen) und Node.
Danach folgen weitere Fragen zu den Konfigurationsdetails (siehe das folgende Lis-
ting).
docker init
This utility will walk you through creating the followin g files
with sensible defaults for your project :
- . dockerig no r e
- Dockerfi l e
- compose . yaml
Let ' s get started !
? What applicat i on platform does your project use ?
Go    - suitable for a Go server applicat i o n
> Python - suitable for a Python server applicati o n
Node  - suitable for a Node server applicat io n
Other - general purpose starting point for container i z i ng
your applicati o n
? What version of Python do you want to use ? > 3.11
? What port do you want your app to listen on ? > 8080
? What is the command to run your app ?
gunicorn 'myapp . example : app ' --bind =0.0.0.0 : 80 8 0
...
When you ' re ready , start your applicat i o n by running :
docker compose up --build
Your applicati o n will be availabl e at http :// localhost :8080
Anhand der angegebenen Informationen erstellt docker init im lokalen Verzeich-
nis drei neue Dateien: Dockerfile , compose.yaml und .dockerignore . Diese Dateien
sind ein guter Ausgangspunkt für eigene Ergänzungen. Zuletzt können Sie Ihr Pro-
jekt mit docker compose up starten. Die Option --build bewirkt, dass zuerst das durch
Dockerfile beschriebene Image erzeugt wird.
Zum Zeitpunkt unserer Tests befand sich docker init noch in einer Testphase und
stand nur bei einer Komplettinstallation des Docker-Desktop-Pakets zur Verfügung.
docker init versus podman init
Das relativ neue Kommando docker init ist ein weiteres Beispiel für die unvoll-
ständige Kompatibilität zwischen Docker und Podman. Es gibt zwar das Kommando
podman init, dieses hat aber nichts mit docker init zu tun; vielmehr initialisiert
es einen vorhandenen Container, führt also Vorbereitungsmaßnahmen wie Volume-
Mounts durch, ohne den Container letztlich auszuführen. Das kann für Debugging-
Zwecke sinnvoll sein.
<noinclude>
<!--
----
{{Navigation|<zurück>|<nachste>}}
----
-->
== Anhang ==
=== Siehe auch ===
<div style="column-count:2">
<categorytree hideroot=on mode="pages">{{BASEPAGENAME}}</categorytree>
</div>
----
{{Special:PrefixIndex/{{BASEPAGENAME}}/}}
=== Dokumentation ===
<!--
; Man-Page
# [https://manpages.debian.org/stable/procps/pgrep.1.de.html prep(1)]
; Info-Pages
; Hinweise
<div class="card h-100 bg-warning">
<div class="card-header">'''<big>Header</big>'''</div>
<div class="card-body bg-white">
Hier steht der Kartentext
</div>
</div>
-->
=== Links ===
==== Projekt ====
==== Weblinks ====
<!--
{{DEFAULTSORT:new}}
{{DISPLAYTITLE:new}}
-->
</noinclude>
</noinclude>

Aktuelle Version vom 17. November 2026, 16:55 Uhr

Docker/Compose - Verwaltung mehrerer Container, die gemeinsam eine Anwendung bilden

Beschreibung

Docker Compose ist ein Werkzeug zur Definition und Verwaltung mehrerer Container, die gemeinsam eine Anwendung bilden.

Die gesamte Umgebung wird in einer compose.yaml-Datei beschrieben und kann mit einem einzigen Befehl gestartet oder gestoppt werden.

Der Vorteil von Compose besteht darin, dass Sie Ihren Anwendungsstack in einer Datei definieren können, diese im Stammverzeichnis Ihres Projekt-Repositorys aufbewahren können (es ist jetzt versionskontrolliert) und es anderen Personen leicht ermöglichen, zu Ihrem Projekt beizutragen.

  • Jemand müsste nur Ihr Repository klonen und die Anwendung mit Compose starten.
  • Tatsächlich gibt es auf GitHub/GitLab eine ganze Reihe von Projekten, die genau das tun
Vorteile
  • Deklarative, versionskontrollierbare Konfiguration in compose.yaml.
  • Start, Stopp und Bereinigung des gesamten Stacks mit einem Befehl.
  • Isolierung und Service-Discovery über benannte Netzwerke und Volumes.
  • Skalierung und gemeinsame Log-Sicht pro Dienst.

In diesem Abschnitt wird Docker Compose vorgestellt

  • Definition und Freigabe von Multi-Service-Anwendungen

Erstellen Sie die Compose-Datei

Erstellen Sie im Verzeichnis getting-started-app eine Datei namens compose.yaml

├── getting-started-app/
│ ├── Dockerdatei
│ ├── compose.yaml
│ ├── node_modules/
│ ├── package.json
│ ├── spec/
│ ├── src/
│ └── yarn.lock

Definieren Sie den Anwendungsdienst

In Teil 6 haben Sie den folgenden Befehl verwendet, um den Anwendungsdienst zu starten

docker run -dp 3000:3000 \
 -w /app -v "$(pwd):/app" \
 --network todo-app \
 -e MYSQL_HOST=mysql \
 -e MYSQL_USER=root \
 -e MYSQL_PASSWORD=secret \
 -e MYSQL_DB=todos \
 node:lts-alpine \
 sh -c "yarn install && yarn run dev"

In YAML sieht diese Konfiguration wie folgt aus:

services:
 app:
  image: node:lts-alpine
  command: sh -c "yarn install && yarn run dev"
  ports:
   - 3000:3000
  working_dir: /app
  volumes:
   - ./:/app
  environment:
   MYSQL_HOST: mysql
   MYSQL_USER: root
   MYSQL_PASSWORD: secret
   MYSQL_DB: todos

Definieren Sie den MySQL-Dienst

Nun ist es an der Zeit, den MySQL-Dienst zu definieren.

  • Der Befehl, den Sie für diesen Container verwendet haben, war der folgende:
docker run -d \
 --network todo-app --network-alias mysql \
 -v todo-mysql-data:/var/lib/mysql \
 -e MYSQL_ROOT_PASSWORD=secret \
 -e MYSQL_DATABASE=todos \
 mysql:8.0

Zu diesem Zeitpunkt sollte Ihre komplette compose.yaml wie folgt aussehen:

services:
 app:
  image: node:lts-alpine
  command: sh -c "yarn install && yarn run dev"
  ports:
   - 3000:3000
  working_dir: /app
  volumes:
   - ./:/app
  environment:
   MYSQL_HOST: mysql
   MYSQL_USER: root
   MYSQL_PASSWORD: secret
   MYSQL_DB: todos

 mysql:
  image: mysql:8.0
  volumes:
   - todo-mysql-data:/var/lib/mysql
  environment:
   MYSQL_ROOT_PASSWORD: secret
   MYSQL_DATABASE: todos

volumes:
 todo-mysql-data:

Parameter

Entsprechung zwischen Parametern von docker run und YAML-Direktiven in compose.yaml

  • So kann nachvollzogen werden, wie Docker Compose die Einstellungen automatisch umsetzt
YAML docker run-Parameter Beschreibung
Dienst: app
image: node:lts-alpine node:lts-alpine Basis-Image.
command: sh -c "yarn install && yarn run dev" sh -c "yarn install && yarn run dev" Startkommando (überschreibt CMD).
ports:
  3000:3000
-p 3000:3000 Port-Mapping Host->Container.
working_dir: /app -w /app Arbeitsverzeichnis im Container.
volumes:
  ./:/app
-v "$(pwd):/app" Bind-Mount des Projektverzeichnisses.
environment: MYSQL_HOST, MYSQL_USER, MYSQL_PASSWORD, MYSQL_DB -e MYSQL_HOST=mysql
-e MYSQL_USER=root
-e MYSQL_PASSWORD=secret
-e MYSQL_DB=todos
Umgebungsvariablen für die App.
Dienst: mysql
image: mysql:8.0 mysql:8.0 MySQL-Server-Image.
volumes:
  todo-mysql-data:/var/lib/mysql
-v todo-mysql-data:/var/lib/mysql Benanntes Volume für persistente Daten.
environment: MYSQL_ROOT_PASSWORD, MYSQL_DATABASE -e MYSQL_ROOT_PASSWORD=secret
-e MYSQL_DATABASE=todos
Initiale Datenbankparameter.
Servicename: mysql --network-alias mysql DNS-Name im Container-Netzwerk (automatisch durch Servicenamen).
Top-Level
volumes:
  todo-mysql-data:
— Definition des benannten Volumes.

Anwendungsstack starten

Nun, da Sie Ihre compose.yaml-Datei haben, können Sie Ihre Anwendung starten.

  • Vergewissern Sie sich zunächst, dass keine anderen Kopien der Container ausgeführt werden.
  • Verwenden Sie docker ps, um die Container aufzulisten und docker rm -f <ids>, um sie zu entfernen
  • Starten Sie den Anwendungsstapel mit dem Befehl docker compose up.
  • Fügen Sie das Flag -d hinzu, um alles im Hintergrund laufen zu lassen
docker compose up -d
  • Wenn Sie den vorherigen Befehl ausführen, sollten Sie eine Ausgabe wie die folgende sehen
✔ Network getting-started-app_default     Created                                                                            0.1s
✔ Volume getting-started-app_todo-mysql-data Created                                                                            0.0s
✔ Container getting-started-app-mysql-1    Started                                                                            0.3s
✔ Container getting-started-app-app-1     Started

Sie werden feststellen, dass Docker Compose sowohl das Volume als auch ein Netzwerk erstellt hat.

  • Standardmäßig erstellt Docker Compose automatisch ein Netzwerk speziell für den Anwendungsstapel (deshalb haben Sie kein Netzwerk in der Compose-Datei definiert).
  • Sehen Sie sich die Protokolle mit dem Befehl docker compose logs -f an.
  • Sie werden sehen, dass die Protokolle der einzelnen Dienste in einen einzigen Stream verschachtelt sind.
  • Dies ist sehr nützlich, wenn Sie auf zeitliche Probleme achten wollen.
  • Die Markierung -f folgt dem Protokoll, so dass Sie eine Live-Ausgabe erhalten, während es erzeugt wird

Wenn Sie den Befehl bereits ausgeführt haben, werden Sie eine Ausgabe sehen, die wie folgt aussieht:

mysql_1 | 2019-10-03T03:07:16.083639Z 0 [Note] mysqld: ready for connections.
mysql_1 | Version: '8.0.31' socket: '/var/run/mysqld/mysqld.sock' port: 3306 MySQL Community Server (GPL)
app_1  | Connected to mysql db at host mysql
app_1  | Listening on port 3000
  • Der Name des Dienstes wird am Anfang der Zeile angezeigt (oft farbig), um die Unterscheidung der Meldungen zu erleichtern.
  • Wenn Sie die Protokolle für einen bestimmten Dienst anzeigen möchten, können Sie den Namen des Dienstes an das Ende des Befehls logs anhängen (z. B. docker compose logs -f app).
  • Zu diesem Zeitpunkt sollten Sie in der Lage sein, Ihre App in Ihrem Browser auf http://<server_ip>:3000/ zu öffnen und zu sehen, dass sie läuft

Sehen Sie den App-Stack im Docker Desktop Dashboard

Im Docker Desktop Dashboard sehen Sie, dass es eine Gruppe namens getting-started-app gibt.

  • Dies ist der Projektname von Docker Compose und wird verwendet, um die Container zusammenzufassen.
  • Standardmäßig ist der Projektname einfach der Name des Verzeichnisses, in dem sich die compose.yaml befand

Wenn Sie den Stack erweitern, sehen Sie die beiden Container, die Sie in der Compose-Datei definiert haben.

  • Die Namen sind auch etwas aussagekräftiger, da sie dem Muster <Service-Name>-<Replikat-Nummer> folgen.
  • So ist es sehr einfach, schnell zu erkennen, welcher Container Ihre Anwendung und welcher Container die mysql-Datenbank ist

Alles abreißen

Wenn Sie bereit sind, alles abzubauen, führen Sie einfach docker compose down aus oder drücken Sie den Mülleimer im Docker Desktop Dashboard für die gesamte Anwendung.

  • Die Container werden gestoppt und das Netzwerk wird entfernt
Warnung

Standardmäßig werden benannte Volumes in Ihrer Compose-Datei nicht entfernt, wenn Sie docker compose down ausführen.

  • Wenn Sie die Volumes entfernen möchten, müssen Sie das Flag --volumes hinzufügen

Das Docker Desktop Dashboard entfernt die Volumes nicht, wenn Sie den Anwendungsstapel löschen

Nächste Schritte

Image Erstellung


Anhang

Siehe auch


Dokumentation

Projekt

  1. Compose-Übersicht
  2. Compose-Dateireferenz
  3. Compose CLI-Referenz