Skip to main content

Dockerizar una aplicación Django con Postgres y Redis

Devin escribe un Dockerfile multietapa, un docker-compose.yml con Django, PostgreSQL y Redis, luego construye y ejecuta el stack para verificar que funcione.
AuthorCognition
CategoryDesarrollo de funcionalidades
1

(Opcional) Define el alcance del proyecto con Ask Devin

Si no estás seguro de de qué servicios depende tu aplicación Django o cómo está estructurado el proyecto, usa Ask Devin para investigarlo primero:También puedes iniciar una sesión de Devin directamente desde Ask Devin, y conservará todo lo que haya aprendido como contexto.
2

Proporciona a Devin tu proyecto de Django y sus dependencias

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.
3

Devin investiga y desarrolla

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
# ---- 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"]
  1. Crea el archivo docker-compose.yml — Agrega Django, PostgreSQL, Redis y un worker de Celery con health checks, volúmenes y una red compartida
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:
  1. Agrega .dockerignore — Excluye archivos que no pertenecen al contexto de compilación (__pycache__, .git, tests/, docs/, *.pyc)
  2. Ejecuta docker compose up --build — Construye la imagen e inicia todos los servicios en la terminal de Devin
  3. Verifica la app — Ejecuta curl sobre /api/health/ para confirmar que Django inicia correctamente, se conecta a PostgreSQL y puede acceder a Redis
4

Guía la sesión con comandos slash

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).
5

Verifica e itera

Cuando Devin abra el pull request (PR), revisa los archivos generados. Acciones de seguimiento habituales:
6

Revisa el PR con Devin Review

Una vez que Devin abra el PR, usa Devin Review 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.