Debuggen mit Dev Proxy

Auf einen Blick
Ziel: Debuggen Ihrer Anwendung, während Der Dev-Proxy API-Fehler simuliert
Zeit: 15 Minuten
Plugins:GenericRandomErrorPlugin
Voraussetzungen:Einrichten von Dev-Proxy, VS-Code

Wenn Sie Anwendungen erstellen, die APIs aufrufen, müssen Sie sicherstellen, dass Ihr Code Fehler ordnungsgemäß verarbeitet. Durch die Kombination von Dev Proxy mit dem Debugger von Visual Studio (VS) Code können Sie API-Fehler simulieren und Ihren Fehlerbehandlungscode schrittweise durchlaufen, um zu überprüfen, ob er ordnungsgemäß funktioniert.

Überblick

Das Debuggen mit Dev Proxy umfasst drei Schritte:

  1. Konfigurieren von VS Code zum Weiterleiten von HTTP-Anforderungen über Dev Proxy
  2. Konfigurieren von Dev Proxy zum Simulieren bestimmter Fehler
  3. Festlegen von Haltepunkten in Ihrem Fehlerbehandlungscode und Debuggen

Konfigurieren von VS-Code für das Debuggen mit Dev Proxy

Die Konfiguration von VS Code hängt von der verwendeten Programmiersprache ab. In den folgenden Abschnitten erfahren Sie, wie Sie VS Code für Node.js, .NET und Python Anwendungen konfigurieren.

Node.js

Um eine Node.js-Anwendung mit Dev Proxy zu debuggen, konfigurieren Sie die Datei, um die Proxyumgebungsvariablen festzulegen und die TLS/SSL-Zertifikatüberprüfung zu deaktivieren.

Datei: .vscode/launch.json

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "node",
      "request": "launch",
      "name": "Debug with Dev Proxy",
      "skipFiles": [
        "<node_internals>/**"
      ],
      "program": "${workspaceFolder}/index.js",
      "env": {
        "NODE_ENV": "development",
        "http_proxy": "http://127.0.0.1:8000",
        "https_proxy": "http://127.0.0.1:8000",
        "GLOBAL_AGENT_HTTP_PROXY": "http://127.0.0.1:8000",
        "NODE_TLS_REJECT_UNAUTHORIZED": "0"
      }
    }
  ]
}

Von Bedeutung

Die Einstellung deaktiviert die TLS/SSL-Zertifikatüberprüfung. Verwenden Sie diese Einstellung nur während der Entwicklung. Um einen sichereren Ansatz zu verfolgen, verwenden Sie den Befehl, um dem Dev-Proxyzertifikat direkt zu vertrauen:

macOS/Linux:

"NODE_EXTRA_CA_CERTS": "${env:HOME}/.devproxy/rootCert.pem"

Windows:

"NODE_EXTRA_CA_CERTS": "${env:USERPROFILE}\\.devproxy\\rootCert.pem"

Die Variable wird vom Paket verwendet, das Proxyunterstützung für viele Node.js HTTP-Bibliotheken bereitstellt. Weitere Informationen zum Konfigurieren verschiedener HTTP-Bibliotheken finden Sie unter Verwenden von Dev Proxy mit Node.js Anwendungen.

.NET

.NET Anwendungen verwenden automatisch die Systemproxyeinstellungen. Zum Debuggen einer .NET Anwendung mit Dev Proxy müssen Sie in der Regel keine Umgebungsvariablen festlegen. Erstellen einer grundlegenden Debugkonfiguration:

Datei: .vscode/launch.json

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Debug with Dev Proxy",
      "type": "coreclr",
      "request": "launch",
      "preLaunchTask": "build",
      "program": "${workspaceFolder}/bin/Debug/net8.0/MyApp.dll",
      "args": [],
      "cwd": "${workspaceFolder}",
      "console": "internalConsole",
      "stopAtEntry": false
    }
  ]
}

Wenn Ihre Anwendung den Systemproxy nicht abholt, legen Sie explizit die Proxyumgebungsvariablen fest:

Datei: .vscode/launch.json (mit expliziten Proxyeinstellungen)

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Debug with Dev Proxy",
      "type": "coreclr",
      "request": "launch",
      "preLaunchTask": "build",
      "program": "${workspaceFolder}/bin/Debug/net8.0/MyApp.dll",
      "args": [],
      "cwd": "${workspaceFolder}",
      "console": "internalConsole",
      "stopAtEntry": false,
      "env": {
        "http_proxy": "http://127.0.0.1:8000",
        "https_proxy": "http://127.0.0.1:8000"
      }
    }
  ]
}

Tipp

Auf Windows und macOS vertraut .NET dem Dev Proxy-Zertifikat automatisch, wenn Sie es während des setups Dev Proxy als vertrauenswürdiges Stammzertifikat installiert haben. Unter Linux müssen Sie möglicherweise dem Zertifikat manuell vertrauen. Informationen zum Konfigurieren vertrauenswürdiger Zertifikate finden Sie in der Dokumentation Ihrer Verteilung.

Python

Um eine Python Anwendung mit Dev Proxy zu debuggen, konfigurieren Sie die datei launch.json, um die Proxyumgebungsvariablen festzulegen. Die Konfiguration hängt davon ab, ob Sie die Bibliothek oder andere HTTP-Bibliotheken verwenden.

Datei: .vscode/launch.json

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Debug with Dev Proxy",
      "type": "debugpy",
      "request": "launch",
      "program": "${workspaceFolder}/main.py",
      "console": "integratedTerminal",
      "env": {
        "HTTP_PROXY": "http://127.0.0.1:8000",
        "HTTPS_PROXY": "http://127.0.0.1:8000",
        "REQUESTS_CA_BUNDLE": ""
      }
    }
  ]
}

Von Bedeutung

Das Festlegen auf eine leere Zeichenfolge weist die Bibliothek an, die ÜBERPRÜFUNG von TLS/SSL-Zertifikaten zu überspringen. Verwenden Sie diese Einstellung nur während der Entwicklung.

Um einen sichereren Ansatz zu erreichen, verweisen Sie auf das Dev Proxy-Zertifikat:

macOS/Linux:

"REQUESTS_CA_BUNDLE": "${env:HOME}/.devproxy/rootCert.pem"

Windows:

"REQUESTS_CA_BUNDLE": "${env:USERPROFILE}\\.devproxy\\rootCert.pem"

Wenn Sie die Bibliothek verwenden, konfigurieren Sie stattdessen die TLS/SSL-Überprüfung mithilfe der Umgebungsvariable:

{
  "env": {
    "HTTP_PROXY": "http://127.0.0.1:8000",
    "HTTPS_PROXY": "http://127.0.0.1:8000",
    "TLS/SSL_CERT_FILE": "${env:HOME}/.devproxy/rootCert.pem"
  }
}

Konfigurieren von Dev Proxy zum Simulieren von Fehlern

Um die Fehlerbehandlung zu debuggen, konfigurieren Sie Dev Proxy so, dass bestimmte Fehler zurückgegeben werden, wenn Ihre App APIs aufruft. Verwenden Sie das GenericRandomErrorPlugin, um Fehler wie BeispielFehler1 oder BeispielFehler2 zu simulieren.

Simulieren eines Fehlers von 429 (zu viele Anforderungen)

Erstellen Sie eine Dev Proxy-Konfigurationsdatei, die die Drosselung simuliert:

Datei: devproxyrc.json

{
  "$schema": "https://raw.githubusercontent.com/dotnet/dev-proxy/main/schemas/v3.1.0/rc.schema.json",
  "plugins": [
    {
      "name": "GenericRandomErrorPlugin",
      "enabled": true,
      "pluginPath": "~appFolder/plugins/DevProxy.Plugins.dll",
      "configSection": "errorsConfig"
    }
  ],
  "urlsToWatch": [
    "https://api.contoso.com/*"
  ],
  "rate": 100,
  "errorsConfig": {
    "$schema": "https://raw.githubusercontent.com/dotnet/dev-proxy/main/schemas/v3.1.0/genericrandomerrorplugin.schema.json",
    "errorsFile": "errors.json"
  }
}

Erstellen Sie die Fehlerdatei mit den spezifischen Fehlerantworten:

Datei: errors.json

{
  "$schema": "https://raw.githubusercontent.com/dotnet/dev-proxy/main/schemas/v3.1.0/genericrandomerrorplugin.errorsfile.schema.json",
  "errors": [
    {
      "request": {
        "url": "https://api.contoso.com/*"
      },
      "responses": [
        {
          "statusCode": 429,
          "headers": [
            {
              "name": "content-type",
              "value": "application/json"
            },
            {
              "name": "Retry-After",
              "value": "60"
            }
          ],
          "body": {
            "error": {
              "code": "TooManyRequests",
              "message": "Rate limit exceeded. Retry after 60 seconds."
            }
          }
        }
      ]
    }
  ]
}

Tipp

Legen Sie fest, dass jede Anforderung fehlschlägt, sodass Sie den Fehlerbehandlungscode während des Debuggens konsistent erreicht haben. Verringern Sie die Rate, wenn Sie zeitweilige Fehler testen möchten.

Simulieren eines 500 (interner Serverfehler)

Um Serverfehler zu simulieren, fügen Sie eine weitere Fehlerantwort hinzu:

Datei: errors.json (mehrere Fehler)

{
  "$schema": "https://raw.githubusercontent.com/dotnet/dev-proxy/main/schemas/v3.1.0/genericrandomerrorplugin.errorsfile.schema.json",
  "errors": [
    {
      "request": {
        "url": "https://api.contoso.com/*"
      },
      "responses": [
        {
          "statusCode": 429,
          "headers": [
            {
              "name": "content-type",
              "value": "application/json"
            },
            {
              "name": "Retry-After",
              "value": "60"
            }
          ],
          "body": {
            "error": {
              "code": "TooManyRequests",
              "message": "Rate limit exceeded. Retry after 60 seconds."
            }
          }
        },
        {
          "statusCode": 500,
          "headers": [
            {
              "name": "content-type",
              "value": "application/json"
            }
          ],
          "body": {
            "error": {
              "code": "InternalServerError",
              "message": "An unexpected error occurred."
            }
          }
        }
      ]
    }
  ]
}

Wenn Sie mehrere Fehlerantworten definieren, wählt Dev Proxy zufällig eine für jede abgefangene Anforderung aus.

Debuggen des Fehlerbehandlungscodes

Nachdem VS Code und Dev Proxy konfiguriert wurden, können Sie jetzt Ihren Fehlerbehandlungscode debuggen.

Schritt 1: Festlegen von Haltepunkten

Öffnen Sie Den Quellcode, und legen Sie Haltepunkte in Ihrem Fehlerbehandlungscode fest. Beispiel: in einer Node.js Anwendung:

async function fetchData() {
  try {
    const response = await fetch('https://api.contoso.com/data');
    
    if (!response.ok) {
      // Set a breakpoint here to debug error responses
      throw new Error(`HTTP error: ${response.status}`);
    }
    
    return await response.json();
  } catch (error) {
    // Set a breakpoint here to debug exceptions
    console.error('Failed to fetch data:', error);
    throw error;
  }
}

Schritt 2: Starten des Dev-Proxys

Starten Sie Dev Proxy mit Ihrer Konfigurationsdatei:

devproxy --config-file devproxyrc.json

Schritt 3: Starten des Debuggens in VS-Code

  1. Öffnen von VS-Code
  2. Drücken Sie F5, oder wählen Sie "Debuggen starten" aus.
  3. Wenn Ihre Anwendung einen API-Aufruf vorgibt, fängt Dev Proxy ihn ab und gibt einen Fehler zurück.
  4. VS Code hält an Ihrem Breakpoint an
  5. Verwenden Sie die Debug-Steuerelemente, um Ihren Code Schritt für Schritt durchzugehen und Variablen zu inspizieren.

Schritt 4: Überprüfen des Fehlers

Wenn VS Code an Ihrem Breakpunkt anhält, verwenden Sie das Debug-Panel, um:

  • Anzeigen des Fehlerantwortstatuscodes und der Meldung
  • Überprüfen der Werte lokaler Variablen
  • Überprüfen der Wiederholungslogik
  • Überprüfen, ob Ihre Fehlermeldungen benutzerfreundlicher sind

Dev Proxy automatisch starten und beenden

Um Ihren Debugworkflow zu optimieren, konfigurieren Sie VS Code so, dass Dev Proxy automatisch gestartet wird, wenn Sie mit dem Debuggen beginnen und ihn beenden, wenn Sie fertig sind. Installieren Sie die Dev Proxy Toolkit-Erweiterung , und konfigurieren Sie Aufgaben:

Datei: .vscode/tasks.json

{
  "version": "2.0.0",
  "tasks": [
    {
      "label": "devproxy-start",
      "type": "devproxy",
      "command": "start",
      "args": [
        "--config-file",
        "devproxyrc.json"
      ],
      "isBackground": true,
      "problemMatcher": "$devproxy-watch"
    },
    {
      "label": "devproxy-stop",
      "type": "devproxy",
      "command": "stop"
    }
  ]
}

Um diese Aufgaben zu verwenden, aktualisieren Sie Folgendes :

Datei: .vscode/launch.json (Node.js mit Autostart)

{
  "version": "0.2.0",
  "configurations": [
    {
      "type": "node",
      "request": "launch",
      "name": "Debug with Dev Proxy",
      "skipFiles": [
        "<node_internals>/**"
      ],
      "program": "${workspaceFolder}/index.js",
      "preLaunchTask": "devproxy-start",
      "postDebugTask": "devproxy-stop",
      "env": {
        "NODE_ENV": "development",
        "http_proxy": "http://127.0.0.1:8000",
        "https_proxy": "http://127.0.0.1:8000",
        "GLOBAL_AGENT_HTTP_PROXY": "http://127.0.0.1:8000",
        "NODE_TLS_REJECT_UNAUTHORIZED": "0"
      }
    }
  ]
}

Tipps zum effektiven Debuggen

  • Um Ihre Haltepunkte konsistent zu erreichen, konfigurieren Sie in Ihrer Dev-Proxy-Konfiguration einen Parameter, damit jede Anforderung fehlschlägt.
  • Um zu verstehen, wie Ihr Code einen bestimmten Fehler behandelt, verwenden Sie beim Debuggen eine einzelne Fehlerantwort.
  • Um zu überprüfen, ob der Code die Ratenbegrenzung berücksichtigt, stellen Sie sicher, dass er beim Debuggen von 429-Fehlern den Header liest und befolgt.
  • Um sicherzustellen, dass Ihr Code ungewöhnliche Antworten ordnungsgemäß verarbeitet, verwenden Sie Dev Proxy, um Edgefälle wie falsch formatierte JSON- oder fehlende Header zu simulieren.
  • Um nur bei bestimmten Fehlern zu unterbrechen, verwenden Sie bedingte Haltepunkte in VS-Code, indem Sie mit der rechten Maustaste auf einen Haltepunkt klicken und eine Bedingung wie z . B. hinzufügen.

Siehe auch

  • Verwenden Sie Dev Proxy mit Visual Studio Code-Debugkonfigurationen - Dev Proxy in VS Code automatisch starten
  • Testen meiner App mit zufälligen Fehlern – Simulieren zufälliger API-Fehler
  • Änderungsanforderungsfehlerrate – Anpassen, wie oft Fehler auftreten
  • Verwenden von Dev Proxy mit Node.js Anwendungen – Node.js Proxykonfiguration
  • Verwenden Sie Dev Proxy mit .NET-Anwendungen – .NET-Proxykonfiguration
  • Last updated on