Es dauert länger, bis Ihr lokales Setup den von Ihnen geschriebenen Code richtig debuggt, als jeder Entwickler zugeben möchte. Und vergessen wir nicht, dass dies größtenteils ein einmaliges Setup ist. Wenn wir es also nicht aufschreiben, werden wir uns nicht erinnern. Dieser Beitrag soll genau dieses Problem lösen! Dies dient als schriftliche Erinnerung daran, wie Sie Ihre lokale Entwicklungsumgebung zum Laufen bringen.

Voraussetzungen:

• PyCharm Professional (für Docker-Unterstützung)
• Docker und Docker Compose
• Django REST Framework (DRF)-Anwendung

In diesem Beitrag werden keine Details zum Django-, Docker- oder Docker-Composer-Setup behandelt, abgesehen von den für den Debug-Modus erforderlichen Updates. Es wird davon ausgegangen, dass Sie bereits praktische Kenntnisse darüber haben, wie Sie diesen Teil zum Laufen bringen.

Schritt 1: Dockerfile-Setup zum Debuggen

Richten Sie Ihre Docker-Datei so ein, dass sie im Entwicklungsmodus ausgeführt wird und Verbindungen vom PyCharm-Debugger zulässt.

Unten finden Sie ein Beispiel für eine Docker-Datei:

# Builder stage
FROM python:3.9-slim as builder

RUN chmod 1777 /tmp

# Install system dependencies
RUN apt-get update && apt-get install -y \
    libpq-dev \
    build-essential

WORKDIR /app

# Copy the requirements file into the container
COPY requirements.txt /app/
RUN pip install --no-cache-dir -r requirements.txt > pip_install.log

# Copy the current directory contents into the container
COPY . /app

# Collect static files
RUN python manage.py collectstatic --noinput

# Final stage
FROM python:3.9-slim

# Set environment variables
ENV PYTHONUNBUFFERED=1
ENV DJANGO_SETTINGS_MODULE=template.settings.development

# Set work directory
WORKDIR /app

# Copy files from the builder stage
COPY --from=builder /app /app

# Install pydevd-pycharm for remote debugging and gunicorn for serving
RUN pip install gunicorn pydevd-pycharm==241.17890.14 psycopg2-binary

# Expose necessary ports
EXPOSE 8000 5679  # Web app port and debug port

# Entry point for the container
ENTRYPOINT ["sh", "-c", "python manage.py runserver 0.0.0.0:8000"]

Dinge, die Sie bei diesem Code beachten sollten

• 241.17890.14 in pydevd-pycharm==241.17890.14 wird je nach der von Ihnen verwendeten Pycharm-Version unterschiedlich sein
• Wir machen sowohl 8000 (den Webserver-Port) als auch 5679 (den Debugger-Port) für den externen Zugriff verfügbar.

Schritt 2: Docker Compose-Konfiguration

Lassen Sie uns unsere docker-compose.yml-Datei erstellen, um den Webdienst (Django-App) zusammen mit der Datenbank und anderen Diensten zu konfigurieren.

Hier ist ein Beispiel für docker-compose.yml:

version: '3'

services:
  web:
    environment:
      - DJANGO_ENVIRONMENT=development
      - DB_HOST=host.docker.internal
    build:
      context: .
    command: >
      sh -c "python manage.py migrate &&
             python manage.py collectstatic --noinput &&
             python manage.py runserver 0.0.0.0:8000"
    volumes:
      - .:/app
    ports:
      - "8000:8000"   # Expose web port
      - "5679:5679"   # Expose debugger port
    extra_hosts:
      - "host.docker.internal:host-gateway"
  db:
    image: postgres:13
    environment:
      - POSTGRES_DB=${DB_NAME}
      - POSTGRES_USER=${DB_USER}
      - POSTGRES_PASSWORD=${DB_PASSWORD}

Lassen Sie uns zur Codeaufschlüsselung springen

• Wir ordnen Port 8000 dem Webserver und Port 5679 dem PyCharm-Debugger zu.
• extra_hosts stellt sicher, dass Ihr Docker-Container über host.docker.internal mit der Hostmaschine kommunizieren kann.

Schritt 3: Konfigurieren Sie PyCharm für das Debuggen

1. Erstellen Sie eine Python-Debug-Server-Konfiguration:
2. Navigieren Sie in PyCharm zu „Ausführen“ ➡️ Konfigurationen bearbeiten.
3. Klicken Sie auf die Schaltfläche und wählen Sie Python Debug Server.
4. Stellen Sie den Host auf 0.0.0.0 oder die IP-Adresse Ihres lokalen Computers ein.
5. Stellen Sie den Port auf 5679 ein (oder den, den Sie in Ihrem Docker-Setup offenlegen).

6. Und klicken Sie auf Speichern!

7. Starten Sie den Debugger-Server:
   Starten Sie den PyCharm-Debugger, indem Sie auf die Schaltfläche „Debuggen“ (grünes Fehlersymbol) klicken. Dadurch wird der von uns festgelegte Port überwacht.

Schritt 4: Remote-Debugging-Code zu Django hinzufügen

In Ihrem Django-Projekt müssen Sie den folgenden Code in manage.py oder wsgi.py hinzufügen, um eine Verbindung zum PyCharm-Debugger herzustellen:

import pydevd_pycharm

# Connect to the PyCharm debug server
pydevd_pycharm.settrace('host.docker.internal', port=5679, stdoutToServer=True, stderrToServer=True, suspend=False)

Dieses Snippet weist Ihre Django-App an, sich wieder mit dem PyCharm-Debugger zu verbinden, der auf Ihrem Host-Computer ausgeführt wird. host.docker.internal wird in den Host-Rechner in Docker aufgelöst und port=5679 entspricht dem, den wir zuvor offengelegt haben.

Schritt 5: Führen Sie Docker und Debug aus

1. Docker erstellen und ausführen: Führen Sie den folgenden Befehl aus, um Ihre Container zu starten:

docker-compose up --build

Dadurch wird das Docker-Image erstellt und die Dienste gestartet, einschließlich Django, das im Entwicklungsmodus ausgeführt wird.

2. Haltepunkte setzen:
Legen Sie Haltepunkte in Ihrem Django-Code in PyCharm fest. Die Haltepunkte sollten funktionieren, da Ihr Container eine Verbindung zum PyCharm-Debug-Server herstellt, der auf Port 5679 ausgeführt wird.

3. Lösen Sie Ihren Code aus:
Lösen Sie nun eine beliebige HTTP-Anfrage in Ihrer Django REST Framework API aus. Wenn der Code den Haltepunkt erreicht, pausiert PyCharm die Ausführung, sodass Sie den aktuellen Status überprüfen und den Code schrittweise durchgehen können.

Schritt 6: Fehlerbehebung

Wenn beim Ausführen von Docker der Fehler „Bind: Adresse wird bereits verwendet“ auftritt, verwendet ein anderer Prozess bereits Port 5679. In diesem Fall können Sie Folgendes tun:

• Stoppen Sie den PyCharm-Debugger und starten Sie Docker neu.
• Ändern Sie den Port in Ihrer docker-compose.yml- und PyCharm-Konfiguration, um Konflikte zu vermeiden.

Abschluss

Dies ist das Setup, das ich verwende, um meine Django REST Framework-Anwendung im Entwicklungsmodus in einem Docker-Container mit dem leistungsstarken Debugger von PyCharm auszuführen. Dieses Setup hilft mir beim Debuggen meines Backend-Codes, indem ich den Code Zeile für Zeile lokal durchgehe.

Indem Sie Ihren Docker-Container für die Kommunikation mit PyCharm einrichten, vereinfachen Sie das Schreiben, Testen und Debuggen Ihrer Django-Anwendung und erleichtern so das Schreiben von Code!

Viel Spaß beim Entschlüsseln Ihres Codes!