Dev-Container erstellen

Die Erweiterung Visual Studio Code Dev Containers ermöglicht die Verwendung eines Docker-Containers als vollwertige Entwicklungsumgebung. Sie ermöglicht das Öffnen beliebiger Ordner oder Repositories innerhalb eines Containers und die Nutzung des vollständigen Funktionsumfangs von Visual Studio Code. Eine devcontainer.json-Datei in Ihrem Projekt teilt VS Code mit, wie auf einen Entwicklungscontainer mit einem klar definierten Werkzeug- und Runtime-Stack zugegriffen (oder dieser erstellt) werden soll. Dieser Container kann zum Ausführen einer Anwendung oder zur Bereitstellung separater Werkzeuge, Bibliotheken oder Runtimes verwendet werden, die für die Arbeit mit einer Codebasis erforderlich sind.

Pfad zur Erstellung eines Dev-Containers

In diesem Dokument werden die Schritte zur Erstellung eines Entwicklungs- (Dev-) Containers in VS Code erläutert.

1. Erstellen Sie eine devcontainer.json, die beschreibt, wie VS Code den Container starten und was nach der Verbindung zu tun ist.
2. Änderungen am Dev-Container vornehmen und beibehalten, z. B. die Installation neuer Software, mithilfe einer Dockerfile.
3. Konfigurieren Sie mehrere Container über Docker Compose.
4. Nehmen Sie während der vorgenommenen Änderungen Änderungen vor, um sicherzustellen, dass Ihre Dev-Container-Änderungen wirksam werden.

Nach jedem der oben genannten Schritte haben Sie einen voll funktionsfähigen Dev-Container und können entweder mit dem nächsten Schritt dieses Tutorials fortfahren, um weitere Funktionen hinzuzufügen, oder aufhören und mit der Arbeit in der aktuell verfügbaren Entwicklungsumgebung beginnen.

Hinweis: Die Erweiterung Dev Containers verfügt über den Befehl Dev Containers: Dev Container-Konfigurationsdateien hinzufügen..., mit dem Sie eine vordefinierte Containerkonfiguration aus einer Liste auswählen können. Wenn Sie sofort einen vollständigen Dev-Container wünschen, anstatt die devcontainer.json und die Dockerfile Schritt für Schritt zu erstellen, können Sie zu Automatisierte Erstellung von Dev-Containern springen.

Erstellen einer devcontainer.json-Datei

Die Containerkonfiguration von VS Code wird in einer devcontainer.json-Datei gespeichert. Diese Datei ähnelt der launch.json-Datei für Debugging-Konfigurationen, wird aber stattdessen zum Starten (oder Anhängen an) Ihres Entwicklungscontainers verwendet. Die Entwicklungscontainerkonfiguration befindet sich entweder unter .devcontainer/devcontainer.json oder ist als .devcontainer.json-Datei (beachten Sie den Punkt am Anfang) im Stammverzeichnis Ihres Projekts gespeichert.

Sie können ein Image als Ausgangspunkt für Ihre devcontainer.json verwenden. Ein Image ist wie ein Mini-Festplattenlaufwerk mit verschiedenen vorinstallierten Werkzeugen und einem Betriebssystem. Sie können Images aus einem Container-Registry ziehen, bei dem es sich um eine Sammlung von Repositories handelt, die Images speichern. Hier ist ein einfaches Beispiel für eine devcontainer.json, die ein vorab erstelltes VS Code Development Container-Image für TypeScript und Node.js verwendet Image

{
  "image": "mcr.microsoft.com/devcontainers/typescript-node:0-18"
}

Sie können Ihre Konfiguration ändern, um Dinge wie z. B.

• Zusätzliche Tools wie Git im Container installieren.
• Erweiterungen automatisch installieren.
• Zusätzliche Ports weiterleiten oder veröffentlichen.
• Runtime-Argumente festlegen.
• Ihre vorhandene Docker Compose-Einrichtung wiederverwenden oder erweitern.
• Weitere erweiterte Containerkonfigurationen hinzufügen.

Für dieses Beispiel, wenn Sie die Erweiterung Code Spell Checker in Ihren Container installieren und Port 3000 automatisch weiterleiten möchten, würde Ihre devcontainer.json wie folgt aussehen:

{
  "image": "mcr.microsoft.com/devcontainers/typescript-node",

  "customizations": {
    "vscode": {
      "extensions": ["streetsidesoftware.code-spell-checker"]
    }
  },
  "forwardPorts": [3000]
}

Hinweis: Zusätzliche Konfigurationen werden bereits basierend auf dem Inhalt des Basis-Images zum Container hinzugefügt. Zum Beispiel fügen wir oben die Erweiterung streetsidesoftware.code-spell-checker hinzu, und der Container wird auch "dbaeumer.vscode-eslint" enthalten, da dies Teil von mcr.microsoft.com/devcontainers/typescript-node ist. Dies geschieht automatisch beim Vorabbauen mit devcontainer.json, worüber Sie im Abschnitt Vorabbau mehr erfahren können.

Mit der obigen devcontainer.json ist Ihr Dev-Container funktionsfähig, und Sie können sich damit verbinden und mit der Entwicklung darin beginnen. Probieren Sie es mit dem Befehl Dev Containers: Reopen in Container aus.

Nach Ausführung dieses Befehls, wenn VS Code neu startet, befinden Sie sich nun in einem Node.js- und TypeScript-Dev-Container mit weitergeleitetem Port 3000 und installierter ESLint-Erweiterung. Sobald Sie verbunden sind, beachten Sie den grünen Remote-Indikator links in der Statusleiste, der anzeigt, dass Sie mit Ihrem Dev-Container verbunden sind.

Zusätzliche Dev-Container-Szenarien

Über eine devcontainer.json-Datei können Sie

• Einen eigenständigen Container hochfahren, um Ihre Toolchain zu isolieren oder die Einrichtung zu beschleunigen.
• Mit einer Container-bereitschaftsgestellten Anwendung arbeiten, die durch ein Image, eine Dockerfile oder Docker Compose definiert ist.
• Docker oder Kubernetes aus einem Dev-Container heraus verwenden, um Ihre App zu erstellen und bereitzustellen.

Wenn die unterstützten Workflows von devcontainer.json nicht Ihren Anforderungen entsprechen, können Sie auch sich an einen bereits laufenden Container anhängen.

Tipp: Möchten Sie einen Remote-Docker-Host verwenden? Lesen Sie den Artikel Entwickeln auf einem Remote-Docker-Host für Details zur Einrichtung.

Zusätzliche Software installieren

Sie möchten möglicherweise zusätzliche Software in Ihrem Dev-Container installieren. Sobald VS Code mit dem Container verbunden ist, können Sie ein VS Code-Terminal öffnen und beliebige Befehle gegen das Betriebssystem im Container ausführen. Dies ermöglicht die Installation neuer Kommandozeilenwerkzeuge und den Start von Datenbanken oder Anwendungsdiensten innerhalb des Linux-Containers.

Die meisten Container-Images basieren auf Debian oder Ubuntu, wo der Befehl apt oder apt-get zur Installation neuer Pakete verwendet wird. Mehr über den Befehl erfahren Sie in der Ubuntu-Dokumentation. Alpine-Images enthalten einen ähnlichen Befehl apk, während CentOS / RHEL / Oracle SE / Fedora-Images yum oder kürzlich dnf verwenden.

Die Dokumentation für die zu installierende Software enthält normalerweise spezifische Anweisungen, Sie müssen Befehle jedoch möglicherweise nicht mit sudo präfixieren, wenn Sie als Root im Container ausgeführt werden.

Zum Beispiel

# If running as root
apt-get update
apt-get install <package>

Wenn Sie als Root ausgeführt werden, können Sie Software installieren, solange sudo in Ihrem Container konfiguriert ist. Alle vordefinierten Container haben sudo eingerichtet, aber der Artikel Hinzufügen eines Nicht-Root-Benutzers zu einem Container hilft Ihnen, dies für Ihre eigenen Container einzurichten. Unabhängig davon können Sie sudo verwenden, wenn Sie es installieren und konfigurieren, wenn Sie als beliebiger Benutzer, einschließlich Root, ausgeführt werden.

# If sudo is installed and configured
sudo apt-get update
sudo apt-get install <package>

Nehmen wir an, Sie möchten Git installieren. Sie könnten die folgenden Befehle im integrierten Terminal in VS Code ausführen:

# If sudo is installed and configured
sudo apt-get update
# Install Git
sudo apt-get install git

Sie können auch die Eigenschaft "features" in der devcontainer.json verwenden, um Tools und Sprachen aus einer vordefinierten Menge von Features oder sogar Ihren eigenen zu installieren.

Zum Beispiel könnten Sie die neueste Version der Azure CLI mit dem folgenden Befehl installieren:

"features": {
    "ghcr.io/devcontainers/features/azure-cli:1": {
        "version": "latest"
    }
  }

Weitere Details finden Sie in der Dev Container Features-Spezifikation.

Neu erstellen

Wenn Sie den Inhalt des Ordners .devcontainer bearbeiten, müssen Sie neu erstellen, damit die Änderungen wirksam werden. Verwenden Sie den Befehl Dev Containers: Rebuild Container für Ihren Container, um ihn zu aktualisieren.

Wenn Sie den Container jedoch neu erstellen, müssen Sie alles, was Sie manuell installiert haben, neu installieren. Um dieses Problem zu vermeiden, können Sie die Eigenschaft postCreateCommand in devcontainer.json oder eine benutzerdefinierte Dockerfile verwenden.

Eine benutzerdefinierte Dockerfile profitiert vom Build-Cache von Docker und führt zu schnelleren Neuerstellungen als postCreateCommand. Die Dockerfile wird jedoch ausgeführt, bevor der Dev-Container erstellt und der Workspace-Ordner gemountet wird, und hat daher keinen Zugriff auf die Dateien im Workspace-Ordner. Eine Dockerfile eignet sich am besten zur Installation von Paketen und Tools unabhängig von Ihren Workspace-Dateien.

Die Aktionen von postCreateCommand werden ausgeführt, sobald der Container erstellt ist. Sie können die Eigenschaft daher auch verwenden, um Befehle wie npm install auszuführen oder ein Shell-Skript in Ihrem Quellcode (falls Sie ihn gemountet haben) auszuführen.

"postCreateCommand": "bash scripts/install-dependencies.sh"

Sie können auch eine interaktive Bash-Shell verwenden, damit Ihre .bashrc übernommen wird und Ihre Shell automatisch für Ihre Umgebung angepasst wird.

"postCreateCommand": "bash -i scripts/install-dependencies.sh"

Tools wie NVM funktionieren nicht, ohne -i zu verwenden, um die Shell in den interaktiven Modus zu versetzen.

"postCreateCommand": "bash -i -c 'nvm install --lts'"

Der Befehl muss beendet werden, sonst startet der Container nicht. Wenn Sie beispielsweise eine Anwendung starten zu postCreateCommand hinzufügen, würde der Befehl nicht beendet werden.

Es gibt auch einen Befehl postStartCommand, der jedes Mal ausgeführt wird, wenn der Container gestartet wird. Die Parameter verhalten sich exakt wie postCreateCommand, aber die Befehle werden beim Start statt beim Erstellen ausgeführt.

Anstatt direkt auf ein Image in devcontainer.json zu verweisen oder Software über postCreateCommand oder postStartCommand zu installieren, ist eine noch effizientere Praxis die Verwendung einer Dockerfile.

Dockerfile

Eine Dockerfile befindet sich ebenfalls im Ordner .devcontainer. Sie können die Eigenschaft image in devcontainer.json durch dockerfile ersetzen.

{
  "build": { "dockerfile": "Dockerfile" },

  "customizations": {
    "vscode": {
      "extensions": ["dbaeumer.vscode-eslint"]
    }
  },

  "forwardPorts": [3000]
}

Wenn Sie Änderungen vornehmen, wie z. B. die Installation neuer Software, bleiben Änderungen, die in der Dockerfile vorgenommen wurden, auch bei einer Neuerstellung des Dev-Containers erhalten.

Verwenden Sie in Ihrer Dockerfile FROM, um das Image zu bezeichnen, und die Anweisung RUN, um jegliche Software zu installieren. Sie können && verwenden, um mehrere Befehle zu verketten.

FROM mcr.microsoft.com/devcontainers/javascript-node:0-18
RUN apt-get update && export DEBIAN_FRONTEND=noninteractive \
    && apt-get -y install git

Hinweis: Der Export DEBIAN_FRONTEND vermeidet Warnungen, wenn Sie mit Ihrem Container arbeiten.

Automatisierte Erstellung von Dev-Containern

Anstatt eine .devcontainer von Hand zu erstellen, fügt die Auswahl des Befehls Dev Containers: Dev Container-Konfigurationsdateien hinzufügen... aus der Befehlspalette (F1) die benötigten Dateien als Ausgangspunkt zu Ihrem Projekt hinzu, die Sie dann für Ihre Bedürfnisse weiter anpassen können.

Der Befehl ermöglicht es Ihnen, eine vordefinierte Containerkonfiguration aus einer Liste basierend auf dem Inhalt Ihres Ordners auszuwählen.

Die vordefinierten Containerkonfigurationen, aus denen Sie auswählen können, stammen aus unserem Index von Erstausrüstern und Community-Beiträgen, der Teil der Dev Container-Spezifikation ist. Wir hosten eine Reihe von Vorlagen als Teil der Spezifikation im Repository devcontainers/templates. Sie können den Ordner src dieses Repositories durchsuchen, um den Inhalt jeder Vorlage anzuzeigen.

Am Ende der Verwendung von Dev Containers: Dev Container-Konfigurationsdateien hinzufügen... werden Ihnen die verfügbaren Features angezeigt, d. h. Werkzeuge und Sprachen, die Sie einfach in Ihren Dev-Container einfügen können. Dev Containers: Container-Features konfigurieren ermöglicht es Ihnen, eine vorhandene Konfiguration zu aktualisieren.

Sie können auch eine vorhandene Dockerfile wiederverwenden.

Nachdem Sie nun eine devcontainer.json und eine Dockerfile haben, sehen wir uns den allgemeinen Prozess für die Bearbeitung von Containerkonfigurationsdateien an.

Vollständige Bearbeitungsschleife für die Containerkonfiguration

Das Bearbeiten Ihrer Containerkonfiguration ist einfach. Da das Neuerstellen eines Containers den Container auf seine ursprünglichen Inhalte zurücksetzt (mit Ausnahme Ihres lokalen Quellcodes), erstellt VS Code nicht automatisch neu, wenn Sie eine Containerkonfigurationsdatei (devcontainer.json, Dockerfile und docker-compose.yml) bearbeiten. Stattdessen gibt es mehrere Befehle, die verwendet werden können, um die Bearbeitung Ihrer Konfiguration zu vereinfachen.

Hier ist die typische Bearbeitungsschleife mit diesen Befehlen:

1. Beginnen Sie mit Dev Containers: Dev Container-Konfigurationsdateien hinzufügen... in der Befehlspalette (F1).
2. Bearbeiten Sie den Inhalt des Ordners .devcontainer nach Bedarf.
3. Probieren Sie es mit Dev Containers: Reopen in Container aus.
4. Wenn Sie einen Fehler sehen, wählen Sie im erscheinenden Dialog Ordner lokal öffnen.
5. Nachdem das Fenster neu geladen wurde, wird eine Kopie des Build-Protokolls in der Konsole angezeigt, damit Sie das Problem untersuchen können. Bearbeiten Sie den Inhalt des Ordners .devcontainer nach Bedarf. (Sie können auch den Befehl Dev Containers: Container-Protokoll anzeigen verwenden, um das Protokoll erneut anzuzeigen, wenn Sie es schließen.)
6. Führen Sie Dev Containers: Rebuild and Reopen in Container aus und springen Sie bei Bedarf zu Schritt 4.

Wenn Sie bereits einen erfolgreichen Build haben, können Sie den Inhalt des Ordners .devcontainer weiterhin nach Bedarf bearbeiten, wenn Sie mit dem Container verbunden sind, und dann Dev Containers: Rebuild Container in der Befehlspalette (F1) auswählen, damit die Änderungen wirksam werden.

Sie können Ihren Container auch durch die Verwendung des Befehls Dev Containers: Repository in Container-Volume klonen iterieren.

1. Beginnen Sie mit Dev Containers: Repository in Container-Volume klonen in der Befehlspalette (F1). Wenn das von Ihnen eingegebene Repository keine devcontainer.json enthält, werden Sie aufgefordert, einen Startpunkt auszuwählen.
2. Bearbeiten Sie den Inhalt des Ordners .devcontainer nach Bedarf.
3. Probieren Sie es mit Dev Containers: Rebuild Container aus.
4. Wenn Sie einen Fehler sehen, wählen Sie im erscheinenden Dialog In Wiederherstellungscontainer öffnen.
5. Bearbeiten Sie den Inhalt des Ordners .devcontainer nach Bedarf in diesem "Wiederherstellungscontainer".
6. Verwenden Sie Dev Containers: Reopen in Container und springen Sie zu Schritt 4, wenn Sie weiterhin Probleme haben.

Docker Compose verwenden

In einigen Fällen reicht eine einzige Containerumgebung nicht aus. Angenommen, Sie möchten Ihrer Konfiguration eine weitere komplexe Komponente hinzufügen, z. B. eine Datenbank. Sie könnten versuchen, sie direkt zur Dockerfile hinzuzufügen, oder Sie könnten sie über einen zusätzlichen Container hinzufügen. Glücklicherweise unterstützt Dev Containers Docker Compose-verwaltete Multi-Container-Konfigurationen.

Sie können entweder

1. Mit einem Dienst arbeiten, der in einer vorhandenen, unveränderten docker-compose.yml definiert ist.
2. Eine neue docker-compose.yml (oder eine Kopie einer vorhandenen) erstellen, die Sie zur Entwicklung eines Dienstes verwenden.
3. Erweitern Sie Ihre vorhandene Docker Compose-Konfiguration, um den Dienst zu entwickeln.
4. Verwenden Sie separate VS Code-Fenster, um gleichzeitig mit mehreren von Docker Compose definierten Diensten zu arbeiten.

Hinweis: Bei der Verwendung von Alpine Linux-Containern funktionieren einige Erweiterungen aufgrund von glibc-Abhängigkeiten im nativen Code der Erweiterung möglicherweise nicht.

VS Code kann so konfiguriert werden, dass benötigte Container für einen bestimmten Dienst in einer Docker Compose-Datei automatisch gestartet werden. Wenn Sie die konfigurierten Container bereits über die Befehlszeile gestartet haben, hängt sich VS Code an den ausgeführten Dienst, den Sie angegeben haben. Dies verleiht Ihrem Multi-Container-Workflow die gleichen schnellen Einrichtungs-Vorteile wie den oben beschriebenen Docker-Image- und Dockerfile-Workflows, während Sie bei Bedarf weiterhin die Befehlszeile verwenden können.

Um schnell zu beginnen, öffnen Sie den Ordner, mit dem Sie arbeiten möchten, in VS Code und führen Sie den Befehl Dev Containers: Dev Container-Konfigurationsdateien hinzufügen... in der Befehlspalette (F1) aus.

Sie werden aufgefordert, eine vordefinierte Containerkonfiguration aus unserem Index von Erstausrüstern und Community-Beiträgen in einer filterbaren Liste basierend auf dem Inhalt Ihres Ordners auszuwählen. Über die VS Code-Benutzeroberfläche können Sie eine der folgenden Vorlagen als Ausgangspunkt für Docker Compose auswählen:

• Vorhandenes Docker Compose - Enthält eine Reihe von Dateien, die Sie in ein bestehendes Projekt einfügen können und die eine docker-compose.yml-Datei im Stammverzeichnis Ihres Projekts wiederverwenden.
• Node.js & MongoDB - Ein Node.js-Container, der eine Verbindung zu einer MongoDB-Datenbank in einem anderen Container herstellt.
• Python & PostgreSQL - Ein Python-Container, der eine Verbindung zu PostgreSQL in einem anderen Container herstellt.
• Docker außerhalb von Docker Compose - Enthält die Docker CLI und veranschaulicht, wie Sie diese verwenden können, um auf Ihre lokale Docker-Installation von innerhalb eines Dev-Containers zuzugreifen, indem Sie den Docker-Unix-Socket als Volume mounten.

Nachdem Sie Ihre Auswahl getroffen haben, fügt VS Code die entsprechende .devcontainer/devcontainer.json- (oder .devcontainer.json-) Datei zum Ordner hinzu.

Sie können Ihre Konfiguration auch manuell erstellen. Um eine Docker Compose-Datei unverändert wiederzuverwenden, können Sie die Eigenschaften dockerComposeFile und service in .devcontainer/devcontainer.json verwenden.

Zum Beispiel

{
  "name": "[Optional] Your project name here",
  "dockerComposeFile": "../docker-compose.yml",
  "service": "the-name-of-the-service-you-want-to-work-with-in-vscode",
  "workspaceFolder": "/default/workspace/path/in/container/to/open",
  "shutdownAction": "stopCompose"
}

Lesen Sie die devcontainer.json-Referenz für Informationen zu anderen verfügbaren Eigenschaften wie workspaceFolder und shutdownAction.

Nachdem Sie eine .devcontainer/devcontainer.json-Datei zu Ihrem Ordner hinzugefügt haben, führen Sie den Befehl Dev Containers: Reopen in Container (oder Dev Containers: Open Folder in Container..., wenn Sie sich noch nicht in einem Container befinden) aus der Befehlspalette (F1) aus.

Wenn die Container noch nicht laufen, ruft VS Code in diesem Beispiel docker-compose -f ../docker-compose.yml up auf. Die Eigenschaft service gibt an, an welchen Dienst in Ihrer Docker Compose-Datei VS Code sich verbinden soll, nicht welcher Dienst gestartet werden soll. Wenn Sie sie manuell gestartet haben, wird VS Code an den von Ihnen angegebenen Dienst angehängt.

Sie können auch eine Entwicklungsversion Ihrer Docker Compose-Datei erstellen. Wenn Sie beispielsweise .devcontainer/docker-compose.devcontainer.yml hätten, würden Sie die folgende Zeile in devcontainer.json ändern:

"dockerComposeFile": "docker-compose.devcontainer.yml"

Ein besserer Ansatz ist jedoch oft, eine Kopie Ihrer Docker Compose-Datei zu vermeiden, indem Sie sie mit einer anderen erweitern. Wir werden die Erweiterung einer Docker Compose-Datei im nächsten Abschnitt behandeln.

Um zu vermeiden, dass der Container heruntergefahren wird, wenn der Standard-Containerbefehl fehlschlägt oder beendet wird, können Sie Ihre Docker Compose-Datei für den in devcontainer.json angegebenen Dienst wie folgt ändern:

# Overrides default command so things don't shut down after the process ends.
command: /bin/sh -c "while sleep 1000; do :; done"

Wenn Sie dies noch nicht getan haben, können Sie Ihren lokalen Quellcode in den Container einbinden, indem Sie die Volumes-Liste in Ihrer Docker Compose-Datei verwenden.

Zum Beispiel

volumes:
  # Mounts the project folder to '/workspace'. The target path inside the container
  # should match what your application expects. In this case, the compose file is
  # in a sub-folder, so you will mount '..'. You would then reference this path as the
  # 'workspaceFolder' in '.devcontainer/devcontainer.json' so VS Code starts here.
  - ..:/workspace:cached

Unter Linux müssen Sie jedoch möglicherweise einen Nicht-Root-Benutzer einrichten und angeben, wenn Sie einen Bind-Mount verwenden, da sonst alle von Ihnen erstellten Dateien Root gehören. Weitere Informationen finden Sie unter Hinzufügen eines Nicht-Root-Benutzers zu Ihrem Dev-Container. Damit VS Code als anderer Benutzer ausgeführt wird, fügen Sie Folgendes zu devcontainer.json hinzu:

"remoteUser": "your-user-name-here"

Wenn alle Prozesse als anderer Benutzer ausgeführt werden sollen, fügen Sie dies dem entsprechenden Dienst in Ihrer Docker Compose-Datei hinzu:

user: your-user-name-here

Wenn Sie keine benutzerdefinierte Dockerfile für die Entwicklung erstellen, möchten Sie möglicherweise zusätzliche Entwicklerwerkzeuge wie curl innerhalb des Containers des Dienstes installieren. Obwohl dies weniger effizient ist als die Hinzufügung dieser Werkzeuge zum Container-Image, können Sie die Eigenschaft postCreateCommand auch zu diesem Zweck verwenden.

Weitere Informationen zur Installation von Software finden Sie unter Zusätzliche Software installieren und weitere Informationen zur Eigenschaft postCreateCommand finden Sie in der devcontainer.json-Referenz.

Wenn Ihre Anwendung mit C++, Go oder Rust oder einer anderen Sprache erstellt wurde, die einen ptrace-basierten Debugger verwendet, müssen Sie auch die folgenden Einstellungen zu Ihrer Docker Compose-Datei hinzufügen:

# Required for ptrace-based debuggers like C++, Go, and Rust
cap_add:
- SYS_PTRACE
security_opt:
- seccomp:unconfined

Nachdem Sie Ihren Container zum ersten Mal erstellt haben, müssen Sie den Befehl Dev Containers: Rebuild Container ausführen, damit Aktualisierungen an devcontainer.json, Ihren Docker Compose-Dateien oder zugehörigen Dockerfiles wirksam werden.

Verwendung von localhost in Docker Compose

Sie können weitere Dienste zu Ihrer docker-compose.yml-Datei hinzufügen, wie in der Docker-Dokumentation beschrieben. Wenn Sie jedoch möchten, dass etwas, das in diesem Dienst läuft, im Container unter localhost verfügbar ist, oder den Dienst lokal weiterleiten möchten, stellen Sie sicher, dass Sie diese Zeile zur Dienstkonfiguration hinzufügen:

# Runs the service on the same network as the database container, allows "forwardPorts" in devcontainer.json function.
network_mode: service:db

Ein Beispiel für network_mode: service:db finden Sie im Beispiel für den Dev-Container von Node.js und MongoDB.

Erweiterung Ihrer Docker Compose-Datei für die Entwicklung

Das Verweisen auf eine vorhandene Bereitstellungs- / Nicht-Entwicklungs-docker-compose.yml hat einige potenzielle Nachteile.

Zum Beispiel

• Docker Compose beendet einen Container, wenn sein Einstiegspunkt beendet wird. Dies ist problematisch in Situationen, in denen Sie debuggen und Ihre App wiederholt neu starten müssen.
• Sie mappen möglicherweise auch nicht das lokale Dateisystem in den Container oder machen Ports für andere Ressourcen wie Datenbanken verfügbar, auf die Sie zugreifen möchten.
• Möglicherweise möchten Sie den Inhalt Ihres lokalen .ssh-Ordners in den Container kopieren oder die oben in Verwendung von Docker Compose beschriebenen ptrace-Optionen einstellen.

Sie können diese und andere ähnliche Probleme lösen, indem Sie Ihre gesamte Docker Compose-Konfiguration mit mehreren docker-compose.yml-Dateien erweitern, die Ihre primäre Datei überschreiben oder ergänzen.

Betrachten Sie beispielsweise diese zusätzliche Datei .devcontainer/docker-compose.extend.yml:

version: '3'
services:
  your-service-name-here:
    volumes:
      # Mounts the project folder to '/workspace'. While this file is in .devcontainer,
      # mounts are relative to the first file in the list, which is a level up.
      - .:/workspace:cached

    # [Optional] Required for ptrace-based debuggers like C++, Go, and Rust
    cap_add:
      - SYS_PTRACE
    security_opt:
      - seccomp:unconfined

    # Overrides default command so things don't shut down after the process ends.
    command: /bin/sh -c "while sleep 1000; do :; done"

Diese Datei kann auch zusätzliche Einstellungen bereitstellen, wie z. B. Portzuordnungen, nach Bedarf. Um sie zu verwenden, verweisen Sie in einer bestimmten Reihenfolge auf Ihre ursprüngliche docker-compose.yml-Datei sowie auf .devcontainer/docker-compose.extend.yml:

{
  "name": "[Optional] Your project name here",

  // The order of the files is important since later files override previous ones
  "dockerComposeFile": ["../docker-compose.yml", "docker-compose.extend.yml"],

  "service": "your-service-name-here",
  "workspaceFolder": "/workspace",
  "shutdownAction": "stopCompose"
}

VS Code verwendet dann automatisch beide Dateien beim Starten von Containern. Sie können diese auch selbst über die Befehlszeile wie folgt starten:

docker-compose -f docker-compose.yml -f .devcontainer/docker-compose.extend.yml up

Während die Eigenschaft postCreateCommand die Installation zusätzlicher Tools in Ihrem Container ermöglicht, möchten Sie in einigen Fällen möglicherweise eine spezielle Dockerfile für die Entwicklung haben. Sie können diesen Ansatz auch verwenden, um auf eine benutzerdefinierte Dockerfile speziell für die Entwicklung zu verweisen, ohne Ihre vorhandene Docker Compose-Datei zu ändern. Sie können beispielsweise .devcontainer/docker-compose.extend.yml wie folgt aktualisieren:

version: '3'
services:
  your-service-name-here:
      # Note that the path of the Dockerfile and context is relative to the *primary*
      # docker-compose.yml file (the first in the devcontainer.json "dockerComposeFile"
      # array). The sample below assumes your primary file is in the root of your project.
      build:
        context: .
        dockerfile: .devcontainer/Dockerfile
      volumes:
        - .:/workspace:cached
      command: /bin/sh -c "while sleep 1000; do :; done"

Herzlichen Glückwunsch! Sie haben nun einen Dev-Container in Visual Studio Code konfiguriert. Lesen Sie weiter, um zu erfahren, wie Sie Containerkonfigurationen mit Teamkollegen und verschiedenen Projekten teilen können.

Konfigurationsdateien zu einem Repository hinzufügen

Sie können eine benutzerdefinierte Dev Container-Vorlage für Ihr Projekt ganz einfach teilen, indem Sie devcontainer.json-Dateien zur Quellcodeverwaltung hinzufügen. Durch die Einbeziehung dieser Dateien in Ihr Repository wird jeder, der eine lokale Kopie Ihres Repositories in VS Code öffnet, automatisch aufgefordert, den Ordner in einem Container wieder zu öffnen, vorausgesetzt, die Dev Containers-Erweiterung ist installiert.

Zusätzlich zu den Vorteilen der Nutzung einer konsistenten Umgebung und Toolchain durch Ihr Team erleichtert dies auch neuen Mitwirkenden oder Teammitgliedern die schnelle Produktivität. Erstmalige Mitwirkende benötigen weniger Anleitung und haben weniger Probleme im Zusammenhang mit der Umgebungsaktualisierung.

Badge "In Dev Container öffnen" hinzufügen

Sie können auch ein Badge oder einen Link in Ihrem Repository hinzufügen, damit Benutzer Ihr Projekt einfach in Dev Containern öffnen können. Es wird die Dev Containers-Erweiterung bei Bedarf installiert, das Repository in ein Container-Volume klonen und den Dev-Container starten.

Beispielsweise würde ein Badge zum Öffnen von https://github.com/microsoft/vscode-remote-try-java wie folgt aussehen:

[![Open in Dev Containers](https://img.shields.io/static/v1?label=Dev%20Containers&message=Open&color=blue)](https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/microsoft/vscode-remote-try-java)

Sie können auch einen direkten Link "In Dev Container öffnen" einfügen:

If you already have VS Code and Docker installed, you can click the badge above or [here](https://vscode.dev/redirect?url=vscode://ms-vscode-remote.remote-containers/cloneInVolume?url=https://github.com/microsoft/vscode-remote-try-java) to get started. Clicking these links will cause VS Code to automatically install the Dev Containers extension if needed, clone the source code into a container volume, and spin up a dev container for use.

Alternative: Repository-Konfigurationsordner

In einigen Fällen möchten Sie möglicherweise eine Konfiguration für ein Repository erstellen, das Sie nicht kontrollieren oder das Ihrer Meinung nach keine Konfiguration enthalten sollte. Um diese Situation zu bewältigen, können Sie einen Speicherort auf Ihrem lokalen Dateisystem konfigurieren, um Konfigurationsdateien zu speichern, die automatisch basierend auf dem Repository abgerufen werden.

Aktualisieren Sie zunächst den Benutzereinstellung Dev > Containers: Repository Configuration Paths mit dem lokalen Ordner, den Sie zum Speichern Ihrer Repository-Container-Konfigurationsdateien verwenden möchten.

Im Einstellungseditor können Sie nach 'dev containers repo' suchen, um die Einstellung zu finden:

Platzieren Sie dann Ihre .devcontainer/devcontainer.json (und zugehörige Dateien) in einem Unterordner, der den Remote-Speicherort des Repositorys widerspiegelt. Wenn Sie beispielsweise eine Konfiguration für github.com/devcontainers/templates erstellen möchten, würden Sie die folgende Ordnerstruktur erstellen:

📁 github.com
    📁 devcontainers
        📁 templates
           📁 .devcontainer

Sobald sie eingerichtet sind, wird die Konfiguration automatisch abgerufen, wenn Sie einen der Dev Containers-Befehle verwenden. Sobald Sie sich im Container befinden, können Sie auch Dev Containers: Container-Konfigurationsdatei öffnen aus der Befehlspalette (F1) auswählen, um die zugehörige devcontainer.json-Datei zu öffnen und weitere Bearbeitungen vorzunehmen.

Der Pfad, der für die Suche nach der Konfiguration verwendet wird, wird aus der Ausgabe von git remote -v abgeleitet. Wenn die Konfiguration nicht gefunden wird, wenn Sie versuchen, den Ordner erneut in einem Container zu öffnen, überprüfen Sie das Protokoll Dev Containers: Container-Protokoll anzeigen in der Befehlspalette (F1) auf die Liste der überprüften Pfade.

Nächste Schritte

• An einen laufenden Container anhängen - Hängen Sie sich an einen bereits laufenden Docker-Container an.
• Fortgeschrittene Container – Finden Sie Lösungen für fortgeschrittene Container-Szenarien.
• devcontainer.json-Referenz – Überprüfen Sie das devcontainer.json-Schema.