Fehler in Kubernetes-Anwendungen mit Cloud Code for VS Code beheben

Mit Cloud Code können Sie mithilfe von skaffold debug eine Anwendung debuggen, die in einem GKE-Cluster (Google Kubernetes Engine) bereitgestellt wurde.

Sie können Fehler in Ihrer Anwendung auf einem lokalen Cluster (z. B. Minikube oder Docker Desktop), GKE oder einem anderen Cloud-Anbieter beheben.

Mit der Debugging-Unterstützung von Cloud Code müssen Sie keine manuelle Einrichtung wie das Einrichten der Portweiterleitung oder das Einfügen sprachspezifischer Debug-Argumente vornehmen. Für die Fehlerbehebung ist eine Cloud Code-fähige GKE-Anwendung erforderlich, die eine skaffold.yaml-Konfigurationsdatei und eine cloudcode.kubernetes-Startkonfiguration enthält.

GKE-Anwendung debuggen

So starten Sie das Debugging für Ihre GKE-Anwendung:

  1. Klicken Sie in der Cloud Code-Statusleiste auf den Namen des aktiven Projekts.

    Name des aktiven Projekts in der Statusleiste

  2. Wählen Sie im angezeigten Schnellauswahl-Menü die Option Debug on Kubernetes aus.

  3. Wenn Sie dazu aufgefordert werden, authentifizieren Sie Ihre Anmeldedaten, um eine Anwendung lokal auszuführen und Fehler zu beheben.

  4. Wenn Ihre Anwendung nicht die erforderliche Skaffold- oder cloudcode.kubernetes-Startkonfiguration hat, unterstützt Sie Cloud Code bei der Einrichtung.

  5. 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.

  6. Wenn Sie einen Remote-Cluster als Kontext ausgewählt haben, wählen Sie bei entsprechender Aufforderung eine Image-Registry aus, in die die Images übertragen werden sollen. Wenn Sie Container Registry verwenden, können Sie zu einer vorhandenen Registry suchen oder den Namen einer zu erstellenden Registry angeben. Wenn für Ihr Projekt die Artifact Registry API aktiviert und mindestens ein Artifact Registry-Repository aktiviert ist, können Sie 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}
    Wenn Sie ein privates Docker Hub-Repository verwenden, müssen Sie ordnungsgemäß authentifiziert sein.
    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 wird in Ihrer cloudcode.kubernetes-Startkonfiguration gespeichert (in .vscode/launch.json zu finden).

    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.

  7. 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 die Fehlerbehebung im Container zu überspringen.

    Remote-Root-Aufforderung

    Cloud Code hängt für jeden debugfähigen Container in der Anwendung eine Debug-Sitzung 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 watch ein- oder ausschalten.

  8. 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.

  9. Nach Abschluss Ihrer Sitzung können Sie die folgenden Kontextmenübefehle verwenden:

    • Deployment-Logs ö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.
  10. Wenn Sie den Überwachungsmodus in der Startkonfiguration deaktiviert haben und Änderungen an Ihrer Anwendung vornehmen sowie die Anwendung neu erstellen und noch einmal bereitstellen möchten, halten Sie im Bereich „Entwicklungssitzungen“ die Ausführungsaktion an und klicken Sie dann auf Symbol: Neu erstellen und neu bereitstellen Anwendung neu erstellen und noch einmal bereitstellen.

  11. Klicken Sie zum Beenden der Debugging-Sitzung in der Debug-Symbolleiste auf Symbol für Debug-Stopp Stop.

    Nach Beendigung der Debugging-Sitzung werden alle bereitgestellten Kubernetes-Ressourcen aus dem Cluster gelöscht.

Konfigurationsdetails

Cloud Code verwendet Skaffold 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 für Ihre Anwendung in skaffold.yaml mehrere debugfähige Container (Container, deren Sprache von Cloud Code Debug unterstützt wird) konfiguriert sind, wird an jeden debug-fähigen Container ein Debugger angehängt.
  • Definitionen der Quellzuordnung über mehrere Sitzungen hinweg beibehalten; Sie können diese Definitionen 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

Einfach loslegen (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

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

Python

  • Das Modul ptvsd muss auf Ihrem Computer und in Ihrem Container installiert sein.
  • 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"]
    

Einfach loslegen (Go)

  • Das Paket dlv muss auf Ihrem Computer und in Ihrem Go-Container installiert sein.
  • 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 Debug-Modus und überwachen 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

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

    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

Anhangskonfiguration 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 im Ordner .vscode Ihres Projekts keine launch.json-Datei vorhanden ist, können Sie diese über den Bereich „Fehlerbehebung“ hinzufügen.

  1. Klicken Sie in der Aktivitätsleiste auf Fehlerbehebungssymbol Ausführen und Fehler beheben, um den Bereich „Fehlerbehebung“ aufzurufen.

  2. Wählen Sie im Drop-down-Menü Konfiguration hinzufügen aus.

  3. Wählen Sie als Umgebung Cloud Code: Kubernetes aus.

    Cloud Code Kubernetes als Umgebung festlegen

  4. Wählen Sie die Option An Kubernetes-Pod anhängen aus.

    Kubernetes-Konfigurationsoption auswählen

  5. Wählen Sie die von Ihnen verwendete Programmiersprache aus.

    Dadurch wird eine Datei launch.json für Ihr Projekt erstellt und geöffnet und eine Anhangskonfiguration erstellt.

  6. Aktualisieren Sie die Konfigurationsattribute in der Datei launch.json, damit sie mit denen Ihres Projekts übereinstimmen. Weitere Informationen zu Konfigurationsattributen finden Sie unter Konfigurationsattribute.

Der Datei „.vscode/launch.json“ eine Anhangskonfiguration hinzufügen

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

  1. Öffnen Sie die Datei launch.json.
  2. Klicken Sie auf Konfiguration hinzufügen, um das Intellisense-Snippet aufzurufen.
  3. Wählen Sie zum Hinzufügen einer Anhangskonfiguration das Snippet Cloud Code: An Kubernetes Pod anhängen für die verwendete Sprache aus.
  4. 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 Fehlerbehebungsport für den Container.
podSelector Satz von Schlüssel/Wert-Paaren, die zur Auswahl 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 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 einen Debug-fähigen Container und eine Anhangskonfiguration 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 beim Anhängen eines Debuggers an einen Pod vom Debuggen einer Kubernetes-Anwendung.

Führen Sie die folgenden Aufgaben aus, um einen Debugger an Ihren Kubernetes-Pod anzuhängen:

  1. Klicken Sie in der Aktivitätsleiste auf Fehlerbehebungssymbol Ausführen und Fehler beheben, um den Bereich „Fehlerbehebung“ aufzurufen.
  2. Wählen Sie die Konfiguration aus und starten Sie sie, indem Sie F5 drücken.

    • localhost:${debugPort} wird während der Fehlerbehebung an debugPort des Containers weitergeleitet.

    Die Debugging-Sitzung wurde jetzt 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.

  3. 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.

  4. Klicken Sie zum Beenden der Debugging-Sitzung in der Debug-Symbolleiste auf Symbol für Debug-Stopp Stop.

Unterschiede zwischen dem Anhängen eines Debuggers an einen Pod vom Debugging einer Kubernetes-Anwendung

An Kubernetes-Pod anhängen Kubernetes-Anwendung debuggen
Behebt Fehler in einem einzelnen Kubernetes-Pod. Behebt Fehler in allen debugfähigen Containern in 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 Konfiguration (.vscode/launch.json) vom Typ cloudcode.kubernetes und Anfrage attach. Verwendet Konfiguration (.vscode/launch.json) vom Typ cloudcode.kubernetes und Anfrage launch.
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. Debug on Kubernetes-Befehl.
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

Support anfragen

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