Docker/Compose

Aus Foxwiki
Wechseln zu:Navigation, Suche

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


TMP

Docker/Compose


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.

  1. 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.

  1. 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.
  1. 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:

  1. Datei compose . yaml
  2. Containe r / Service endet sofort , weil es
  3. 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:

  1. 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

  1. 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.

  1. 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.

  1. 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:

  1. 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:

  1. 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 "]

  1. mehrteil i g e s Kommando

command : [" php " , " -a "]

  1. 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 :-).

  1. 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«.

  1. 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.


Anhang

Siehe auch


Dokumentation

Projekt