Containerisierte Apps debuggen

Die Container Tools-Erweiterung bietet mehr Unterstützung für das Debuggen von Anwendungen in Containern, z. B. das Generieren von launch.json-Konfigurationen zum Anhängen eines Debuggers an Anwendungen, die in einem Container ausgeführt werden.

Die Container Tools-Erweiterung bietet einen docker-Debug-Konfigurationsanbieter, der verwaltet, wie VS Code eine Anwendung startet und/oder einen Debugger an die Anwendung in einem laufenden Container anhängt. Dieser Anbieter wird über Einträge in launch.json konfiguriert, wobei die Konfiguration für jede vom Anbieter unterstützte Anwendungsplattform spezifisch ist.

Die Container Tools-Erweiterung unterstützt derzeit das Debuggen von Node.js-, Python- und .NET-Anwendungen in Containern.

Voraussetzungen

Das Generieren oder Einfügen einer Startkonfiguration in launch.json reicht nicht aus, um einen Container zu erstellen und zu debuggen. Um eine Startkonfiguration für Container erfolgreich auszuführen, müssen Sie Folgendes haben:

Eine Dockerfile.
docker-build- und docker-run-Aufgaben in tasks.json.
Eine Startkonfiguration, die diese Aufgaben aufruft.

Wir empfehlen die Verwendung des Befehls Container: Docker-Dateien zum Arbeitsbereich hinzufügen..., um diese Elemente zu erstellen, falls keine dieser Assets bereits vorhanden ist. Wenn Sie bereits eine funktionierende Dockerfile haben, empfehlen wir die Verwendung des Befehls Container: Für Container-Debugging initialisieren, um eine Startkonfiguration und containerbezogene Aufgaben zu generieren.

Node.js

Weitere Informationen zum Debuggen von Node.js-Anwendungen in Containern finden Sie unter Node.js in einem Container debuggen.

Beispiel für eine launch.json-Konfiguration zum Debuggen einer Node.js-Anwendung

{
  "configurations": [
    {
      "name": "Containers: Node.js Launch",
      "type": "docker",
      "request": "launch",
      "preLaunchTask": "docker-run: debug",
      "platform": "node"
    }
  ]
}

Python

Weitere Informationen zum Debuggen von Python-Anwendungen in Containern finden Sie unter Python in einem Container debuggen.

Beispiel für eine launch.json-Konfiguration zum Debuggen einer Python-Anwendung

{
  "configurations": [
    {
      "name": "Containers: Python - Django",
      "type": "docker",
      "request": "launch",
      "preLaunchTask": "docker-run: debug",
      "python": {
        "pathMappings": [
          {
            "localRoot": "${workspaceFolder}",
            "remoteRoot": "/app"
          }
        ],
        "projectType": "django"
      }
    }
  ]
}

.NET

Sie können zwischen zwei Möglichkeiten wählen, Ihr Projekt in Containern zu erstellen und zu debuggen

Mit .NET SDK: Wenn Sie mit MSBuild vertraut sind oder Ihr Projekt ohne Dockerfile containerisieren möchten, ist dies die empfohlene Wahl.

Hinweis: Diese Option ist nur für .NET SDK 7 und höher verfügbar und verwendet den Befehl dotnet publish zum Erstellen des Images.
Mit einer Dockerfile: Wenn Sie es vorziehen, Ihr Projekt mit einer Dockerfile anzupassen, wählen Sie diese Option.

Weitere Details zu diesen beiden Optionen finden Sie unter .NET in Containern debuggen.

Beispiel für eine launch.json-Konfiguration zum Debuggen einer .NET-Anwendung mit Dockerfile

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Containers: .NET Launch",
      "type": "docker",
      "request": "launch",
      "preLaunchTask": "Run Container",
      "netCore": {
        "appProject": "${workspaceFolder}/project.csproj"
      }
    }
  ]
}

Referenz zur Konfiguration

Eigenschaft	Beschreibung
`containerName`	Name des für das Debugging verwendeten Containers.
`dockerServerReadyAction`	Optionen zum Starten eines Browsers zum Container. Ähnlich wie `serverReadyAction`, ersetzt aber Container-Ports durch Host-Ports.
`removeContainerAfterDebug`	Ob der Debug-Container nach dem Debugging entfernt werden soll.
`platform`	Die Zielplattform für die Anwendung. Kann `netCore` oder `node` sein.
`netCore`	Optionen für das Debuggen von .NET-Projekten in Containern.
`node`	Optionen für das Debuggen von Node.js-Projekten in Containern.
`python`	Optionen für das Debuggen von Python-Projekten in Containern.

Eigenschaften des `dockerServerReadyAction`-Objekts

Eigenschaft	Beschreibung
`action`	Die auszuführende Aktion, wenn das Muster gefunden wird. Kann `debugWithChrome` oder `openExternally` sein.
`containerName`	Der Containername, um den Host-Port abzugleichen.
`pattern`	Das Regex-Muster, nach dem in der Debug-Konsolenausgabe gesucht werden soll.
`uriFormat`	Das zu startende URI-Format.
`webRoot`	Der Stammordner, von dem Webseiten ausgeliefert werden. Wird nur verwendet, wenn `action` auf `debugWithChrome` gesetzt ist.

Eigenschaften des `node`-Objekts

Diese Eigenschaften sind die gleichen wie die in der VS Code-Dokumentation beschriebenen für das Anhängen eines Debuggers an Node.js-Anwendungen. Alle im node-Objekt übergebenen Eigenschaften werden an den Node.js-Debug-Adapter weitergegeben, auch wenn sie hier nicht speziell aufgeführt sind.

Eigenschaft	Beschreibung	Standard
`port`	Optional. Der zu verwendende Debug-Port.	`9229`
`address`	Optional. TCP/IP-Adresse des Debug-Ports.
`sourceMaps`	Optional. Aktivieren Sie Source Maps, indem Sie dies auf `true` setzen.
`outFiles`	Optional. Array von Glob-Mustern zum Auffinden generierter JavaScript-Dateien.
`autoAttachChildProcesses`	Optional. Verfolgen Sie alle Unterprozesse des Debuggees und hängen Sie automatisch die an, die im Debug-Modus gestartet werden.
`timeout`	Optional. Beim Neustarten einer Sitzung wird nach dieser Anzahl von Millisekunden aufgegeben.
`stopOnEntry`	Optional. Sofort anhalten, wenn das Programm gestartet wird.
`localRoot`	Optional. Der Stammverzeichnis von VS Code.	Das Stammverzeichnis des Arbeitsbereichs.
`remoteRoot`	Optional. Das Stammverzeichnis von Node innerhalb des Containers.	`/usr/src/app`
`smartStep`	Optional. Versuchen Sie, Code, der nicht auf Quellendateien abgebildet wird, automatisch zu überspringen.
`skipFiles`	Optional. Überspringen Sie automatisch Dateien, die von diesen Glob-Mustern abgedeckt werden.
`trace`	Optional. Aktivieren Sie die Diagnoseausgabe.

Eigenschaften des `python`-Objekts

Eigenschaft	Beschreibung	Standard
`host`	Der Host für das Remote-Debugging.
`port`	Der Port für das Remote-Debugging.	`5678`
`pathMappings`	Ordnet den Projektpfad zwischen der lokalen Maschine und dem Remote-Host zu.
`projectType`	Der Typ Ihres Python-Projekts: `flask` für Flask-Projekte, `django` für Django, `fastapi` für FastAPI und allgemein für andere. Der Projekttyp wird verwendet, um den Port und die für das Debugging verwendeten Befehle festzulegen.
`justMyCode`	Debuggen Sie nur vom Benutzer geschriebenen Code.
`django`	Django-Debugging.	`false`
`jinja`	Jinja-Vorlagen-Debugging (z. B. Flask).	`false`

Eigenschaften des `netCore`-Objekts

Die im netCore-Objekt übergebenen Eigenschaften werden im Allgemeinen an den .NET-Debug-Adapter weitergegeben, auch wenn sie hier nicht speziell aufgeführt sind. Die vollständige Liste der Debugger-Eigenschaften finden Sie in der Dokumentation der OmniSharp VS Code-Erweiterung.

Eigenschaft	Beschreibung
`appProject`	Das zu debuggende .NET-Projekt (.csproj, .fsproj usw.).

Nächste Schritte

Lesen Sie weiter, um mehr über Folgendes zu erfahren:

12/14/2023