Django mit Docker starten - So geht's

Es gibt viele Wege, Django zu installieren, aber Docker ist nicht nur der einfachste Weg, um schnell loszulegen – es macht es auch super einfach, dein Setup mit anderen zu teilen und die Produktionsumgebung möglichst genau abzubilden.

In diesem Tutorial richten wir eine neue Django App mit Docker ein und nutzen dabei etwas AI-unterstütztes Coding, um das Ganze zu beschleunigen.

Voraussetzungen

Bevor wir starten, brauchst du Docker auf deinem Rechner. Du kannst der Anleitung auf der Docker-Website folgen, um Docker zu installieren – je nach Betriebssystem.

Ich schreibe dieses Tutorial auf macOS, aber die Schritte sollten unter Linux und Windows ähnlich sein.

Vibe Coding für das initiale Setup

Los geht's mit dem Boilerplate. Ich nutze VS Code zusammen mit GitHub Copilot, um das Ganze zu beschleunigen.

Um den Copilot Chat zu öffnen, nutze den Shortcut Cmd + Shift + I, wähle den Agent Mode und fang an zu prompten. Ich habe Claude Opus 4.5 (Preview) als Modell verwendet. Hier ist mein Prompt:

setup a django app in docker

Der Prompt hat folgende Dateien und Ordner generiert:

• myproject Ordner – enthält den gesamten Django Code (du kannst den Ordner umbenennen, aber vergiss nicht, die Referenzen im Dockerfile und anderen Configs anzupassen)
• Dockerfile – Anweisungen zum Bauen des Docker Images
• docker-compose.yml – orchestriert das Docker Image und den Datenbank-Service
• requirements.txt – Python Dependencies
• manage.py – Django Management Script
• .dockerignore – Dateien, die beim Image-Build ignoriert werden sollen
• .gitignore – Dateien, die im Git Repository ignoriert werden sollen

Das initiale Ergebnis ist ein guter Startpunkt, aber wir können es noch verbessern. Ich zeige dir unten ein paar Optimierungen, aber du kannst dir auch das fertige Projekt auf GitHub anschauen.

Dockerfile

Das Dockerfile ist die Blaupause zum Bauen des Docker Images. Es sagt Docker, wie ein Container mit allen Dependencies erstellt werden soll, die deine Django App braucht. Für mehr Details, schau dir die Dockerfile Referenz an.

Das Dockerfile, das Copilot im ersten Entwurf erstellt hat, funktioniert zwar, hatte aber in meinem Fall ein paar Probleme, die verbessert werden konnten:

• Keine Multi-Stage Builds – die Image-Größe könnte reduziert werden
• Kein non-root User – das ist eine Sicherheitslücke und sollte behoben werden

Ich habe diesen Guide auf dem Docker Blog gefunden, der ein optimiertes Dockerfile für Django Apps vorschlägt. Wenn du tiefer einsteigen willst, kann ich dir den Artikel empfehlen.

Hier ist das finale Dockerfile mit diesen Optimierungen:

# Stage 1: Base build stage
FROM python:3.13-slim AS builder
 
# Create the app directory
RUN mkdir /app
 
# Set the working directory
WORKDIR /app
 
# Set environment variables to optimize Python
ENV PYTHONDONTWRITEBYTECODE=1
ENV PYTHONUNBUFFERED=1 
 
# Upgrade pip and install dependencies
RUN pip install --upgrade pip 
 
# Copy the requirements file first (better caching)
COPY requirements.txt /app/
 
# Install Python dependencies
RUN pip install --no-cache-dir -r requirements.txt
 
# Stage 2: Production stage
FROM python:3.13-slim
 
RUN useradd -m -r appuser && \
   mkdir /app && \
   chown -R appuser /app
 
# Copy the Python dependencies from the builder stage
COPY --from=builder /usr/local/lib/python3.13/site-packages/ /usr/local/lib/python3.13/site-packages/
COPY --from=builder /usr/local/bin/ /usr/local/bin/
 
# Set the working directory
WORKDIR /app
 
# Copy application code
COPY --chown=appuser:appuser . .
 
# Set environment variables to optimize Python
ENV PYTHONDONTWRITEBYTECODE=1
ENV PYTHONUNBUFFERED=1 
 
# Switch to non-root user
USER appuser
 
# Expose the application port
EXPOSE 8000 
 
# Start the application using Gunicorn
CMD ["gunicorn", "--bind", "0.0.0.0:8000", "--workers", "3", "myproject.wsgi:application"]

Diese optimierte Version:

• Nutzt Multi-Stage Builds, um das finale Image klein zu halten
• Erstellt einen non-root User für bessere Sicherheit
• Verwendet Gunicorn statt des Django Development Servers für Production

docker-compose.yml

Die docker-compose.yml Datei ermöglicht es dir, die Run-Konfiguration für mehrere Services zu definieren. Für Django brauchen wir typischerweise mindestens zwei Services: die Web-Anwendung und eine Datenbank. PostgreSQL ist die beliebteste Wahl für Django Projekte.

Für mehr Details, schau dir die Compose file Referenz an.

Ähnlich wie beim Dockerfile funktioniert der initiale Entwurf von Copilot, kann aber verbessert werden:

Environment Variables wurden direkt in die Datei geschrieben. Das ist nicht empfehlenswert, da du so leicht Secrets leaken oder versehentlich in Git committen kannst.

Erstelle stattdessen eine .env Datei und schreibe alle Environment Variables dort rein:

# Postgres
POSTGRES_DB=django_db
POSTGRES_USER=postgres
POSTGRES_PASSWORD=your_secure_password

# Django
ALLOWED_HOSTS=localhost,0.0.0.0
CSRF_TRUSTED_ORIGINS=localhost,0.0.0.0
DATABASE_URL=psql://postgres:your_secure_password@db:5432/django_db
DEBUG=1

Wichtig: Stelle sicher, dass du alle Credentials ersetzt und die Datenbank-Verbindungsparameter bei Bedarf anpasst.

Hinweis: Die App, die Copilot ausgespuckt hat, parst die ALLOWED_HOSTS und CSRF_TRUSTED_ORIGINS aus Environment Variables. Stelle sicher, dass deine Django Settings entsprechend angepasst sind.

Ich habe auch noch ein paar andere Dinge aufgeräumt, die CoPilot eingeschmuggelt hat:

• den version Tag – der ist in den neuesten Docker Compose Versionen deprecated
• ein Command Override, das den Django Development Server statt Gunicorn verwendet hat
• ein Bind Mount für den App-Ordner, der manchmal für Development genutzt wird
• Postgres auf Version 17 geupgradet und den Mount-Pfad für das Data Volume entsprechend angepasst

Und hier bin ich gelandet:

services:
  web:
    build: .
    ports:
      - "8000:8000"
    env_file:
      - .env
    depends_on:
      - db

  db:
    image: postgres:17
    volumes:
      - postgres_data:/var/lib/postgresql/data
    env_file:
      - .env

volumes:
  postgres_data:

Vergiss nicht, .env zu deiner .gitignore Datei hinzuzufügen.

Die App starten

Du kannst die App mit Docker Compose hochfahren:

docker compose up -d

Das -d Flag startet die Container im Detached Mode (im Hintergrund). Um zu prüfen, ob alles läuft:

docker compose ps

Um die Logs anzuzeigen:

docker compose logs -f

Sobald alles läuft, kannst du deine Django App unter http://localhost:8000 aufrufen.

In die Cloud deployen

Du kannst diese dockerisierte Django App ganz einfach bei jedem Cloud-Anbieter deployen, der Docker unterstützt. Für dieses Tutorial nutzen wir Sliplane, das es super einfach macht, Docker-Anwendungen zu deployen.

Bevor wir loslegen, stelle sicher, dass du dein Projekt in ein GitHub Repository gepusht hast – wir werden es direkt von dort deployen. Sliplane erstellt eine praktische Deployment Pipeline, die automatisch neue Commits aus dem Repository baut und deployed.

Sobald das Repo auf GitHub ist, starten wir mit dem Deployment einer Datenbank, indem wir Sliplanes One-Click-Deploy Preset für Postgres nutzen:

1.) Logge dich bei sliplane.io mit deinem GitHub Account ein 2.) Erstelle ein neues Projekt und gib ihm einen Namen 3.) Klicke im Projekt auf "Deploy Service" 4.) Wähle einen Server zum Deployen aus, oder erstelle einen neuen, falls du noch keinen hast. Der Base Server sollte stark genug sein, um deine Django App und die Datenbank zu betreiben. 5.) Wähle den Server aus und klicke auf "Add service". Wähle das Postgres Preset aus. Du kannst die Preset-Einstellungen bei Bedarf anpassen. Wir deaktivieren den Public Toggle, da die Datenbank nicht öffentlich erreichbar sein sollte, und klicken auf "Add service" oben rechts.

Django deployen:

6.) Klicke erneut auf "Add service" und wähle "Repository" als Deploy Source 7.) Suche dein Django Projekt im Repository-Eingabefeld und wähle es aus. Diesmal stelle sicher, dass der Public Toggle an ist – mit dem Standard-HTTP-Protokoll und Healthcheck-Pfad. 8.) Füge die folgenden Environment Variables zum Env-Eingabefeld hinzu und passe die Werte entsprechend an:

ALLOWED_HOSTS="$SLIPLANE_DOMAIN"
CSRF_TRUSTED_ORIGINS="https://$SLIPLANE_DOMAIN"
DATABASE_URL="psql://POSTGRES_USER:POSTGRES_PASSWORD@POSTGRES_INTERNAL_HOST/POSTGRES_DATABASE" # ersetze mit deinem tatsächlichen Datenbank-Connection-String

Nutze die Credentials der Datenbank, die wir gerade konfiguriert haben, um dich zu verbinden. Du kannst den internen Hostnamen mit diesem Pattern referenzieren: ${SERVICE_NAME}.INTERNAL_HOST, also falls deine Datenbank db heißt, wird der interne Hostname zu DB.INTERNAL_HOST.

Wir referenzieren auch die von Sliplane zugewiesene Domain unserer Django App mit der eingebauten $SLIPLANE_DOMAIN Variable.

9.) Nachdem du die Environment Variables hinzugefügt hast, stelle sicher, dass der Public Toggle an ist. Klicke auf "Add service" und "Deploy". Sobald das Deployment abgeschlossen ist, ist deine Django App live und mit der PostgreSQL Datenbank verbunden, die du vorher eingerichtet hast. Du kannst sie über die von Sliplane zugewiesene Domain erreichen.

10.) Nachdem die Services deployed wurden, kannst du dich per SSH mit dem Service verbinden und die Datenbank-Migrationen ausführen:

python manage.py migrate

Und einen Superuser erstellen, um auf das Django Admin zuzugreifen:

python manage.py createsuperuser

Jetzt kannst du dich im Django Admin unter https://dein-django-service.sliplane.app/admin mit den Superuser-Credentials einloggen, die du gerade erstellt hast.

Zusammenfassung

Django in Docker zu betreiben macht es einfach, schnell loszulegen und dein Setup mit deinem Team zu teilen. Du arbeitest außerdem nah an der Produktionsumgebung, was die gefürchteten "Works on my machine"-Probleme vermeidet.

Du kannst AI-Tools wie GitHub Copilot nutzen, um einen ersten Entwurf des Django Docker Setups zu generieren, aber vergiss nicht, die generierten Dateien wie in diesem Guide beschrieben zu reviewen und zu optimieren.

Um deine dockerisierte Django App zu deployen, kannst du Sliplane nutzen, um die App innerhalb von Minuten in der Cloud zum Laufen zu bringen!