Verwenden Sie den Visual Studio-Debugger mit der in Kubernetes ausgeführten ASP.NET Core-Webanwendung?

Unser Team möchte den Visual Studio-Debugger für bereitgestellte Instanzen unserer ASP.NET-Anwendung in unserem internen Kubernetes-Cluster ausführen können. Ich muss herausfinden, wie ich das Rätsel beenden kann, bin aber mit Visual Studio 2019 nicht sehr vertraut.

• Das Docker-Image wird mit den offiziellen .NET Core-Images kompiliert und mit / vsdbg mit der neuesten Version (die --attach nicht unterstützt) gefüllt.
• Visual Studio funktioniert mit meinem Docker Desktop.
• Kubectl ist korrekt konfiguriert. Ich kann entweder den in Docker Desktop enthaltenen Kubernetes-Cluster oder unseren internen Kubernetes-Cluster zum Testen verwenden.
• Azure ist derzeit keine Option. Ich verstehe aus der Dokumentation, dass Microsoft dies von mir bevorzugt.

Wie sollte ich Visual Studio konfigurieren, um dies zu tun?

OK. Fangen wir an. Stellen Sie zunächst sicher, dass Sie Ihre App im Debug-Modus veröffentlicht haben! Ich bevorzuge es, eine neue mehrstufige Docker-Funktion zum Erstellen meiner Bilder zu verwenden, damit ich am Ende einer Erstellungsphase in Dockerfile so etwas schreibe:

RUN dotnet publish -c Debug -o ./results

Um Bilder an Minikube zu senden, verwende ich die lokale Container-Registrierung wie hier beschrieben. Aber Sie können es so machen, wie Sie es normalerweise tun. Wenn Sie Ihren Container in Betrieb haben, können wir damit beginnen, ihn zu hacken. Ich werde Powershell für diesen Zweck verwenden, aber das gleiche kann leicht in jeder anderen Terminalsprache umgeschrieben werden. Sie können dem Tutorial Schritt für Schritt folgen und die Befehle in Ihrem Terminal einzeln ausführen, um bei Bedarf die Werte von var mit dem Befehl echo zu überprüfen. In Ihrer * .yml-Datei sollte ein Selektor ungefähr so ​​beschrieben sein:

selector:
  matchLabels:
    app: mywebapp

Nehmen Sie es und definieren Sie mit ihm eine $ Selector-Variable in Ihrem Powershell-Terminal:

$Selector = 'app=mywebapp'

Sie müssen einen Pod finden, in dem Ihre containerisierte Anwendung über die Auswahl ausgeführt wird:

$pod = kubectl get pods --selector=$Selector -o jsonpath='{.items[0].metadata.name}';

Angenommen, Sie haben nur noch einen Container im Pod, können Sie Befehle für diesen Container ausführen. Standardmäßig ist in vsdbg kein Container installiert. Installieren Sie es also wie folgt:

kubectl exec $pod -i -- apt-get update;
kubectl exec $pod -i -- apt-get install -y unzip;
kubectl exec $pod -i -- curl -sSL https://aka.ms/getvsdbgsh -o '/root/getvsdbg.sh';
kubectl exec $pod -i -- bash /root/getvsdbg.sh -v latest -l /vsdbg;

Als nächstes müssen Sie die PID Ihrer App im Container finden:

$prid = kubectl exec $pod -i -- pidof -s dotnet;

Normalerweise ist es gleich 1, aber es ist besser, weniger Annahmen zu treffen. Das ist es. Jetzt können Sie einen Debugger starten:

kubectl exec $pod -i -- /vsdbg/vsdbg --interpreter=mi --attach $prid;

Vergessen Sie nicht, die folgenden Befehle auszuführen, bevor Sie das Fenster schließen, da Ihre App sonst für immer hängen bleibt:

-target-detach
-gdb-exit

Lassen Sie uns alles zusammenfügen, ein wiederverwendbares Skript erstellen und es irgendwo in der Nähe der Wurzeln speichern, da Sie es mit all Ihren ASP.NET Core-Projekten verwenden können:

param(
    # the selector from your yml file
    #  selector:
    #    matchLabels:
    #      app: myweb
    # -Selector app=myweb
    [Parameter(Mandatory=$true)][string]$Selector
)

Write-Host '1. searching pod by selector:' $Selector '...';
$pod = kubectl get pods --selector=$Selector -o jsonpath='{.items[0].metadata.name}';

Write-Host '2. installing updates ...';
kubectl exec $pod -i -- apt-get update;

Write-Host '3. installing unzip ...';
kubectl exec $pod -i -- apt-get install -y --no-install-recommends unzip;

Write-Host '4. downloading getvsdbgsh ...';
kubectl exec $pod -i -- curl -sSL https://aka.ms/getvsdbgsh -o '/root/getvsdbg.sh';

Write-Host '5. installing vsdbg ...';
kubectl exec $pod -i -- bash /root/getvsdbg.sh -v latest -l /vsdbg;

$cmd = 'dotnet';
Write-Host '6. seaching for' $cmd 'process PID in pod:' $pod '...';
$prid = kubectl exec $pod -i -- pidof -s $cmd;

Write-Host '7. attaching debugger to process with PID:' $pid 'in pod:' $pod '...';
kubectl exec $pod -i -- /vsdbg/vsdbg --interpreter=mi --attach $prid;

Jetzt können Sie dieses Skript folgendermaßen ausführen, wenn das Terminal über den Skriptordner ausgeführt wird:

powershell -ExecutionPolicy Bypass -File kubedbg.ps1 -Selector app=mywebapp

Aber sollen wir nicht in Visual Studio debuggen? Ja! Gehen wir weiter und starten unseren Terminalprozess von Visual Studio MIEngine aus. Öffnen Sie Ihr Projekt in Visual Studio. Fügen Sie eine neue XML-Datei mit dem folgenden Inhalt hinzu und nennen Sie sie kubedbg.xml:

<PipeLaunchOptions xmlns="http://schemas.microsoft.com/vstudio/MDDDebuggerOptions/2014"
    PipePath="powershell" TargetArchitecture="x64" MIMode="clrdbg"
    PipeArguments="
      -ExecutionPolicy Bypass
      -File C:\kube\kubedbg.ps1
      -Selector app=mywebapp">
  <LaunchCompleteCommand>None</LaunchCompleteCommand>
</PipeLaunchOptions>

Im -FileParameter müssen Sie den absoluten Pfad zu der zuvor erstellten Skriptdatei angeben. Drücken Sie dann Strg + Alt + A, um das Befehlsfenster zu öffnen und den folgenden Befehl auszuführen: Debug.MIDebugLaunch /Executable:dotnet /OptionsFile:absolute_path_to_kubedbg_xml Dieser Befehl startet den Debugging-Prozess in Visual Studio mit allen erwarteten Standardvorteilen. Aber hören Sie nicht auf, auf andere Weise zu debuggen, als indem Sie im Menü Debuggen auf Alle trennen klicken! Obwohl dieser Befehl nicht sehr bequem zu schreiben ist. Glücklicherweise können Sie in Visual Studio Aliase für Befehle mit Parametern angeben. Schließlich benötigen Sie kubedbg.xmlfür jedes Projekt eine neue Datei. In diesem Sinne erstellen Sie Ihren ersten Alias, indem Sie den folgenden Befehl in das Befehlsfenster eingeben:

alias kubedbg.mywebapp Debug.MIDebugLaunch /Executable:dotnet 
/OptionsFile:absolute_path_to_kubedbg.xml

Danach können Sie mit dem Debuggen beginnen, indem Sie kubedbg.mywebapp im Befehlsfenster ausführen. Noch besser ist es, wenn Sie denselben Befehl in der Combobox der Suchsymbolleiste ausführen, jedoch mit dem Präfix: >kubedbg.mywebapp.Das ist nicht schwierig, da es auch eine Textvervollständigung gibt. Weitere Informationen zu Befehls-Aliasnamen finden Sie hier. Viel Spaß beim Debuggen! PS: Als Bonus können Sie Ihre App auf die gleiche Weise debuggen, auch wenn Sie in einer öffentlichen Cloud ausgeführt werden. Wenn kubectl einem Cluster in der öffentlichen Cloud zugewiesen wird, funktioniert es nur mit demselben Skript und es werden weniger Annahmen zurückgezahlt, da die Prozess-ID des realen Clusters nicht gleich 1 ist