Debugowanie za pomocą serwera proxy deweloperskiego

Na pierwszy rzut oka
Cel: Debugowanie aplikacji, gdy Dev Proxy symuluje błędy API
Czas: 15 minut
Plugins:GenericRandomErrorPlugin
Wymagania wstępne: Konfigurowanie serwera proxy deweloperskiego, programu VS Code

Podczas tworzenia aplikacji wywołujących interfejsy API należy upewnić się, że kod prawidłowo obsługuje błędy. Łącząc serwer proxy dev z debugerem Visual Studio (VS) Code, można symulować błędy interfejsu API i przechodzić przez kod obsługi błędów, aby sprawdzić, czy działa prawidłowo.

Przegląd

Debugowanie za pomocą serwera proxy deweloperskiego obejmuje trzy kroki:

Konfigurowanie programu VS Code do kierowania żądań HTTP za pośrednictwem serwera proxy deweloperskiego
Konfigurowanie serwera proxy deweloperskiego w celu symulowania określonych błędów
Ustawianie punktów przerwania w kodzie obsługi błędów i debugowanie

Konfigurowanie programu VS Code na potrzeby debugowania za pomocą serwera proxy deweloperskiego

Sposób konfigurowania programu VS Code zależy od używanego języka programowania. W poniższych sekcjach pokazano, jak skonfigurować program VS Code dla aplikacji Node.js, .NET i Python.

Node.js

Aby debugować aplikację Node.js za pomocą serwera proxy deweloperskiego, skonfiguruj plik, aby ustawić zmienne środowiskowe serwera proxy i wyłączyć weryfikację certyfikatu TLS/SSL.

Plik: .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"
      }
    }
  ]
}

Ważna

To ustawienie wyłącza weryfikację certyfikatu TLS/SSL. To ustawienie jest używane tylko podczas programowania. Aby uzyskać bardziej bezpieczne rozwiązanie, użyj, aby bezpośrednio ufać certyfikatowi Dev Proxy:

macOS/Linux:

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

Windows:

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

Zmienna jest używana przez pakiet, który zapewnia obsługę serwera proxy dla wielu bibliotek HTTP Node.js. Aby uzyskać więcej informacji na temat konfigurowania różnych bibliotek HTTP, zobacz Use Dev Proxy with Node.js applications (Używanie serwera proxy deweloperskiego z aplikacjami Node.js).

.NET

.NET aplikacje automatycznie używają ustawień serwera proxy systemu. Aby debugować aplikację .NET za pomocą serwera proxy deweloperskiego, zazwyczaj nie trzeba ustawiać żadnych zmiennych środowiskowych. Utwórz podstawową konfigurację debugowania:

Plik: .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
    }
  ]
}

Jeśli aplikacja nie pobiera serwera proxy systemu, jawnie ustaw zmienne środowiskowe serwera proxy:

Plik: .vscode/launch.json (z jawnymi ustawieniami serwera proxy)

{
  "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"
      }
    }
  ]
}

Wskazówka

W systemach Windows i macOS, .NET automatycznie ufa certyfikatowi Dev Proxy, jeśli podczas konfiguracji Dev Proxy zainstalowano go jako zaufany certyfikat główny. W systemie Linux może być konieczne ręczne zaufanie certyfikatu. Zapoznaj się z dokumentacją dystrybucji dotyczącą konfigurowania zaufanych certyfikatów.

Python

Aby debugować aplikację Python za pomocą serwera proxy deweloperskiego, skonfiguruj plik launch.json, aby ustawić zmienne środowiskowe serwera proxy. Konfiguracja zależy od tego, czy używasz biblioteki, czy innych bibliotek HTTP.

Plik: .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": ""
      }
    }
  ]
}

Ważna

Ustawienie na pusty ciąg informuje bibliotekę o pominięciu weryfikacji certyfikatu TLS/SSL. To ustawienie jest używane tylko podczas programowania.

Aby uzyskać bardziej bezpieczne podejście, wskaż certyfikat serwera proxy deweloperskiego:

macOS/Linux:

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

Windows:

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

Jeśli używasz biblioteki, skonfiguruj weryfikację protokołu TLS/SSL przy użyciu zmiennej środowiskowej :

{
  "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"
  }
}

Konfigurowanie serwera proxy deweloperskiego w celu symulowania błędów

Aby debugować obsługę błędów, skonfiguruj serwer proxy Dev, aby zwracał określone błędy, gdy aplikacja wywołuje interfejsy API. Użyj metody GenericRandomErrorPlugin , aby symulować błędy takie jak lub .

Symulowanie błędu 429 (zbyt wielu żądań)

Utwórz plik konfiguracji serwera proxy dev, który symuluje ograniczanie przepustowości:

Plik: devproxyrc.json

{
  "$schema": "https://raw.githubusercontent.com/dotnet/dev-proxy/main/schemas/v2.2.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/v2.2.0/genericrandomerrorplugin.schema.json",
    "errorsFile": "errors.json"
  }
}

Utwórz plik błędów z określonymi odpowiedziami o błędach:

Plik: errors.json

{
  "$schema": "https://raw.githubusercontent.com/dotnet/dev-proxy/main/schemas/v2.2.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."
            }
          }
        }
      ]
    }
  ]
}

Wskazówka

Ustaw odpowiednią wartość, aby każde żądanie kończyło się niepowodzeniem, umożliwiając ciągłe uruchamianie kodu obsługi błędów podczas debugowania. Obniż częstotliwość testowania sporadycznych błędów.

Symulowanie błędu 500 (wewnętrzny błąd serwera)

Aby symulować błędy serwera, dodaj kolejną odpowiedź o błędzie:

Plik: errors.json (wiele błędów)

{
  "$schema": "https://raw.githubusercontent.com/dotnet/dev-proxy/main/schemas/v2.2.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."
            }
          }
        }
      ]
    }
  ]
}

Podczas definiowania wielu odpowiedzi na błędy serwer proxy deweloperów losowo wybiera jeden dla każdego przechwyconego żądania.

Debugowanie kodu obsługi błędów

Po skonfigurowaniu programu VS Code i serwera proxy deweloperskiego można teraz debugować kod obsługi błędów.

Krok 1. Ustawianie punktów przerwania

Otwórz kod źródłowy i ustaw punkty przerwania w kodzie obsługi błędów. Na przykład w aplikacji Node.js:

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;
  }
}

Krok 2. Uruchamianie serwera proxy deweloperskiego

Uruchom serwer proxy dewelopera przy użyciu pliku konfiguracji:

devproxy --config-file devproxyrc.json

Krok 3. Rozpoczęcie debugowania w programie VS Code

Otwieranie programu VS Code
Naciśnij klawisz F5 lub wybierz pozycję Uruchom uruchamianie debugowania
Gdy aplikacja wykonuje wywołanie interfejsu API, serwer proxy dewelopera przechwytuje go i zwraca błąd
Program VS Code wstrzymuje się w punkcie przerwania
Używanie kontrolek debugowania do przechodzenia przez kod i inspekcji zmiennych

Krok 4. Sprawdzanie błędu

Gdy program VS Code wstrzymuje się w punkcie przerwania, użyj panelu debugowania, aby:

Wyświetlanie kodu stanu odpowiedzi błędu i komunikatu
Sprawdzanie wartości zmiennych lokalnych
Przechodzenie przez logikę ponawiania prób
Sprawdź, czy komunikaty o błędach są przyjazne dla użytkownika

Automatyczne uruchamianie i zatrzymywanie serwera proxy deweloperskiego

Aby usprawnić przepływ pracy debugowania, skonfiguruj program VS Code, aby automatycznie uruchamiał serwer proxy deweloperów po rozpoczęciu debugowania i zatrzymaniu go po zakończeniu. Zainstaluj rozszerzenie Dev Proxy Toolkit i skonfiguruj zadania:

Plik: .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"
    }
  ]
}

Aby użyć tych zadań, zaktualizuj plik :

Plik: .vscode/launch.json (Node.js z autostartem)

{
  "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"
      }
    }
  ]
}

Porady dotyczące efektywnego debugowania

Aby konsekwentnie osiągać punkty przerwania, ustaw w konfiguracji serwera proxy deweloperów, aby każde żądanie kończyło się niepowodzeniem.
Aby dowiedzieć się, jak kod obsługuje określony błąd, użyj pojedynczej odpowiedzi o błędzie podczas debugowania.
Aby sprawdzić, czy kod szanuje ograniczanie przepustowości, sprawdź, czy odczytuje i postępuj zgodnie z nagłówkiem podczas debugowania błędów 429.
Aby upewnić się, że kod obsługuje nietypowe odpowiedzi, użyj serwera proxy dewelopera, aby symulować przypadki brzegowe, takie jak nieprawidłowo sformułowany kod JSON lub brakujące nagłówki.
Aby przerwać tylko określone błędy, użyj warunkowych punktów przerwania w programie VS Code, klikając prawym przyciskiem myszy punkt przerwania i dodając warunek taki jak .

Zobacz także

Użyj Dev Proxy z konfiguracjami debugowania w Visual Studio Code — autostart Dev Proxy w programie VS Code
Testowanie aplikacji przy użyciu błędów losowych — symulowanie losowych błędów interfejsu API
Współczynnik niepowodzeń żądań zmian — dostosuj częstotliwość występowania błędów
Używanie serwera proxy deweloperów z aplikacjami Node.js — konfiguracja serwera proxy Node.js
Użyj serwer proxy deweloperów przy użyciu aplikacji .NET — konfiguracja serwera proxy .NET

Opinia

Czy ta strona była pomocna?

Last updated on 2026-03-06

Udostępnij za pośrednictwem

Debugowanie za pomocą serwera proxy deweloperskiego

Przegląd

Konfigurowanie programu VS Code na potrzeby debugowania za pomocą serwera proxy deweloperskiego

Node.js

.NET

Python

Konfigurowanie serwera proxy deweloperskiego w celu symulowania błędów

Symulowanie błędu 429 (zbyt wielu żądań)

Symulowanie błędu 500 (wewnętrzny błąd serwera)

Debugowanie kodu obsługi błędów

Krok 1. Ustawianie punktów przerwania

Krok 2. Uruchamianie serwera proxy deweloperskiego

Krok 3. Rozpoczęcie debugowania w programie VS Code

Krok 4. Sprawdzanie błędu

Automatyczne uruchamianie i zatrzymywanie serwera proxy deweloperskiego

Porady dotyczące efektywnego debugowania

Zobacz także

Opinia

Dodatkowe zasoby