Skip to main content

Eine Django-App mit Postgres und Redis dockerisieren

Devin schreibt ein Multi-Stage-Dockerfile und eine docker-compose.yml mit Django, PostgreSQL und Redis, baut anschließend den Stack und führt ihn aus, um zu prüfen, dass alles funktioniert.
AuthorCognition
CategoryFeature-Entwicklung
1

(Optional) Projektumfang mit Ask Devin festlegen

Wenn du dir nicht sicher bist, von welchen Services deine Django‑App abhängt oder wie das Projekt aufgebaut ist, nutze Ask Devin, um das zuerst zu analysieren:Du kannst auch direkt aus Ask Devin eine Devin-Session starten; dabei werden alle bisherigen Erkenntnisse als Kontext übernommen.
2

Stellen Sie Devin Ihr Django-Projekt und Ihre Requirements zur Verfügung

Weise Devin an, das Django-Projekt zu containerisieren, und erwähne alle Besonderheiten – etwa bevorzugte Basis-Images, Dienste, von denen die App abhängt, oder Einschränkungen bei der Image-Größe. Devin liest deine requirements.txt oder pyproject.toml, um den Rest herauszufinden.
3

Devin analysiert und entwickelt

Devin liest Ihr Django-Projekt und die Abhängigkeitsdateien, um den Build-Prozess zu verstehen, und erstellt dann die Docker-Konfiguration:
  1. Liest Abhängigkeitsdateien — Parst requirements.txt oder pyproject.toml und identifiziert Django, psycopg2, redis, celery und gunicorn
  2. Schreibt das Dockerfile — Erstellt einen mehrstufigen Build, der Abhängigkeiten in einer Builder-Stage installiert und die virtuelle Umgebung in ein minimales python:3.12-slim-Laufzeit-Image kopiert
# ---- 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. Erstellt docker-compose.yml — Fügt Django, PostgreSQL, Redis und einen Celery-Worker mit Healthchecks, Volumes und einem gemeinsamen Netzwerk hinzu
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. Fügt .dockerignore hinzu — Schließt Dateien aus, die nicht in den Build-Kontext gehören (__pycache__, .git, tests/, docs/, *.pyc)
  2. Führt docker compose up --build aus — Baut das Image und startet alle Services im Devin-Terminal
  3. Überprüft die App — Führt einen curl-Aufruf auf /api/health/ aus, um zu bestätigen, dass Django sauber startet, sich mit PostgreSQL verbindet und Redis erreicht
4

Steuern Sie die Sitzung mit Slash-Befehlen

Verwenden Sie während der Sitzung Slash-Befehle, um den Devin-Workflow zu steuern:
  • /plan — Bitten Sie Devin, seinen Ansatz zu skizzieren, bevor es eine Docker-Konfiguration schreibt. Überprüfen Sie den Plan und schlagen Sie Änderungen vor.
  • /test — Weisen Sie Devin an, den Container-Stack neu aufzubauen und erneut zu überprüfen. Verwenden Sie diesen Befehl nach jeder Änderung, um Probleme frühzeitig zu erkennen.
  • /review — Bitten Sie Devin, sein eigenes Dockerfile und die Docker-Compose-Konfiguration auf Sicherheitsprobleme, Imagegröße und Best Practices zu prüfen, bevor der PR erstellt wird.
5

Prüfen und iterieren

Sobald Devin den Pull Request (PR) eröffnet, überprüfe die generierten Dateien. Häufige Folgeaufgaben:
6

Überprüfen Sie den Pull Request mit Devin Review

Sobald Devin den PR eröffnet hat, verwenden Sie Devin Review, um die Docker-Konfiguration zu überprüfen. Devin Review kann Sicherheitsprobleme erkennen (Ausführung als root, offengelegte Geheimnisse), fehlende Best Practices identifizieren (keine .dockerignore, keine Health Checks) sowie Inkonsistenzen mit Ihrer bestehenden Infrastruktur aufdecken.