Mit Cloud Code können Sie Fehler in Anwendungen beheben, die in einem
Google Kubernetes Engine-Cluster (GKE) durch Nutzung
skaffold debug
Sie können Fehler in Ihrer Anwendung auf einem lokalen Cluster (z. B. minikube oder Docker Desktop) GKE oder einem anderen Cloud-Anbieter.
Mit der Unterstützung für die Fehlerbehebung von Cloud Code müssen Sie keine manuelle Einrichtung wie die Einrichtung der Portweiterleitung oder das Einfügen von sprachspezifischen Debug-Argumenten vornehmen. Für die Fehlerbehebung ist ein Cloud Code-fähiger
GKE-Anwendung, die ein skaffold.yaml
enthält
Konfigurationsdatei und eine cloudcode.kubernetes
-Startkonfiguration.
Fehler in GKE-Anwendungen beheben
Führen Sie die folgenden Schritte aus, um mit dem Debuggen Ihrer GKE-Anwendung zu beginnen: Schritte:
Klicken Sie in der Cloud Code-Statusleiste auf den Namen des aktiven Projekts.
Wählen Sie im angezeigten Menü „Schnellauswahl“ die Option Unter Kubernetes debuggen aus.
Wenn Sie dazu aufgefordert werden, authentifizieren Sie Ihre Anmeldedaten, um eine Anwendung lokal.
Wenn Ihre Anwendung keine erforderliche Skaffold-Konfiguration oder
cloudcode.kubernetes
-Startkonfiguration hat, unterstützt Cloud Code Sie 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 entsprechender Aufforderung ein Image aus Registry, in die die Images übertragen werden sollen. Wenn Sie Container Registry verwenden, Rufen Sie eine vorhandene Registry auf oder geben Sie den Namen der zu erstellenden Registry an. Wenn Ihr Projekt Artifact Registry API aktiviert und mindestens ein Artifact Registry-Repository kann ein vorhandenes Artifact Registry-Repository suchen und 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-name} Container Registry gcr.io/{project_id} Docker Hub docker.io/{account}
Stellen Sie sicher, dass Sie ordnungsgemäß authentifiziert wenn Sie ein privates Docker Hub-Repository verwenden.AWS-Container-Repository (ECR): {aws_account_id}.dkr.ecr.{region}.amazonaws.com/{my-app} Azure Container Registry (ACR) {my_acr_name}.azurecr.io/{my-app} Um 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 ist in deinem
cloudcode.kubernetes
gespeichert Startkonfiguration (gefunden in.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 drücken, um das Debugging für den Container zu überspringen.
Cloud Code hängt für jedes Debug-fähige Gerät eine Debug-Sitzung an. Container in der Anwendung.
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
watch
ein- 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:
- Open Deployment Logs (Bereitstellungslogs öffnen): Die Anwendungslogs eines bestimmten mit dem Cloud Code-Log-Explorer bereitstellen.
- Dienst-URL öffnen: Öffnen Sie die Anwendungsdienst-URL eines bestimmten Dienstes in einem Webbrowser.
Wenn Sie den Überwachungsmodus in der Startkonfiguration deaktiviert haben und Sie Änderungen an Ihrer Anwendung vornehmen und die Anwendung neu erstellen und noch einmal bereitstellen möchten, pausieren Sie im Bereich „Entwicklungssitzungen“ die Ausführungsaktion und klicken Sie dann auf Anwendung neu erstellen und neu 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 auf Basis von Skaffold verarbeitet 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 über mehrere debugfähige Container verfügt (Container, deren
Sprache wird von Cloud Code Debug unterstützt), die in
skaffold.yaml
gesetzt ist, wird an jeden Debug-fähigen Container ein Debugger angehängt. - Quellzuordnungsdefinitionen sitzungsübergreifend beibehalten; können Sie diese anpassen,
indem Sie die Datei
.vscode/launch.json
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 Debugging auf Skaffold finden Sie in der skaffold debug
-Dokumentation.
Container einrichten
Folgen Sie der Anleitung für die verwendete Sprache, um den Container für das Debugging vorzubereiten:
Node.js
- Node.js-Anwendung mit
--inspect=<debugPort>
starten wobeidebugPort
aus dem Konfiguration anhängen. Beispiel:CMD ["node", "--inspect=9229", "index.js"]
Python
- Stellen Sie sicher, dass Sie
Modul
ptvsd
die auf Ihrem Computer und in Ihrem Container installiert sind. - Starten Sie die Python-Anwendung über
ptvsd
. Entspricht dem angegebenen Port für im FelddebugPort
im Konfiguration anhängen. Beispiel:CMD ["python", "-m", "ptvsd", "--port", "
", "app.py"]
Go
- Stellen Sie sicher, dass Sie
dlv
-Paket die auf Ihrem Computer und in Ihrem Go-Container installiert sind. Starten Sie Ihre Go-Anwendung über
dlv debug
Der im Startbefehl angegebene Port muss mit dem Port des
debugPort
-Attributwert im Konfiguration anhängen. 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 eine Verbindung:ENTRYPOINT ["java","-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=<debugPort>,quiet=y", "-jar", "my-app-1.0.jar"]
.NET Core
Sie benötigen die
vsdbg
, den .NET Core- Befehlszeilen-Debugger von Microsoft, installiert auf Ihrem Kubernetes-Container.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
Anhang-Konfiguration einrichten
Wenn Sie einen debugfähigen Container hinzufügen möchten, benötigen Sie eine Anhang-Konfiguration vom Typ cloudcode.kubernetes
.
Vscode/launch.json-Datei hinzufügen
Wenn Ihr Projekt keine launch.json
-Datei in .vscode
hat
können Sie über den Debug-Bereich
einen neuen Ordner hinzufügen.
Klicken Sie in der Aktivitätsleiste auf Ausführen und debuggen, um zum Debug-Bereich zu gelangen.
Wählen Sie im Drop-down-Menü die Option Konfiguration hinzufügen aus.
Wählen Sie Cloud Code: Kubernetes als Umgebung aus.
Wählen Sie die Option Attach to Kubernetes Pod (An Kubernetes-Pod anhängen) aus.
Wählen Sie die verwendete Programmiersprache aus.
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 von übereinstimmen für Ihr Projekt. Weitere Informationen zu Konfigurationsattributen finden Sie unter Konfigurationsattribute:
Anhangskonfiguration zur .vscode/launch.json-Datei hinzufügen
So fügen Sie einer vorhandenen .vscode/launch.json
-Datei eine neue Anhangskonfiguration hinzu:
- Öffnen Sie die Datei
launch.json
. - Klicken Sie zum Aufrufen des Snippets auf Konfiguration hinzufügen.
- Wählen Sie zum Hinzufügen einer Anhangskonfiguration das Symbol Cloud Code: Attach to Kubernetes Pod (Cloud Code: An Kubernetes Pod anhängen) für die verwendete Sprache verwenden.
- Aktualisieren Sie die Attribute in der Konfiguration, damit sie mit denen Ihrer Projekt arbeiten. Weitere Informationen zu Konfigurationsattributen finden Sie unter Konfigurationsattribute:
Konfigurationsattribute
Attribut | Beschreibung |
---|---|
debugPort | Im Container verwendeter Fehlerbehebungsport. |
podSelector | Satz von Schlüssel/Wert-Paaren, die zum Auswählen des Pods für die Fehlerbehebung verwendet werden. Weitere Informationen
finden Sie in der
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 den Kubernetes-Pod 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 eine
Debug-fähigen Container und ein
attach configuration vom Typ
cloudcode.kubernetes
Informationen dazu, wie sich das Anhängen an einen Kubernetes-Pod von Fehlerbehebung für eine Kubernetes-Anwendung finden Sie unter Unterschiede zwischen dem Anhängen eines Debuggers an einen Pod und dem Debuggen einer Kubernetes-Anwendung
Führen Sie die folgenden Aufgaben aus, um einen Debugger an Ihren Kubernetes-Pod anzuhängen:
- Um den Debug-Bereich aufzurufen, klicken Sie auf Ausführen und Fehler beheben in der Aktivitätsleiste.
Wählen Sie die Konfiguration aus und starten Sie sie, indem Sie
F5
drücken.localhost:${debugPort}
wird andebugPort
am Port weitergeleitet des Containers während der Fehlerbehebung.
Die Fehlerbehebungssitzung ist jetzt erfolgreich eingerichtet. Sie können die Aufgaben wie Sie normalerweise beim Debuggen von lokalem Code die den Code durchgehen.
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.
Unterschied zwischen dem Anhängen eines Debuggers an einen Pod und dem Debugging einer Kubernetes-Anwendung
An einen Kubernetes-Pod anhängen | Fehler in einer Kubernetes-Anwendung beheben |
---|---|
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 fordert die Anfrage attach an.
|
Verwendet die Konfiguration (.vscode/launch.json) vom Typ cloudcode.kubernetes und fordert launch 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 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 Dateisynchronisierung und Hot Refresh um die Entwicklung zu beschleunigen.
- Richten Sie ein kontinuierliche Entwicklung in Cloud Code erstellen.
- Kubernetes-Logs in Cloud Code aufrufen