Docker Compose verwenden

Docker Compose bietet eine Möglichkeit, mehrere zusammenarbeitende Container zu orchestrieren. Beispiele hierfür sind ein Dienst, der Anfragen verarbeitet, und eine Frontend-Webseite, oder ein Dienst, der eine unterstützende Funktion wie einen Redis-Cache verwendet. Wenn Sie das Microservices-Modell für Ihre App-Entwicklung verwenden, können Sie Docker Compose nutzen, um den App-Code in mehrere unabhängig laufende Dienste aufzuteilen, die über Webanfragen kommunizieren. Dieser Artikel hilft Ihnen, Docker Compose für Ihre Apps zu aktivieren, unabhängig davon, ob es sich um Node.js, Python oder .NET handelt, und hilft Ihnen auch bei der Konfiguration des Debuggens in Visual Studio Code für diese Szenarien.

Auch für Szenarien mit einzelnen Containern bietet die Verwendung von Docker Compose eine toolunabhängige Konfiguration, wie es eine einzelne Dockerfile nicht tut. Konfigurationseinstellungen wie Volume-Mounts für den Container, Port-Mappings und Umgebungsvariablen können in den docker-compose YML-Dateien deklariert werden.

Um Docker Compose in VS Code über die Container Tools-Erweiterung zu verwenden, sollten Sie bereits mit den Grundlagen von Docker Compose vertraut sein.

Docker Compose-Unterstützung zu Ihrem Projekt hinzufügen

Wenn Sie bereits eine oder mehrere Dockerfiles haben, können Sie Docker Compose-Dateien hinzufügen, indem Sie die **Befehlspalette** (⇧⌘P (Windows, Linux Ctrl+Shift+P)) öffnen und den Befehl **Container: Docker Compose-Dateien zum Arbeitsbereich hinzufügen** verwenden. Befolgen Sie die Anweisungen.

Sie können Docker Compose-Dateien zu Ihrem Arbeitsbereich hinzufügen, während Sie eine Dockerfile hinzufügen, indem Sie die **Befehlspalette** (⇧⌘P (Windows, Linux Ctrl+Shift+P)) öffnen und den Befehl **Container: Docker-Dateien zum Arbeitsbereich hinzufügen** verwenden. Sie werden gefragt, ob Sie Docker Compose-Dateien hinzufügen möchten. Wenn Sie Ihre vorhandene Dockerfile behalten möchten, wählen Sie **Nein**, wenn Sie aufgefordert werden, die Dockerfile zu überschreiben.

Die Container Tools-Erweiterung fügt die Datei docker-compose.yml zu Ihrem Arbeitsbereich hinzu. Diese Datei enthält die Konfiguration zum Starten der Container wie in der Produktion erwartet. In einigen Fällen wird auch eine docker-compose.debug.yml generiert. Diese Datei bietet einen vereinfachten Modus zum Starten, der den Debugger aktiviert.

Screenshot of project with docker-compose files

Die VS Code Container Tools-Erweiterung generiert Dateien, die sofort funktionieren, aber Sie können sie auch anpassen, um sie für Ihr Szenario zu optimieren. Sie können dann den Befehl **Container: Compose Up** (mit der rechten Maustaste auf die Datei docker-compose.yml klicken oder den Befehl in der **Befehlspalette** suchen), um alles auf einmal zu starten. Sie können auch den Befehl docker-compose up über die Eingabeaufforderung oder das Terminalfenster in VS Code verwenden, um die Container zu starten. Informationen zur Konfiguration des Docker Compose-Verhaltens und zu verfügbaren Befehlszeilenoptionen finden Sie in der Docker Compose-Dokumentation.

Mit den docker-compose-Dateien können Sie nun Port-Mappings in den docker-compose-Dateien anstelle der .json-Konfigurationsdateien angeben. Beispiele finden Sie in der Docker Compose-Dokumentation.

Tipp: Wenn Sie Docker Compose verwenden, geben Sie keinen Host-Port an. Lassen Sie stattdessen Docker einen zufälligen verfügbaren Port auswählen, um Portkonflikte automatisch zu vermeiden.

Neue Container zu Ihren Projekten hinzufügen

Wenn Sie eine weitere App oder einen weiteren Dienst hinzufügen möchten, können Sie den Befehl **Container: Docker Compose-Dateien zum Arbeitsbereich hinzufügen** erneut ausführen und wählen, die vorhandenen docker-compose-Dateien zu überschreiben. Dabei gehen jedoch alle Anpassungen in diesen Dateien verloren. Wenn Sie Änderungen an den Compose-Dateien beibehalten möchten, können Sie die Datei docker-compose.yml manuell bearbeiten, um den neuen Dienst hinzuzufügen. Typischerweise können Sie den vorhandenen Dienstabschnitt kopieren, einfügen, um einen neuen Eintrag zu erstellen, und die Namen entsprechend für den neuen Dienst ändern.

Sie können den Befehl **Container: Docker-Dateien zum Arbeitsbereich hinzufügen** erneut ausführen, um die Dockerfile für eine neue App zu generieren. Während jede App oder jeder Dienst seine eigene Dockerfile hat, gibt es normalerweise eine docker-compose.yml und eine docker-compose.debug.yml pro Arbeitsbereich.

In Python-Projekten befinden sich die Dateien Dockerfile, .dockerignore und docker-compose*.yml im Stammverzeichnis des Arbeitsbereichs. Wenn Sie eine weitere App oder einen weiteren Dienst hinzufügen, verschieben Sie die Dockerfile in den Ordner der App.

In Node.js-Projekten befinden sich die Dateien Dockerfile und .dockerignore neben der package.json für diesen Dienst.

Für .NET ist die Ordnerstruktur bereits so eingerichtet, dass sie mehrere Projekte handhabt. Wenn Sie die Docker Compose-Dateien erstellen, werden .dockerignore und docker-compose*.yml im Stammverzeichnis des Arbeitsbereichs platziert (z. B. wenn sich das Projekt in src/project1 befindet, dann befinden sich die Dateien in src). Wenn Sie einen weiteren Dienst hinzufügen, erstellen Sie ein weiteres Projekt in einem Ordner, z. B. project2, und erstellen Sie die docker-compose-Dateien neu oder ändern Sie sie wie zuvor beschrieben.

Debuggen

Beziehen Sie sich zuerst auf die Debugging-Dokumentation für Ihre Zielplattform, um die Grundlagen des Debuggens in Containern mit VS Code zu verstehen.

Wenn Sie mit Docker Compose debuggen möchten, führen Sie den Befehl **Container: Compose Up** mit einer der beiden Docker Compose-Dateien wie im vorherigen Abschnitt beschrieben aus und verbinden Sie sich dann mit der entsprechenden **Attach**-Startkonfiguration. Das Starten direkt über die normale Startkonfiguration verwendet nicht Docker Compose.

Erstellen Sie eine **Attach**- Startkonfiguration. Dies ist ein Abschnitt in launch.json. Der Prozess ist größtenteils manuell, aber in einigen Fällen kann die Container Tools-Erweiterung helfen, indem sie eine vorkonfigurierte Startkonfiguration hinzufügt, die Sie als Vorlage verwenden und anpassen können. Der Prozess für jede Plattform (Node.js, Python und .NET) wird in den folgenden Abschnitten beschrieben.

Node.js

Wählen Sie auf der Registerkarte **Debug** das Dropdown-Menü **Konfiguration**, wählen Sie **Neue Konfiguration** und wählen Sie die Vorlage für die Konfiguration Containers: Attach **Container: An Node anhängen**.

Konfigurieren Sie den Debugging-Port in docker-compose.debug.yml. Dies wird beim Erstellen der Datei festgelegt, sodass Sie ihn möglicherweise nicht ändern müssen. Im folgenden Beispiel wird Port 9229 für das Debugging auf dem Host und dem Container verwendet.

 version: '3.4'

 services:
   node-hello:
     image: node-hello
     build: .
     environment:
       NODE_ENV: development
     ports:
       - 3000
       - 9229:9229
     command: node --inspect=0.0.0.0:9229 ./bin/www

Wenn Sie mehrere Apps haben, müssen Sie den Port für einige von ihnen ändern, damit jede App einen eindeutigen Port hat. Sie können im launch.json auf den richtigen Debugging-Port verweisen und die Datei speichern. Wenn Sie dies weglassen, wird der Port automatisch ausgewählt.

Hier ist ein Beispiel, das die Node.js-Startkonfiguration - Attach zeigt

 "configurations": [
     {
         "type": "node",
         "request": "attach",
         "name": "Containers: Attach to Node",
         "remoteRoot": "/usr/src/app",
         "port": 9229 // Optional; otherwise inferred from the docker-compose.debug.yml.
     },
     // ...
 ]

Wenn Sie mit der Bearbeitung der **Attach**-Konfiguration fertig sind, speichern Sie launch.json und wählen Sie Ihre neue Startkonfiguration als aktive Konfiguration aus. Suchen Sie auf der Registerkarte **Debug** die neue Konfiguration im Dropdown-Menü **Konfiguration**.
Klicken Sie mit der rechten Maustaste auf die Datei docker-compose.debug.yml und wählen Sie **Compose Up**.
Wenn Sie eine Verbindung zu einem Dienst herstellen, der einen HTTP-Endpunkt bereitstellt und HTML zurückgibt, wird der Webbrowser nicht automatisch geöffnet. Um die App im Browser zu öffnen, wählen Sie den Container in der Seitenleiste aus, klicken Sie mit der rechten Maustaste und wählen Sie **Im Browser öffnen**. Wenn mehrere Ports konfiguriert sind, werden Sie aufgefordert, den Port auszuwählen.
Starten Sie den Debugger auf übliche Weise. Wählen Sie auf der Registerkarte **Debug** den grünen Pfeil (Schaltfläche **Start**) oder verwenden Sie F5.

Python

Befolgen Sie für das Debuggen von Python mit Docker Compose diese Schritte

Wählen Sie auf der Registerkarte **Debug** das Dropdown-Menü **Konfiguration**, wählen Sie **Neue Konfiguration**, wählen Sie **Python-Debugger** und wählen Sie die Vorlage für die **Remote Attach**-Konfiguration.

Sie werden aufgefordert, den Host und den Port auszuwählen, den Sie für das Debugging verwenden möchten (z. B. localhost). Der Standard-Debugging-Port für Python ist 5678. Wenn Sie mehrere Apps haben, müssen Sie den Port für eine davon ändern, damit jede App einen eindeutigen Port hat. Sie können im launch.json auf den richtigen Debugging-Port verweisen und die Datei speichern. Wenn Sie dies weglassen, wird der Port automatisch ausgewählt.

     "configurations": [
     {
        "name": "Python Debugger: Remote Attach",
        "type": "debugpy",
        "request": "attach",
        "port": 5678,
        "host": "localhost",
        "pathMappings": [
            {
                "localRoot": "${workspaceFolder}",
                "remoteRoot": "/app"
            }
        ]
    }

Wenn Sie mit der Bearbeitung der **Attach**-Konfiguration fertig sind, speichern Sie launch.json. Navigieren Sie zur Registerkarte **Debug** und wählen Sie **Python Debugger: Remote Attach** als aktive Konfiguration aus.
Wenn Sie bereits eine gültige Dockerfile haben, empfehlen wir die Ausführung des Befehls **Container: Docker Compose-Dateien zum Arbeitsbereich hinzufügen**. Dies erstellt eine docker-compose.yml-Datei und auch eine docker-compose.debug.yml, die den Python-Debugger im Container voldmapped und startet. Wenn Sie noch keine Dockerfile haben, empfehlen wir die Ausführung von **Container: Docker-Dateien zum Arbeitsbereich hinzufügen** und die Auswahl von **Ja** zum Einbinden von Docker Compose-Dateien.

Hinweis: Standardmäßig werden beim Auswählen der Django- und Flask-Optionen für **Container: Docker-Dateien zum Arbeitsbereich hinzufügen** eine Dockerfile für Gunicorn konfiguriert. Befolgen Sie die Anweisungen im Python im Container-Quickstart, um sicherzustellen, dass sie richtig konfiguriert ist, bevor Sie fortfahren.

Klicken Sie mit der rechten Maustaste auf die Datei docker-compose.debug.yml (Beispiel unten gezeigt) und wählen Sie **Compose Up**.

version: '3.4'

services:
  pythonsamplevscodedjangotutorial:
    image: pythonsamplevscodedjangotutorial
    build:
      context: .
      dockerfile: ./Dockerfile
    command: ["sh", "-c", "pip install debugpy -t /tmp && python /tmp/debugpy --wait-for-client --listen 0.0.0.0:5678 manage.py runserver 0.0.0.0:8000 --nothreading --noreload"]
    ports:
      - 8000:8000
      - 5678:5678

Sobald Ihr Container erstellt und ausgeführt wird, verbinden Sie den Debugger, indem Sie F5 mit der ausgewählten Startkonfiguration **Python Debugger: Remote Attach** drücken.

Hinweis: Wenn Sie den Python-Debugger in eine bestimmte Datei importieren möchten, finden Sie weitere Informationen in der debugpy README.
Wenn Sie eine Verbindung zu einem Dienst herstellen, der einen HTTP-Endpunkt bereitstellt und HTML zurückgibt, öffnet sich der Webbrowser möglicherweise nicht automatisch. Um die App im Browser zu öffnen, klicken Sie mit der rechten Maustaste auf den Container im Container Explorer und wählen Sie **Im Browser öffnen**. Wenn mehrere Ports konfiguriert sind, werden Sie aufgefordert, den Port auszuwählen.

Sie debuggen jetzt Ihre laufende App im Container.

.NET

Wählen Sie auf der Registerkarte **Debug** das Dropdown-Menü **Konfiguration**, wählen Sie **Neue Konfiguration** und wählen Sie die Vorlage für die Container-Anbindung **Container: .NET-Anbindung (Vorschau)**.
VS Code versucht, vsdbg vom Host-Computer zum Zielcontainer zu kopieren, indem es einen Standardpfad verwendet. Sie können auch einen Pfad zu einer vorhandenen Instanz von vsdbg in der **Attach**-Konfiguration angeben.
```
 "netCore": {
     "debuggerPath": "/remote_debugger/vsdbg"
 }
```
Wenn Sie mit der Bearbeitung der **Attach**-Konfiguration fertig sind, speichern Sie launch.json und wählen Sie Ihre neue Startkonfiguration als aktive Konfiguration aus. Suchen Sie auf der Registerkarte **Debug** die neue Konfiguration im Dropdown-Menü **Konfiguration**.
Klicken Sie mit der rechten Maustaste auf die Datei docker-compose.debug.yml und wählen Sie **Compose Up**.
Wenn Sie eine Verbindung zu einem Dienst herstellen, der einen HTTP-Endpunkt bereitstellt und HTML zurückgibt, wird der Webbrowser nicht automatisch geöffnet. Um die App im Browser zu öffnen, wählen Sie den Container in der Seitenleiste aus, klicken Sie mit der rechten Maustaste und wählen Sie **Im Browser öffnen**. Wenn mehrere Ports konfiguriert sind, werden Sie aufgefordert, den Port auszuwählen.
Starten Sie den Debugger auf übliche Weise. Wählen Sie auf der Registerkarte **Debug** den grünen Pfeil (Schaltfläche **Start**) oder verwenden Sie F5.
Wenn Sie versuchen, eine Verbindung zu einer .NET-App herzustellen, die in einem Container ausgeführt wird, wird eine Aufforderung angezeigt, den Container Ihrer App auszuwählen.

Um diesen Schritt zu überspringen, geben Sie den Container-Namen in der **Attach**-Konfiguration in launch.json an.
```
    "containerName": "Your ContainerName"
```
Als Nächstes werden Sie gefragt, ob Sie den Debugger (vsdbg) in den Container kopieren möchten. Wählen Sie **Ja**.

Wenn alles richtig konfiguriert ist, sollte der Debugger mit Ihrer .NET-App verbunden sein.

Screenshot of debug session

Volume-Mounts

Standardmäßig führt die Container Tools-Erweiterung keine Volume-Mounts für Debugging-Komponenten durch. Dies ist bei .NET oder Node.js nicht erforderlich, da die erforderlichen Komponenten in die Laufzeit integriert sind. Wenn Ihre App Volume-Mounts benötigt, geben Sie diese mit dem volumes-Tag in den docker-compose*.yml-Dateien an.

volumes:
    - /host-folder-path:/container-folder-path

Docker Compose mit mehreren Compose-Dateien

Arbeitsbereiche können mehrere docker-compose-Dateien enthalten, um verschiedene Umgebungen wie Entwicklung, Test und Produktion zu handhaben. Der Inhalt der Konfiguration kann auf mehrere Dateien aufgeteilt werden. Zum Beispiel eine Basis-Compose-Datei, die die gemeinsamen Informationen für alle Umgebungen definiert, und separate Überschreibungsdateien, die umgebungsspezifische Informationen definieren. Wenn diese Dateien als Eingabe für den docker-compose-Befehl übergeben werden, werden diese Dateien zu einer einzigen Konfiguration kombiniert. Standardmäßig übergibt der Befehl **Container: Compose Up** eine einzelne Datei als Eingabe für den Compose-Befehl, aber Sie können den compose up-Befehl anpassen, um mehrere Dateien mithilfe der Befehlseinstellungen zu übergeben. Oder Sie können eine benutzerdefinierte Aufgabe verwenden, um den docker-compose-Befehl mit den gewünschten Parametern aufzurufen.

Hinweis: Wenn Ihr Arbeitsbereich docker-compose.yml und docker-compose.override.yml enthält und keine anderen Compose-Dateien, dann wird der docker-compose-Befehl ohne Eingabedateien aufgerufen und verwendet implizit diese Dateien. In diesem Fall ist keine Anpassung erforderlich.

Befehlseinstellungen

Befehlseinstellungen bieten verschiedene Möglichkeiten, den compose up-Befehl nach Ihren Anforderungen anzupassen. Im Folgenden finden Sie einige Beispiel-Befehlseinstellungen für den compose up-Befehl.

Basisdatei und Überschreibungsdatei

Angenommen, Ihr Arbeitsbereich hat eine Basis-Compose-Datei (docker-compose.yml) und für jede Umgebung eine Überschreibungsdatei (docker-compose.dev.yml, docker-compose.test.yml und docker-compose.prod.yml) und Sie führen immer docker compose up mit der Basisdatei und einer Überschreibungsdatei aus. In diesem Fall kann der compose up-Befehl wie im folgenden Beispiel angepasst werden. Wenn der compose up-Befehl aufgerufen wird, wird ${configurationFile} durch die ausgewählte Datei ersetzt.

"docker.commands.composeUp": [
    {
        "label": "override",
        "template": "docker-compose -f docker-compose.yml ${configurationFile}  up -d --build",
    }
]

Vorlagenabgleich

Angenommen, Sie haben für jede Umgebung einen anderen Satz von Eingabedateien. Sie könnten mehrere Vorlagen mit regulären Ausdrücken definieren, und der ausgewählte Dateiname wird mit dieser match-Eigenschaft abgeglichen, und die entsprechende Vorlage wird verwendet.

"containers.commands.composeUp": [
    {
        "label": "dev-match",
        "template": "docker-compose -f docker-compose.yml -f docker-compose.debug.yml -f docker-compose.dev.yml up -d --build",
        "match": "dev"
    },
    {
        "label": "test-match",
        "template": "docker-compose -f docker-compose.yml -f docker-compose.debug.yml -f docker-compose.test.yml up -d --build",
        "match": "test"
    },
    {
        "label": "prod-match",
        "template": "docker-compose -f docker-compose.yml -f docker-compose.release.yml -f docker-compose.prod.yml up -d --build",
        "match": "prod"
    }
]

Wählen Sie eine Vorlage, wenn der Befehl aufgerufen wird

Wenn Sie die match-Eigenschaft aus den Befehlsvorlagen weglassen, werden Sie bei jedem Aufruf des compose up-Befehls gefragt, welche Vorlage verwendet werden soll. Beispiel:

"containers.commands.composeUp": [
    {
        "label": "dev",
        "template": "docker-compose -f docker-compose.yml -f docker-compose.common.dev.yml ${configurationFile} up -d --build"
    },
    {
        "label": "test",
        "template": "docker-compose -f docker-compose.yml -f docker-compose.common.test.yml ${configurationFile} up -d --build"
    },
    {
        "label": "prod",
        "template": "docker-compose -f docker-compose.yml -f docker-compose.common.prod.yml ${configurationFile} up -d --build"
    },
],

Benutzerdefinierte Tasks

Anstatt Befehlseinstellungen zu verwenden, können Sie auch eine Aufgabe wie die folgende definieren, um einen docker-compose-Befehl aufzurufen. Weitere Informationen zu dieser Option finden Sie unter benutzerdefinierte Aufgaben.

{
  "type": "shell",
  "label": "compose-up-dev",
  "command": "docker-compose -f docker-compose.yml -f docker-compose.Common.yml -f docker-compose.dev.yml up -d --build",
  "presentation": {
    "reveal": "always",
    "panel": "new"
  }
}

Nächste Schritte

12/21/2022