Mit Cloud Code können Sie eine Anwendung, die in einem GKE-Cluster (Google Kubernetes Engine) bereitgestellt wird, mithilfe von skaffold debug debuggen.
Sie können Ihre Anwendung in einem lokalen Cluster (z. B. minikube oder Docker Desktop), in GKE oder bei einem anderen Cloud-Anbieter debuggen.
Mit dem Cloud Code-Debugging-Support müssen Sie keine manuelle Einrichtung vornehmen, z. B. Portweiterleitung einrichten oder sprachspezifische Debugging-Argumente einfügen. Für das Debugging ist eine Cloud Code-kompatible GKE-Anwendung erforderlich, die eine skaffold.yaml-Konfigurationsdatei und eine cloudcode.kubernetes-Startkonfiguration enthält.
GKE-Anwendung debuggen
So beginnen Sie mit dem Debuggen Ihrer GKE-Anwendung:
Klicken Sie in der Cloud Code-Statusleiste auf den Namen des aktiven Projekts.
Wählen Sie im angezeigten Menü „Schnellauswahl“ die Option Debuggen in Kubernetes aus.
Wenn Sie dazu aufgefordert werden, authentifizieren Sie Ihre Anmeldedaten, um eine Anwendung lokal auszuführen und zu debuggen.
Wenn Ihre Anwendung nicht die erforderliche
skaffold.yaml-Konfiguration odercloudcode.kubernetes-Startkonfiguration hat, hilft Cloud Code Ihnen bei der Einrichtung.Geben Sie an, ob Sie den aktuellen Kubernetes-Kontext zum Ausführen der Anwendung verwenden oder ob Sie zu einem bevorzugten Kontext wechseln möchten.
Wenn Sie einen Remote-Cluster als Kontext ausgewählt haben, wählen Sie bei Aufforderung eine Bildregistrierung aus, in die die Bilder übertragen werden sollen.
Wenn in Ihrem Projekt die Artifact Registry API aktiviert ist und mindestens ein Artifact Registry-Repository vorhanden ist, können Sie ein vorhandenes Artifact Registry-Repository auswählen.
In den folgenden Beispielen wird gezeigt, wie Sie für einige gängige Registries angeben, wo Container-Images gespeichert werden:
Artifact Registry REGION-docker.pkg.dev/PROJECT_ID/REPO_NAMEDocker Hub docker.io/ ACCOUNT
Achten Sie darauf, dass Sie richtig authentifiziert sind, wenn Sie ein privates Docker Hub-Repository verwenden.AWS-Container-Repository (ECR): AWS_ACCOUNT_ID.dkr.ecr.REGION.amazonaws.com/APPAzure Container Registry (ACR) ACR_NAME.azurecr.io/APPUm den endgültigen Namen des Image-Repositorys zu generieren, verkettet Cloud Code diese Image-Registry mit dem in den Kubernetes-Manifesten angegebenen Image-Namen. Diese Auswahl wird in Ihrer
cloudcode.kubernetesStartkonfiguration gespeichert (zu finden unter.vscode/launch.json).Weitere Informationen finden Sie im Leitfaden zur Image-Registry.
Anschließend erstellt Cloud Code Ihre Container, überträgt sie in die Registry, wendet Kubernetes-Konfigurationen auf den Cluster an und wartet auf den Rollout.
Nach Abschluss der Einführung leitet Cloud Code alle deklarierten Containerports automatisch an Ihren Computer weiter und zeigt die URLs im Ausgabefenster an. So können Sie Ihre Live-Anwendung durchsuchen.
Für jeden debugfähigen Container in Ihrer Anwendung werden Sie aufgefordert, das Verzeichnis im Remote-Container, in dem sich das zu debuggende Programm befindet, zu bestätigen oder einzugeben.
Alternativ können Sie die ESC-Taste drücken, um das Debugging des Containers zu überspringen.
Cloud Code hängt eine Debugging-Sitzung für jeden debugfähigen Container in der Anwendung an.
Sie können jetzt die gleichen 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 einem Live-Kubernetes-Cluster.
Wenn Sie eine Änderung an Ihrer Anwendung speichern, stellt Cloud Code Ihre Anwendung standardmäßig noch einmal bereit und richtet eine neue Debug-Sitzung ein. Sie können dieses Feature in der Startkonfiguration Ihres Projekts mit dem Flag
watchein- oder ausschalten.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.
Nach Abschluss Ihrer Sitzung können Sie die folgenden Kontextmenübefehle verwenden:
- Bereitstellungslogs öffnen:Öffnen Sie die Anwendungslogs einer bestimmten Bereitstellung mit dem Cloud Code-Log-Explorer.
- Dienst-URL öffnen: Öffnen Sie die Anwendungsdienst-URL eines bestimmten Dienstes in einem Webbrowser.
Wenn Sie den Beobachtungsmodus in Ihrer Startkonfiguration deaktiviert haben und Änderungen an Ihrer Anwendung vornehmen und die Anwendung neu erstellen und bereitstellen möchten, halten Sie im Bereich „Entwicklungssitzungen“ den Mauszeiger auf die Ausführungsaktion und klicken Sie dann auf
Anwendung neu erstellen und bereitstellen.Klicken Sie zum Beenden der Debugging-Sitzung in der Debug-Symbolleiste auf
Stop.Nach Beendigung der Debugging-Sitzung werden alle bereitgestellten Kubernetes-Ressourcen aus dem Cluster gelöscht.
Konfigurationsdetails
Cloud Code verarbeitet automatisch die folgenden Konfigurationsdetails für alle unterstützten Sprachen:
- Portweiterleitung des Debug-Ports, damit der Debugger hinzugefügt werden kann.
- Anhängen eines Debuggers an einen oder mehrere Debug-fähige Container in Ihrer Anwendung.
Wenn Ihre Anwendung mehrere debugfähige Container (Container, deren Sprache von Cloud Code-Debug unterstützt wird) in
skaffold.yamlkonfiguriert hat, wird an jeden debugfähigen Container ein Debugger angehängt. - Quellzuordnungsdefinitionen werden sitzungsübergreifend beibehalten. Sie können diese Definitionen anpassen, indem Sie Ihre
.vscode/launch.json-Datei direkt bearbeiten.
Cloud Code verarbeitet außerdem die folgenden sprachspezifischen Konfigurationsdetails:
Node.js
Neuschreiben des Einstiegspunkts, der aufgerufen werden soll:
node --inspect=localhost:9229
Python
Installieren Sie das ptvsd-Modul mithilfe eines Init-Containers und schreiben Sie den Einstiegspunkt für den Aufruf neu:
python -m ptvsd --host localhost --port 5678
Go
Installieren des dlv-Debuggers mit einem Init-Container und Umschreiben des Einstiegspunkts, sodass die gestartete Fehlerbehebungssitzung nur mit einem Fehlerbehebungsserver (im monitorlosen Modus) den Debug-Prozess beim Start fortsetzt, mehrere Client-Verbindungen akzeptiert und unter localhost:56268 empfängt:
dlv exec --headless --continue --accept-multiclient --listen=localhost:56268 --api-version=2, <app> --
Java
Hinzufügen einer Umgebung JAVA_TOOLS_OPTIONS mit der entsprechenden Java Debug Wire Protocol (JDWP)-Konfiguration, sodass der JDWP-Debugging-Agent eine Socket-Verbindung auf Port 5005 überwacht und die VM mit der Ausführung beginnen kann, bevor der Debugger angehängt wird:
jdwp=transport=dt_socket,server=y,suspend=n,address=5005,quiet=y
Weitere Informationen zum Debuggen mit skaffold debug finden Sie in der Dokumentation.
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>, wobeidebugPortaus der Konfiguration zum Anhängen stammt. Beispiel:CMD ["node", "--inspect=9229", "index.js"]
Python
- Das
ptvsd-Modul muss auf Ihrem Computer und in Ihrem Container installiert sein. - Starten Sie die Python-Anwendung über
ptvsd. Der angegebene Port muss mit dem FelddebugPortin der Attach-Konfiguration übereinstimmen. 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 sollte mit dem Attributwert
debugPortin der Attach-Konfiguration ü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 die JVM auf Ihrem Computer installiert ist.
Starten Sie die Java-Anwendung mit den folgenden Optionen, wobei
debugPortaus der Anhang-Konfiguration stammt.-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=
,quiet=y Wenn Sie die Java-Anwendung beispielsweise im Debug-Modus starten und am Port
debugPortauf eine Verbindung warten möchten, verwenden Sie folgenden Befehl: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 Sie
vsdbg, den .NET Core-Befehlszeilendebugger von Microsoft, in Ihrem Kubernetes-Container installiert haben.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
Attach-Konfiguration einrichten
Wenn Sie einen debugfähigen Container hinzufügen möchten, benötigen Sie eine Anhang-Konfiguration vom Typ cloudcode.kubernetes.
Datei „.vscode/launch.json“ hinzufügen
Wenn Ihr Projekt keine launch.json-Datei im Ordner .vscode hat, können Sie eine über den Debug-Bereich hinzufügen.
Klicken Sie in der Aktivitätsleiste auf
Ausführen und debuggen, um zum Debugging-Bereich zu gelangen.Wählen Sie im Drop-down-Menü Konfiguration hinzufügen aus.
Wählen Sie Cloud Code: Kubernetes als Umgebung 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.jsonfü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.
Fügen Sie der Datei „.vscode/launch.json“ eine Attach-Konfiguration hinzu.
So fügen Sie einer vorhandenen .vscode/launch.json-Datei eine neue Attach-Konfiguration hinzu:
- Öffnen Sie die Datei
launch.json. - Klicken Sie auf Konfiguration hinzufügen, um das Snippet-IntelliSense aufzurufen.
- Wenn Sie eine Attach-Konfiguration hinzufügen möchten, wählen Sie den Snippet Cloud Code: Attach to Kubernetes Pod für die von Ihnen verwendete Sprache aus.
- 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 | Im Container verwendeter Fehlerbehebungsport. |
| podSelector | Eine Reihe 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 eine typische 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 Ihren Kubernetes-Pod anhängen
Cloud Code für 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 debugfähigen Container und eine Attach-Konfiguration vom Typ cloudcode.kubernetes.
Informationen dazu, wie sich das Anhängen an einen Kubernetes-Pod vom Debuggen einer Kubernetes-Anwendung unterscheidet, finden Sie unter Unterschiede zwischen dem Anhängen eines Debuggers an einen Pod und dem Debuggen einer Kubernetes-Anwendung.
So hängen Sie einen Debugger an Ihren Kubernetes-Pod an:
- Klicken Sie in der Aktivitätsleiste auf
Ausführen und debuggen, um zum Debugging-Bereich zu gelangen.
Wählen Sie die Konfiguration aus und starten Sie sie, indem Sie
F5drücken.localhost:${debugPort}wird beim Debuggen andebugPortim Container weitergeleitet.
Die Debugging-Sitzung wurde eingerichtet. Sie können die Aufgaben ausführen, die Sie normalerweise beim Debuggen von lokalem Code ausführen, z. B. Haltepunkte festlegen und den Code schrittweise durchlaufen.
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.
Unterschiede zwischen dem Anhängen eines Debuggers an einen Pod und dem Debuggen einer Kubernetes-Anwendung
| An einen Kubernetes-Pod anhängen | Kubernetes-Anwendung debuggen |
|---|---|
| Behebt Fehler eines einzelnen Kubernetes-Pods. | Behebt Fehler in allen Debug-fähigen Containern der Anwendung. |
| 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 attach.
|
Verwendet die Konfiguration (.vscode/launch.json) vom Typ cloudcode.kubernetes und die Anfrage launch.Weitere Informationen finden Sie unter Konfigurationen für den Start und das 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 nicht sprachspezifisch. |
| Kein dedizierter Befehl. | Befehl Debugging auf Kubernetes. |
| 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. |
Nächste Schritte
- Verwenden Sie die Dateisynchronisierung und das Hot-Reloading, um die Entwicklung zu beschleunigen.
- Richten Sie eine Umgebung für die kontinuierliche Entwicklung in Cloud Code ein.
- Kubernetes-Logs in Cloud Code ansehen