Faire en sorte que votre configuration locale débogue correctement le code que vous écrivez prend plus de temps que n'importe quel développeur ne voudrait l'admettre. Et n'oublions pas qu'il s'agit principalement d'une configuration unique, donc si nous ne l'écrivons pas, nous ne nous en souviendrons pas. Cet article est là pour résoudre exactement ce problème ! Laissez ceci vous servir de rappel écrit sur la manière de mettre en place et de faire fonctionner votre environnement de développement local.

Prérequis :

• PyCharm Professional (pour la prise en charge de Docker)
• Docker et Docker Compose
• Application Django REST Framework (DRF)

Cet article ne couvrira pas les détails de la configuration de Django, Docker ou Docker Composer en dehors des mises à jour nécessaires au mode débogage. Cela suppose que vous avez déjà une connaissance pratique de la façon de faire fonctionner cette pièce.

Étape 1 : configuration de Dockerfile pour le débogage

Configurez votre Dockerfile pour qu'il s'exécute en mode développement et autorisez les connexions à partir du débogueur PyCharm.

Vous trouverez ci-dessous un exemple de Dockerfile :

# 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"]

Ce qu'il faut garder à l'esprit à propos de ce code

• 241.17890.14 dans pydevd-pycharm==241.17890.14 va être différent selon la version de Pycharm que vous avez
• Nous exposons à la fois 8000 (le port du serveur Web) et 5679 (le port du débogueur) pour un accès externe.

Étape 2 : Configuration de Docker Compose

Laissons notre fichier docker-compose.yml configurer le service Web (application Django) ainsi que la base de données et d'autres services.

Voici un exemple de 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}

Passons à la répartition du code

• Nous mappons le port 8000 pour le serveur Web et le port 5679 pour le débogueur PyCharm.
• extra_hosts garantit que votre conteneur Docker peut communiquer avec la machine hôte à l'aide de host.docker.internal.

Étape 3 : configurer PyCharm pour le débogage

1. Créer une configuration de serveur de débogage Python :
2. Dans PyCharm, accédez à Exécuter ➡️ Modifier les configurations.
3. Cliquez sur le bouton et sélectionnez Python Debug Server.
4. Définissez l'hôte sur 0.0.0.0 ou l'adresse IP de votre ordinateur local.
5. Définissez le port sur 5679 (ou celui que vous exposez dans votre configuration Docker).

6. Et appuyez sur Enregistrer !

7. Démarrez le serveur du débogueur :
   Démarrez le débogueur PyCharm en cliquant sur le bouton Déboguer (icône de bug verte). Cela commencera à écouter sur le port que nous avons défini.

Étape 4 : Ajouter le code de débogage à distance à Django

Dans votre projet Django, vous devrez ajouter le code suivant dans votre manage.py ou wsgi.py pour vous connecter au débogueur PyCharm :

import pydevd_pycharm

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

Cet extrait indique à votre application Django de se reconnecter au débogueur PyCharm exécuté sur votre machine hôte. host.docker.internal se résout en machine hôte dans Docker et port=5679 correspond à celui que nous avons exposé précédemment.

Étape 5 : Exécutez Docker et déboguez

1. Construire et exécuter Docker : Exécutez la commande suivante pour démarrer vos conteneurs :

docker-compose up --build

Cela créera l'image Docker et démarrera les services, y compris Django exécuté en mode développement.

2. Définir des points d'arrêt :
Définissez des points d'arrêt dans votre code Django dans PyCharm. Les points d'arrêt devraient fonctionner car votre conteneur se connectera au serveur de débogage PyCharm exécuté sur le port 5679.

3. Déclenchez votre code :
Maintenant, déclenchez n’importe quelle requête HTTP dans votre API Django REST Framework. Lorsque le code atteint le point d'arrêt, PyCharm suspend l'exécution, vous permettant d'inspecter l'état actuel et de parcourir le code.

Étape 6 : Dépannage

Si vous rencontrez l'erreur bind: adresse déjà utilisée lors de l'exécution de Docker, un autre processus utilise déjà le port 5679. Dans ce cas, vous pouvez :

• Arrêtez le débogueur PyCharm et redémarrez Docker.
• Modifiez le port dans votre configuration docker-compose.yml et PyCharm pour éviter les conflits.

Conclusion

Il s'agit de la configuration que j'utilise pour exécuter mon application Django REST Framework en mode développement dans un conteneur Docker à l'aide du puissant débogueur de PyCharm. Cette configuration m'aide à déboguer mon code backend en parcourant le code ligne par ligne, le tout localement.

En configurant votre conteneur Docker pour communiquer avec PyCharm, vous simplifiez l'écriture, les tests et le débogage de votre application Django, facilitant ainsi l'écriture de code !

Amusez-vous à casser votre code !