¿Prefieres no configurarlo manualmente? Pega un enlace a esta página en una sesión de Devin y pídele que lo configure todo por ti. Si no estás seguro de de qué servicios depende tu aplicación Django o cómo está estructurado el proyecto, usa [Ask Devin](https://app.devin.ai/search?utm_source=docs\&utm_medium=use-case-gallery) para investigarlo primero: ```txt Delimita el alcance del proyecto Django para su contenedorización theme={null} ¿De qué depende nuestra app de Django en src/? 1. ¿A qué bases de datos y cachés se conecta? 2. ¿Usa Celery u otros workers en segundo plano? 3. ¿Qué hay en requirements.txt o pyproject.toml? 4. ¿Existen archivos de Docker o configuraciones de despliegue? 5. ¿Cómo gestiona la app los archivos estáticos y el contenido multimedia? ``` También puedes iniciar una sesión de Devin directamente desde Ask Devin, y conservará todo lo que haya aprendido como contexto. Indica a Devin a qué proyecto de Django quieres aplicar contenedores y menciona cualquier detalle específico: preferencias de imagen base, servicios de los que depende la app o restricciones de tamaño de la imagen. Devin lee tu `requirements.txt` o `pyproject.toml` para encargarse del resto. ```txt Dockerize Django API with Postgres and Redis theme={null} Dockeriza la API de Django en src/. Usa PostgreSQL para la base de datos y Redis para la caché y las colas de tareas de Celery. - Dockerfile multi-stage: instala las dependencias en una etapa de build y copia solo el venv en una imagen de tiempo de ejecución slim basada en python:3.12-slim - docker-compose.yml con Django (gunicorn), PostgreSQL 16 y Redis 7 - .dockerignore que excluya tests, docs, .git y __pycache__ - Ejecutar como usuario sin privilegios (non-root) - Comprobación de estado en /api/health/ - Worker de Celery como servicio separado en compose ## Pruebas y verificación - Construye la imagen y ejecuta docker-compose up - Espera a que todos los servicios estén en estado healthy - Verifica que la API responda en localhost:8000/api/health/ - Ejecuta la suite de pruebas de Django dentro del contenedor - Si algo falla — errores de build, variables de entorno ausentes, problemas de conexión, pruebas fallidas — depura y corrige. Sigue iterando hasta que toda la pila arranque limpiamente y todas las pruebas pasen. - No abras un pull request (PR) hasta que todo funcione de extremo a extremo ``` Devin lee tu proyecto Django y los archivos de dependencias para entender el proceso de compilación, y luego crea la configuración de Docker: 1. **Lee los archivos de dependencias** — Analiza `requirements.txt` o `pyproject.toml`, identifica Django, psycopg2, redis, celery y gunicorn 2. **Escribe el Dockerfile** — Crea un proceso de compilación en múltiples etapas que instala las dependencias en una etapa de compilación y copia el entorno virtual en una imagen mínima de ejecución `python:3.12-slim` ```dockerfile theme={null} # ---- Builder ---- FROM python:3.12-slim AS builder WORKDIR /app COPY requirements.txt . RUN python -m venv /opt/venv \ && /opt/venv/bin/pip install --no-cache-dir -r requirements.txt # ---- Runtime ---- FROM python:3.12-slim RUN groupadd -r django && useradd -r -g django django COPY --from=builder /opt/venv /opt/venv ENV PATH="/opt/venv/bin:$PATH" WORKDIR /app COPY src/ . RUN python manage.py collectstatic --noinput EXPOSE 8000 USER django CMD ["gunicorn", "config.wsgi:application", "--bind", "0.0.0.0:8000", "--workers", "3"] ``` 3. **Crea el archivo docker-compose.yml** — Agrega Django, PostgreSQL, Redis y un worker de Celery con health checks, volúmenes y una red compartida ```yaml theme={null} services: web: build: . ports: - "8000:8000" env_file: .env depends_on: db: condition: service_healthy redis: condition: service_healthy healthcheck: test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8000/api/health/')"] interval: 10s retries: 3 db: image: postgres:16-alpine environment: POSTGRES_DB: app_db POSTGRES_USER: app_user POSTGRES_PASSWORD: app_pass volumes: - pgdata:/var/lib/postgresql/data healthcheck: test: ["CMD-SHELL", "pg_isready -U app_user -d app_db"] interval: 5s retries: 5 redis: image: redis:7-alpine healthcheck: test: ["CMD", "redis-cli", "ping"] interval: 5s retries: 5 celery: build: . command: celery -A config worker -l info env_file: .env depends_on: db: condition: service_healthy redis: condition: service_healthy volumes: pgdata: ``` 4. **Agrega .dockerignore** — Excluye archivos que no pertenecen al contexto de compilación (`__pycache__`, `.git`, `tests/`, `docs/`, `*.pyc`) 5. **Ejecuta `docker compose up --build`** — Construye la imagen e inicia todos los servicios en la terminal de Devin 6. **Verifica la app** — Ejecuta `curl` sobre `/api/health/` para confirmar que Django inicia correctamente, se conecta a PostgreSQL y puede acceder a Redis Usa comandos de barra inclinada durante la sesión para dirigir el flujo de trabajo de Devin: * **`/plan`** — Pídele a Devin que describa su enfoque antes de escribir cualquier configuración de Docker. Revisa el plan y sugiere cambios. * **`/test`** — Indícale a Devin que vuelva a compilar y volver a verificar el stack de contenedores. Úsalo después de cada cambio para detectar problemas lo antes posible. * **`/review`** — Pídele a Devin que revise su propio Dockerfile y la configuración de Docker Compose en busca de problemas de seguridad, tamaño de imagen y buenas prácticas antes de abrir el pull request (PR). Cuando Devin abra el pull request (PR), revisa los archivos generados. Acciones de seguimiento habituales: ```txt Optimizar el tamaño de la imagen theme={null} La imagen de Docker pesa 520 MB. Redúcela: asegúrate de que no copiamos archivos innecesarios, elimina los archivos .pyc del venv y quita pip de la imagen final. ``` ```txt Añadir hot-reload para desarrollo theme={null} Añade un docker-compose.override.yml para desarrollo local que monte el directorio de código fuente y ejecute el servidor de desarrollo de Django con auto-reload en lugar de gunicorn. ``` ```txt Añadir build de Docker en CI theme={null} Crea un workflow de GitHub Actions que construya la imagen de Docker en cada PR, ejecute pytest dentro del contenedor y haga push a ECR al hacer merge en main. Etiqueta las imágenes con el SHA de git. ``` Una vez que Devin abra el PR, usa [Devin Review](https://app.devin.ai/review?utm_source=docs\&utm_medium=use-case-gallery) para revisar la configuración de Docker. Devin Review puede detectar problemas de seguridad (ejecución como root, secretos expuestos), ausencia de buenas prácticas (sin `.dockerignore`, sin health checks) e inconsistencias con tu infraestructura existente.

{title}