Debugger an einen Kubernetes-Pod in Cloud Code für VS Code anhängen

Cloud Code for VS Code unterstützt das Anhängen eines Debuggers an einen Kubernetes-Pod für Node.js, Python, Go, Java und .NET. Sie benötigen lediglich einen Debug-Container und eine Anhangskonfiguration vom Typ cloudcode.kubernetes.

Informationen darüber, wie sich das Anhängen an einen Kubernetes-Pod vom Debugging einer Kubernetes-Anwendung unterscheidet, finden Sie unter Anhängen an einen Kubernetes-Pod im Vergleich zum Debugging einer Kubernetes-Anwendung.

Container einrichten

Folgen Sie der Anleitung für die verwendete Sprache, um den Container für das Debugging vorzubereiten:

Node.js

Starten Sie die Node.js-Anwendung mit --inspect=<debugPort>, wobei debugPort aus der Anhangskonfiguration stammt. Beispiel: CMD ["node", "--inspect=9229", "index.js"]

Python

Achten Sie darauf, dass das ptvsd-Modul auf Ihrem Computer und in Ihrem Container installiert ist.
Starten Sie die Python-Anwendung über ptvsd. Ordnen Sie den angegebenen Port dem Feld debugPort in der Anhangskonfiguration zu. Beispiel:
```
CMD ["python", "-m", "ptvsd", "--port", "", "app.py"]
```

Go

Prüfen Sie, ob das dlv-Paket auf Ihrem Computer und in Ihrem Go-Container installiert ist.
Starten Sie Ihre Go-Anwendung über dlv debug.

Der im Startbefehl angegebene Port muss mit dem Attributwert debugPort in der Anhangskonfiguration übereinstimmen. Beispiel:
```
CMD ["dlv", "debug", "--headless", "--listen=:<debugPort>", "--log"]
```
Tipp zur Fehlerbehebung: Beim Beheben von Fehlern in einer Go-Anwendung hält die Anwendung an und wartet auf das Hinzufügen eines Debuggers. Fügen Sie einen Debugger hinzu, damit der Dienst gestartet werden kann.

Java

Prüfen Sie, ob JVM auf Ihrem Computer installiert ist.
Starten Sie die Java-Anwendung mit den folgenden Optionen, wobei debugPort aus der Anhang-Konfiguration stammt.
```
-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=,quiet=y
```
So starten Sie beispielsweise die Java-Anwendung im Fehlerbehebungsmodus und beobachten Port debugPort auf Verbindung:
```
ENTRYPOINT ["java","-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=<debugPort>,quiet=y", "-jar", "my-app-1.0.jar"]
```

.NET Core

Achten Sie darauf, dass auf Ihrem Kubernetes-Container der .NET Core-Befehlszeilen-Debugger von Microsoft vsdbg installiert ist.

Beispiel:

RUN apt-get update 

  && apt-get install -y --no-install-recommends unzip 

  && apt-get install -y procps 

  && rm -rf /var/lib/apt/lists/* 

  && curl -sSL https://aka.ms/getvsdbgsh | bash /dev/stdin -v latest -l /dbg/netcore/vsdbg

Eine Anhang-Konfiguration einrichten

Wenn Sie einen debugfähigen Container hinzufügen möchten, benötigen Sie eine Anhang-Konfiguration vom Typ cloudcode.kubernetes.

Projekte ohne .vscode/launch.json-Datei

Wenn im Projekt .vscode keine launch.json-Datei vorhanden ist, können Sie eine Datei über das Debug-Steuerfeld hinzufügen.

Klicken Sie in der Aktivitätsleiste auf Ausführen und debuggen, um den Bereich „Fehlerbehebung“ aufzurufen.
Wählen Sie im Drop-down-Menü Konfiguration hinzufügen aus.
Wählen Sie als Umgebung Cloud Code: Kubernetes aus.
Wählen Sie die Option An Kubernetes-Pod anhängen aus.
Wählen Sie die Programmiersprache aus, die Sie verwenden.

Dadurch wird eine Datei launch.json für Ihr Projekt erstellt und geöffnet und eine Anhangskonfiguration erstellt.
Aktualisieren Sie die Konfigurationsattribute in der Datei launch.json, damit sie mit denen Ihres Projekts übereinstimmen. Weitere Informationen zu Konfigurationsattributen finden Sie unter Konfigurationsattribute.

Projekte mit der Datei ".vscode/launch.json"

So fügen Sie einer vorhandenen .vscode/launch.json-Datei eine neue Anhangkonfiguration hinzu:

Öffnen Sie die Datei launch.json.
Klicken Sie auf Konfiguration hinzufügen, um das Snippet Intellisense aufzurufen.
Wählen Sie das Snippet Cloud Code: Anhängen an Kubernetes-Pod für die Sprache aus, die Sie hinzufügen möchten.
Aktualisieren Sie die Attribute in der Konfiguration, damit sie mit denen Ihres Projekts übereinstimmen. Weitere Informationen zu Konfigurationsattributen finden Sie unter Konfigurationsattribute.

Konfigurationsattribute

Attribut	Beschreibung
debugPort	Debugging-Port für den Container.
podSelector	Satz von Schlüssel/Wert-Paaren, die zum Auswählen des Debug-Pods verwendet werden. Weitere Informationen finden Sie im Leitfaden zu Selektoren. Das folgende Beispiel zeigt einen typischen „podSelector“: `"podSelector": { "app": <deployment-name> }`
localRoot	Pfad zum lokalen Verzeichnis, in dem das Programm enthalten ist, für das Sie die Fehlerbehebung durchführen. Die Standardeinstellung ist ${workspaceFolder}.
remoteRoot	Absoluter Pfad zum Remote-Verzeichnis (im Kubernetes-Container) mit dem Programm, in dem Sie die Fehlerbehebung ausführen.

Debugger an einen Kubernetes-Pod anhängen

Nachdem Sie die Konfiguration und den Container eingerichtet haben:

Klicken Sie in der Aktivitätsleiste auf Ausführen und debuggen, um den Bereich „Fehlerbehebung“ aufzurufen.
Wählen Sie die Konfiguration aus und starten Sie sie, indem Sie F5 drücken.
- localhost:${debugPort} wird während der Fehlerbehebung im Container an debugPort weitergeleitet.
Die Debug-Sitzung wurde erfolgreich eingerichtet. Sie können die Aufgaben ausführen, die Sie normalerweise beim Debuggen von lokalem Code ausführen, z. B. das Festlegen von Haltepunkten und das Durchlaufen von Code.
In der Debugging-Seitenleiste können Sie Variablen und Stack-Informationen prüfen. Verwenden Sie die Debug Console im Debugger im unteren Bereich, um mit der Debugging-Sitzung zu interagieren.
Klicken Sie zum Beenden der Debugging-Sitzung in der Debug-Symbolleiste auf Stop.

Anhängen an einen Kubernetes-Pod im Vergleich zum Debugging einer Kubernetes-Anwendung

An einen Kubernetes-Pod anhängen	Kubernetes-Anwendung debuggen
Fehler in einem einzelnen Kubernetes-Pod werden behoben.	Fehler in allen Debug-fähigen Containern in der Anwendung werden behoben.
Die Anwendung muss im Kubernetes-Pod ausgeführt werden, bevor die Fehlerbehebung erfolgt.	Führt die Anwendung im Kubernetes-Cluster aus und hängt den Debugger an.
Verwendet die Konfiguration (.vscode/launch.json) vom Typ 'cloudcode.kubernetes' und die Anfrage 'attachment'.	Verwendet die Konfiguration (.vscode/launch.json) vom Typ „cloudcode.kubernetes“ und fordert „starten“ an. Weitere Informationen finden Sie unter Konfigurationen starten und anhängen.
Beispielkonfiguration: { "name": "Attach to Kubernetes Pod (NodeJS)", "type": "cloudcode.kubernetes", "request": "attach", "language": "Node", "debugPort": 9229, "podSelector": { "app": "hello-world" }, "localRoot": "${workspaceFolder}", "remoteRoot": "/app" }	Beispielkonfiguration: { "name": "Run/Debug on Kubernetes", "type": "cloudcode.kubernetes", "request": "launch", "skaffoldConfig": "${workspaceFolder}/skaffold.yaml", "watch": true, "cleanUp": true, "portForward": true }
Diese Konfiguration kann nicht zum Ausführen der Anwendung verwendet werden.	Diese Konfiguration kann zum Ausführen oder Debuggen der Anwendung verwendet werden.
Diese Konfiguration ist sprachspezifisch.	Diese Konfiguration ist sprachunabhängig.
Kein eigener Befehl.	Debug on Kubernetes ausführen.
Der Watch-Modus ist nicht verfügbar, also starten Sie den Debugger manuell, nachdem Sie Änderungen vorgenommen haben.	Im Überwachungsmodus kann Cloud Code den Debugger neu starten, nachdem Sie die Änderungen gespeichert haben.

Support

Wenn Sie uns Feedback geben möchten, können Sie Probleme auf GitHub melden oder eine Frage in Stack Overflow stellen.