Skip to main content

Dockerizzare un'app Django con Postgres e Redis

Devin scrive un Dockerfile multi-stage, un file docker-compose.yml con Django, PostgreSQL e Redis, quindi effettua la build ed esegue lo stack per verificare che funzioni.
AuthorCognition
CategorySviluppo di funzionalità
1

(Facoltativo) Definisci l'ambito del progetto con Ask Devin

Se non sei sicuro da quali servizi dipenda la tua app Django o di come è strutturato il progetto, usa Ask Devin per analizzarlo prima:Puoi anche avviare una sessione di Devin direttamente da Ask Devin, e porterà con sé tutto il contesto che ha appreso.
2

Fornisci a Devin il tuo progetto Django e i relativi requirements

Indirizza Devin al progetto Django da containerizzare e indica eventuali requisiti specifici — ad esempio preferenze per l’immagine di base, servizi da cui l’app dipende o vincoli sulle dimensioni dell’immagine. Devin legge i tuoi file requirements.txt o pyproject.toml per occuparsi del resto.
3

Devin analizza e realizza

Devin legge il tuo progetto Django e i file di dipendenze per comprendere il processo di build, quindi genera la configurazione Docker:
  1. Legge i file di dipendenze — Analizza requirements.txt o pyproject.toml e identifica Django, psycopg2, redis, celery e gunicorn
  2. Scrive il Dockerfile — Crea una build multi-stage che installa le dipendenze in una fase builder e copia l’ambiente virtuale in un’immagine di runtime minimale 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. Genera il file docker-compose.yml — Aggiunge Django, PostgreSQL, Redis e un worker Celery con health check, volumi e una rete condivisa
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. Aggiunge .dockerignore — Esclude i file che non devono far parte del contesto di build (__pycache__, .git, tests/, docs/, *.pyc)
  2. Esegue docker compose up --build — Costruisce l’immagine e avvia tutti i servizi nel terminale di Devin
  3. Verifica l’app — Esegue un curl su /api/health/ per confermare che Django si avvia correttamente, si connette a PostgreSQL e raggiunge Redis
4

Gestisci la sessione con i comandi slash

Utilizza i comandi slash durante la sessione per guidare il flusso di lavoro di Devin:
  • /plan — Chiedi a Devin di descrivere il proprio approccio prima di scrivere qualsiasi configurazione Docker. Rivedi il piano e suggerisci modifiche.
  • /test — Di’ a Devin di ricostruire e verificare nuovamente lo stack di container. Usa questo comando dopo ogni modifica per intercettare i problemi in anticipo.
  • /review — Chiedi a Devin di rivedere il proprio Dockerfile e la configurazione Docker Compose per problemi di sicurezza, dimensione dell’immagine e best practice prima di aprire la pull request (PR).
5

Verificare e iterare

Una volta che Devin apre la PR, rivedi i file generati. Follow-up comuni:
6

Rivedi la PR con Devin Review

Una volta che Devin apre la PR, utilizza Devin Review per verificare la configurazione Docker. Devin Review può individuare problemi di sicurezza (esecuzione come root, segreti esposti), best practice mancanti (assenza di un file .dockerignore, mancanza di health check) e incoerenze con la tua infrastruttura esistente.