Python-Debugging in einem Container

Beim Hinzufügen von Docker-Dateien zu einem Python-Projekt werden Aufgaben und Startkonfigurationen hinzugefügt, um das Debugging der Anwendung innerhalb eines Containers zu ermöglichen. Um die verschiedenen Szenarien von Python-Projekten zu berücksichtigen, benötigen einige Apps möglicherweise zusätzliche Konfigurationen.

Konfigurieren des Container-Einstiegspunkts

Sie können den Einstiegspunkt des Containers konfigurieren, indem Sie Eigenschaften in tasks.json festlegen. VS Code konfiguriert automatisch den Container-Einstiegspunkt, wenn Sie zum ersten Mal den Befehl Container: Docker-Dateien zum Arbeitsbereich hinzufügen... verwenden.

Beispiel: Konfigurieren des Einstiegspunkts für ein Python-Modul

{
  "tasks": [
    {
      "type": "docker-run",
      "label": "docker-run: debug",
      "dependsOn": ["docker-build"],
      "python": {
        "module": "myapp"
      }
    }
  ]
}

Beispiel: Konfigurieren des Einstiegspunkts für eine Python-Datei

{
  "tasks": [
    {
      "type": "docker-run",
      "label": "docker-run: debug",
      "dependsOn": ["docker-build"],
      "python": {
        "args": ["runserver", "0.0.0.0:8000", "--nothreading", "--noreload"],
        "file": "manage.py"
      }
    }
  ]
}

Automatisches Starten des Browsers zur Einstiegsseite der Anwendung

Sie können die Startkonfigurationen Container: Python - Django oder Container: Python - Flask auswählen, um den Browser automatisch zur Hauptseite der App zu starten. Diese Funktion ist standardmäßig aktiviert, aber Sie können dieses Verhalten explizit konfigurieren, indem Sie das Objekt dockerServerReadyAction in launch.json festlegen.

Diese Funktion hängt von mehreren Aspekten der Anwendung ab

Die Anwendung muss in die Debug-Konsole oder Docker-Protokolle ausgeben.
Die Anwendung muss eine "Server bereit"-Nachricht protokollieren.
Die Anwendung muss eine durchsuchbare Seite bereitstellen.

Hier ist ein Beispiel für die Verwendung von dockerServerReadyAction, um den Browser zu starten und die Seite about.html basierend auf einem bestimmten Server-Nachrichtenmuster zu öffnen.

{
  "configurations": [
    {
      "name": "Containers: Python - Django",
      "type": "docker",
      "request": "launch",
      "preLaunchTask": "docker-run: debug",
      "python": {
        "pathMappings": [
          {
            "localRoot": "${workspaceFolder}",
            "remoteRoot": "/app"
          }
        ],
        "projectType": "django"
      },
      "dockerServerReadyAction": {
        "action": "openExternally",
        "pattern": "Starting development server at (https?://\\S+|[0-9]+)",
        "uriFormat": "%s://:%s/about.html"
      }
    }
  ]
}

Hinweis: Der Regex im Attribut pattern versucht einfach, eine Protokollnachricht ähnlich wie "Starting development server at https://:8000" zu erfassen. Er berücksichtigt Variationen der URL für http oder https, beliebige Hostnamen und beliebige Ports.

Wichtige Eigenschaften des Objekts dockerServerReadyAction

action: Die Aktion, die ausgeführt werden soll, wenn das Muster gefunden wird. Kann debugWithChrome oder openExternally sein.
pattern: Wenn die Anwendung eine andere Nachricht als die oben gezeigte protokolliert, legen Sie die Eigenschaft pattern des dockerServerReadyAction-Objekts auf einen JavaScript-regulären Ausdruck fest, der dieser Nachricht entspricht. Der reguläre Ausdruck sollte eine Erfassungsgruppe enthalten, die dem Port entspricht, auf dem die Anwendung lauscht.
uriFormat: Standardmäßig öffnet die Container Tools-Erweiterung die Hauptseite des Browsers (wie auch immer diese von der Anwendung bestimmt wird). Wenn Sie möchten, dass der Browser eine bestimmte Seite wie im obigen Beispiel öffnet, sollte die Eigenschaft uriFormat des dockerServerReadyAction-Objekts auf eine Formatzeichenfolge mit zwei Token gesetzt werden, um die Protokoll- und Portsubstitution anzugeben.

Wie Hot Reloading in Django- oder Flask-Apps aktiviert wird

Wenn Sie Container: Docker-Dateien zum Arbeitsbereich hinzufügen für Django oder Flask auswählen, stellen wir Ihnen eine Dockerfile und eine tasks.json-Datei zur Verfügung, die für die statische Bereitstellung konfiguriert sind. Jedes Mal, wenn Sie Änderungen an Ihrem App-Code vornehmen, müssen Sie Ihren Container neu erstellen und erneut ausführen. Hot Reloading ermöglicht es Ihnen, Änderungen an Ihrem App-Code zu visualisieren, während Ihr Container weiter läuft. Aktivieren Sie Hot Reloading mit diesen Schritten

Für Django-Apps

Kommentieren Sie in der Dockerfile die Zeile aus, die den App-Code zum Container hinzufügt.
```
#ADD . /app
```

Erstellen Sie innerhalb der docker-run-Aufgabe in der tasks.json-Datei ein neues dockerRun-Attribut mit einer volumes-Eigenschaft. Diese Einstellung erstellt eine Zuordnung vom aktuellen Arbeitsbereichsordner (App-Code) zum Ordner /app im Container.

{
  "type": "docker-run",
  "label": "docker-run: debug",
  "dependsOn": [
    "docker-build"
  ],
  "dockerRun": {
    "volumes": [
      {
        "containerPath": "/app", "localPath": "${workspaceFolder}"
      }
    ]
  },
  ...
}

Bearbeiten Sie das Python-Attribut, indem Sie --noreload und --nothreading entfernen.

{
  ...
  "dockerRun": {
    "volumes": [
      {
        "containerPath": "/app", "localPath": "${workspaceFolder}"
      }
    ]
  },
  "python": {
    "args": [
      "runserver",
      "0.0.0.0:8000",
    ],
    "file": "manage.py"
  }
}

Wählen Sie die Startkonfiguration Container: Python – Django und drücken Sie F5, um Ihren Container zu erstellen und auszuführen.
Bearbeiten und speichern Sie eine beliebige Datei.
Aktualisieren Sie den Browser und validieren Sie, dass die Änderungen vorgenommen wurden.

Für Flask-Apps

Kommentieren Sie in der Dockerfile die Zeile aus, die den App-Code zum Container hinzufügt.
```
#ADD . /app
```

Bearbeiten Sie innerhalb der docker-run-Aufgabe in der tasks.json-Datei das vorhandene dockerRun-Attribut, indem Sie FLASK_ENV in der env-Eigenschaft sowie eine volumes-Eigenschaft hinzufügen. Diese Einstellung erstellt eine Zuordnung vom aktuellen Arbeitsbereichsordner (App-Code) zum Ordner /app im Container.

{
  "type": "docker-run",
  "label": "docker-run: debug",
  "dependsOn": [
    "docker-build"
  ],
  "dockerRun": {
    "env": {
      "FLASK_APP": "path_to/flask_entry_point.py",
      "FLASK_ENV": "development"
    },
    "volumes": [
      {
        "containerPath": "/app", "localPath": "${workspaceFolder}"
      }
    ]
  },
  ...
}

Bearbeiten Sie das Python-Attribut, indem Sie --no-reload und --no-debugger entfernen.

{
  ...
  "dockerRun": {
    "env": {
      "FLASK_APP": "path_to/flask_entry_point.py",
      "FLASK_ENV": "development"
    },
    "volumes": [
      {
        "containerPath": "/app", "localPath": "${workspaceFolder}"
      }
    ]
  },
  "python": {
    "args": [
      "run",
      "--host", "0.0.0.0",
      "--port", "5000"
    ],
    "module": "flask"
  }
}

Wählen Sie die Startkonfiguration Container: Python – Flask und drücken Sie F5, um Ihren Container zu erstellen und auszuführen.
Bearbeiten und speichern Sie eine beliebige Datei.
Aktualisieren Sie den Browser und validieren Sie, dass die Änderungen vorgenommen wurden.

Wie man einen Container erstellt und gemeinsam ausführt

In der zuvor erwähnten tasks.json-Datei gibt es eine Abhängigkeit von der docker-build-Aufgabe. Die Aufgabe ist Teil des tasks-Arrays in tasks.json. Zum Beispiel

"tasks":
[
  {
    ...
  },
  {
    "label": "docker-build",
    "type": "docker-build",
    "dockerBuild": {
        "context": "${workspaceFolder}",
        "dockerfile": "${workspaceFolder}/Dockerfile",
        "tag": "YOUR_IMAGE_NAME:YOUR_IMAGE_TAG"
    }
  }
]

Tipp: Da die Abhängigkeit eindeutig docker-build als Abhängigkeit angibt, muss der Name dieser Aufgabe entsprechen. Sie können den Namen bei Bedarf ändern.

Das dockerBuild-Objekt in JSON ermöglicht die folgenden Parameter
- context: Der Build-Kontext, von dem aus Ihre Dockerfile aufgerufen wird
- dockerfile: Der Pfad zur auszuführenden Dockerfile
- tag: Der Name des zu erstellenden Images mit seinem Versionstag

Insgesamt kann eine VS-Code-Einrichtung zum Erstellen und Debuggen Ihrer Flask-Anwendung sein

launch.json

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Debug Flask App",
      "type": "docker",
      "request": "launch",

      "preLaunchTask": "docker-run: debug",
      "python": {
        "pathMappings": [
          {
            "localRoot": "${workspaceFolder}",
            "remoteRoot": "/app"
          }
        ],
        "projectType": "flask"
      },
      "dockerServerReadyAction": {
        "action": "openExternally",
        "pattern": "Running on (http?://\\S+|[0-9]+)",
        "uriFormat": "%s://:%s/"
      }
    }
  ]
}

tasks.json

{
  "version": "2.0.0",
  "tasks": [
    {
      "type": "docker-run",
      "label": "docker-run: debug",
      "dependsOn": ["docker-build"],
      "dockerRun": {
        "containerName": "YOUR_IMAGE_NAME",
        "image": "YOUR_IMAGE_NAME:YOUR_IMAGE_TAG",
        "env": {
          "FLASK_APP": "path_to/flask_entry_point.py",
          "FLASK_ENV": "development"
        },
        "volumes": [
          {
            "containerPath": "/app",
            "localPath": "${workspaceFolder}"
          }
        ],
        "ports": [
          {
            "containerPort": 5000,
            "hostPort": 5000
          }
        ]
      },
      "python": {
        "args": ["run", "--host", "0.0.0.0", "--port", "5000"],
        "module": "flask"
      }
    },
    {
      "label": "docker-build",
      "type": "docker-build",
      "dockerBuild": {
        "context": "${workspaceFolder}",
        "dockerfile": "${workspaceFolder}/Dockerfile",
        "tag": "YOUR_IMAGE_NAME:YOUR_IMAGE_TAG"
      }
    }
  ]
}

Nächste Schritte

Mehr erfahren über

Konfigurieren eines Nicht-Root-Benutzers in Ihrem Container

12/21/2021