Depuracion de django con vs code desplegados en docker.

Cómo Depurar un Proyecto en Django Usando el Debugger Integrado de VS Code

Configurar el debugger en VS Code para un proyecto Django puede facilitar enormemente la depuración y mejorar la eficiencia del desarrollo. Aquí te explico paso a paso cómo activar el debugger integrado de VS Code y Docker para un proyecto Django.

Paso 1: Crear el archivo `launch.json`

El archivo launch.json permite configurar el debugger en VS Code. Para comenzar, crea el archivo en la carpeta .vscode y define las configuraciones necesarias para depurar Django:

{
    "configurations": [
        {
            "name": "Depurador de Python: Django",
            "type": "python",
            "request": "attach",
            "pathMappings": [
                {
                  "localRoot": "${workspaceFolder}/app",
                  "remoteRoot": "/app"
                }
              ],
            "port": 8201,
            "host": "127.0.0.1",
            "django": true,
            "autoStartBrowser": false,
            "program": "${workspaceFolder}/app/manage.py"
        },
    ]
}

Con esta configuración, VS Code se conectará al proyecto en el puerto 8201 para iniciar la depuración.

Paso 2: Configurar `manage.py` para Activar el Depurador

Modifica el archivo manage.py para activar el modo de depuración. Esta configuración activa el debugger solo cuando el modo DEBUG está habilitado en Django:

#!/usr/bin/env python
"""Django's command-line utility for administrative tasks."""
import os
import sys


def main():
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "myproject.settings")
    try:
        from django.core.management import execute_from_command_line
    except ImportError as exc:
        raise ImportError(
            "Couldn't import Django. Are you sure it's installed and "
            "available on your PYTHONPATH environment variable? Did you "
            "forget to activate a virtual environment?"
        ) from exc

    from django.conf import settings

    if settings.DEBUG:
        if os.environ.get("RUN_MAIN") or os.environ.get("WERKZEUG_RUN_MAIN"):
            import ptvsd

            ptvsd.enable_attach(address=("0.0.0.0", 8201))
            print("Attached remote debugger to port 8201")

    execute_from_command_line(sys.argv)


if __name__ == "__main__":
    main() 

Paso 3: Configurar el Archivo `docker-compose.yml`

Para permitir que el debugger de VS Code se conecte al contenedor Docker, expón el puerto 8201 en la configuración de Docker:

services:
  db:
    image: postgres:13
    environment:
      POSTGRES_DB: mydatabase
      POSTGRES_USER: myuser
      POSTGRES_PASSWORD: mypassword
    volumes:
      - postgres_data:/var/lib/postgresql/data
    ports:
      - "5440:5432"

  web:
    build: .
    command: python manage.py runserver 0.0.0.0:8000
    volumes:
      - ./app:/app
    ports:
      - "8000:8000"
      - "8201:8201"      
    depends_on:
      - db
    environment:
      - DATABASE_NAME=mydatabase
      - DATABASE_USER=myuser
      - DATABASE_PASSWORD=mypassword
      - DATABASE_HOST=db
      - DATABASE_PORT=5432

volumes:
  postgres_data:

Paso 4: Instalar `ptvsd`

Agrega ptvsd a tu archivo requirements.txt para habilitar la conexión remota de depuración:

Django
psycopg2-binary
ptvsd

Paso 5: Reiniciar los Contenedores de Docker

Para que los cambios surtan efecto, reinicia los servicios en Docker:

  $ docker compose down web
  $ docker compose restart web

Paso 6: Crear una Vista de Prueba en Django

Para confirmar que la depuración funciona correctamente, crea una vista básica en Django

Crear una app de prueba:

$ docker compose run web python manage.py startapp test_depuracion

Añadir una clase de vista (views.py en test_depuracion):

from django.shortcuts import render
from django.views.generic import View
from django.http import HttpResponse

class ErrorView(View):
def get(self, request):
text_1 = "This is a test"
text_2 = "This is a test"
print(text_1)
print(text_2)
return HttpResponse(text_1)

Registrar la vista en las URL (urls.py):

from django.contrib import admin
from django.urls import path
from test_depuracion.views import ErrorView

urlpatterns = [
path('admin/', admin.site.urls),
path('error/', ErrorView.as_view()),
]

Paso 7: Realizar una Prueba de Depuración

1. Coloca un breakpoint en cualquier línea de ErrorView.

2. Activa el depurador en VS Code.

3. Accede a la URL de prueba (/error/).

4. En VS Code, observa que el depurador se activa y permite explorar variables, controlar la ejecución paso a paso y ver el estado en tiempo real.

Con estos pasos, ahora puedes depurar eficazmente tu proyecto Django en VS Code. Este método simplifica el proceso y permite resolver problemas con mayor rapidez y precisión.

El inicio del proyecto lo puedes ver en este link: Django - Docker

código: https://github.com/aztrock/myproject

Python - Voip - Linux