Skip to content

Django Spickzettel

Hochentwickeltes Python-Web-Framework für schnelle, sichere Entwicklung.

01

Einstieg

Installieren & Projekt anlegen

Django über pip installieren. Ein Projekt hält Einstellungen und URLs; eine App ist ein wiederverwendbares Modul mit Models und Views.

django
pip install django
django-admin startproject myproject
cd myproject
python manage.py startapp myapp

Entwicklungsserver starten

Startet den eingebauten Dev-Server mit Auto-Reload. Niemals in Produktion einsetzen.

django
python manage.py runserver
# Default: http://127.0.0.1:8000
python manage.py runserver 8080
python manage.py runserver 0.0.0.0:8000

Migrations & Superuser

makemigrations erzeugt Migrationsdateien aus Modell-Änderungen. migrate wendet sie auf die DB an. createsuperuser legt ein Admin-Konto an.

django
python manage.py makemigrations
python manage.py migrate
python manage.py createsuperuser

Projektstruktur

manage.py ist das CLI-Tool. Das innere Paket hält die Projektkonfiguration; das App-Verzeichnis hält den App-Code.

django
myproject/
  manage.py            # CLI utility
  myproject/
    settings.py        # Configuration
    urls.py            # Root URL dispatcher
    wsgi.py            # WSGI entry point
    asgi.py            # ASGI entry point
  myapp/
    models.py          # Database models
    views.py           # View functions
    admin.py           # Admin registration

Settings-Grundlagen

INSTALLED_APPS listet die aktiven Apps. In Produktion DEBUG=False setzen und ALLOWED_HOSTS konfigurieren.

django
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'myapp',
]
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}
DEBUG = True
ALLOWED_HOSTS = []
02

Model-Felder

Ein Model definieren

Jede Model-Klasse mappt auf eine DB-Tabelle. Jedes Feld mappt auf eine Spalte. __str__ definiert den Anzeigenamen.

django
from django.db import models

class Article(models.Model):
    title = models.CharField(max_length=200)
    body = models.TextField()
    published = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.title

Häufige Feldtypen

CharField verlangt max_length. auto_now_add setzt bei Erzeugung; auto_now aktualisiert bei jedem Speichern. EmailField/URLField ergänzen Validierung.

django
name = models.CharField(max_length=100)
description = models.TextField(blank=True)
price = models.DecimalField(max_digits=10, decimal_places=2)
quantity = models.IntegerField(default=0)
is_active = models.BooleanField(default=True)
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
email = models.EmailField(unique=True)
url = models.URLField(blank=True)

Feld-Optionen

null ist DB-Ebene; blank ist Validierungsebene. choices erzeugt ein Dropdown in Formularen und im Admin.

django
title = models.CharField(
    max_length=200,
    null=True,          # DB allows NULL
    blank=True,         # Form allows empty
    default='',
    choices=[('draft', 'Draft'), ('pub', 'Published')],
    help_text='Article title',
    verbose_name='Article Title',
)

Meta-Optionen

ordering setzt die Standard-Sortierung. db_table überschreibt den automatisch generierten Tabellennamen. constraints erzwingen DB-Ebene-Regeln.

django
class Meta:
    ordering = ['-created_at']
    db_table = 'articles'
    verbose_name_plural = 'Articles'
    constraints = [
        models.UniqueConstraint(
            fields=['title', 'author'],
            name='unique_title_per_author',
        )
    ]

Model-Methoden & Properties

save() überschreiben für Logik vor dem Speichern. @property ergänzt berechnete Attribute. Immer super().save() aufrufen.

django
class Article(models.Model):
    title = models.CharField(max_length=200)
    views = models.IntegerField(default=0)

    def __str__(self):
        return self.title

    def save(self, *args, **kwargs):
        self.title = self.title.strip()
        super().save(*args, **kwargs)

    @property
    def is_popular(self):
        return self.views > 1000
03

Model-Beziehungen

ForeignKey (Many-to-One)

ForeignKey erzeugt eine Many-to-One-Beziehung. related_name ermöglicht Rückwärtsabfragen: author.books.all().

django
class Author(models.Model):
    name = models.CharField(max_length=100)

class Book(models.Model):
    author = models.ForeignKey(
        Author,
        on_delete=models.CASCADE,
        related_name='books',
    )
    title = models.CharField(max_length=200)

OneToOneField

OneToOneField erzeugt eine Eins-zu-eins-Verknüpfung. Zugriff über user.profile oder profile.user.

django
class Profile(models.Model):
    user = models.OneToOneField(
        User,
        on_delete=models.CASCADE,
    )
    bio = models.TextField()

ManyToManyField

ManyToManyField erzeugt automatisch eine Junction-Tabelle. Hinzufügen/Entfernen: course.students.add(student).

django
class Student(models.Model):
    name = models.CharField(max_length=100)

class Course(models.Model):
    students = models.ManyToManyField(Student, blank=True)
    title = models.CharField(max_length=200)

on_delete-Optionen

CASCADE löscht Kinder, wenn das Elternteil gelöscht wird. SET_NULL verlangt null=True. PROTECT wirft ProtectedError.

django
# CASCADE - delete related objects
author = models.ForeignKey(Author, on_delete=models.CASCADE)

# SET_NULL - set to NULL (field must be nullable)
author = models.ForeignKey(Author, on_delete=models.SET_NULL, null=True)

# PROTECT - prevent deletion
author = models.ForeignKey(Author, on_delete=models.PROTECT)

# SET_DEFAULT - set to default value
author = models.ForeignKey(Author, on_delete=models.SET_DEFAULT, default=1)

Verknüpfte Objekte abfragen

Vorwärtszugriff über den Feldnamen. Rückwärtszugriff über related_name (standardmäßig modelname_set).

django
# Forward query
book.author.name

# Reverse query (uses related_name)
author.books.all()
author.books.filter(title__contains='Django')

# Add/remove in M2M
course.students.add(student1, student2)
course.students.remove(student1)
course.students.clear()

# Check membership
student in course.students.all()
04

ORM QuerySet

Objekte erzeugen & speichern

create() speichert sofort. get_or_create gibt (object, created_bool) zurück — atomares Holen oder Erzeugen.

django
# Method 1: Create and save separately
article = Article(title='Hello', body='World')
article.save()

# Method 2: Create in one step
article = Article.objects.create(title='Hello', body='World')

# Method 3: get_or_create
obj, created = Article.objects.get_or_create(
    title='Hello', defaults={'body': 'World'}
)

Einzelnes Objekt abrufen

get() wirft DoesNotExist, wenn nichts gefunden, MultipleObjectsReturned bei mehreren. first() zum sicheren Holen eines Objekts verwenden.

django
# Get by primary key
article = Article.objects.get(pk=1)

# Get by field
article = Article.objects.get(title='Hello')

# First/last (returns None if empty)
first = Article.objects.first()
last = Article.objects.last()

# Latest/earliest by field
latest = Article.objects.latest('created_at')

Filter & Exclude

filter() gibt ein QuerySet zurück (lazy). Verkettungen wenden UND-Logik an. QuerySets werden erst beim Iterieren ausgewertet.

django
# Filter
Article.objects.filter(title__contains='Django')
Article.objects.filter(published=True)

# Exclude
Article.objects.exclude(views__lt=100)

# Chain filters (AND)
Article.objects.filter(author=1).exclude(draft=True)

Field-Lookups

Lookups nutzen die Doppel-Unterstrich-Syntax. Häufig: exact, contains, icontains, gt, gte, lt, lte, in, startswith, range.

django
Article.objects.filter(title__icontains='django')  # case-insensitive
Article.objects.filter(views__gte=100)              # >=
Article.objects.filter(views__in=[100, 200, 300])   # IN
Article.objects.filter(created_at__year=2024)       # date lookup
Article.objects.filter(title__startswith='Hello')   # LIKE 'Hello%'
Article.objects.filter(title__isnull=True)          # IS NULL

Sortierung & Slicing

Slicing setzt LIMIT auf DB-Ebene. Negative Indizierung wird bei QuerySets nicht unterstützt.

django
# Order by
Article.objects.order_by('-created_at')  # descending
Article.objects.order_by('author', '-views')

# Slice (LIMIT/OFFSET)
Article.objects.all()[:5]       # first 5
Article.objects.all()[5:10]     # offset 5, limit 5
Article.objects.order_by('-views')[:3]  # top 3

# Distinct
Article.objects.values('author').distinct()

Update & Delete

update() ist effizient für Massenänderungen. save(update_fields=[...]) vermeidet Race Conditions. delete() kaskadiert standardmäßig.

django
# Bulk update
Article.objects.filter(draft=True).update(draft=False)

# Single update (only save this field)
article.title = 'New Title'
article.save(update_fields=['title'])

# Delete
article.delete()  # returns (count, {model: count})
Article.objects.filter(views=0).delete()  # bulk delete
05

ORM Fortgeschritten

F-Ausdrücke

F() referenziert einen DB-Spaltenwert und ermöglicht atomare Updates, ohne das Objekt nach Python zu laden.

django
from django.db.models import F

# Atomic increment (no race condition)
Article.objects.filter(pk=1).update(views=F('views') + 1)

# Compare two fields
Article.objects.filter(views__gt=F('min_views'))

# Arithmetic on fields
Article.objects.annotate(ratio=F('views') / F('likes'))

Q-Objekte für komplexe Abfragen

Q-Objekte ermöglichen ODER (|), UND (&) und NICHT (~) Logik. Ohne Q sind mehrere filter()-Aufrufe nur UND-verknüpft.

django
from django.db.models import Q

# OR
Article.objects.filter(Q(title__contains='Django') | Q(title__contains='Flask'))

# AND with NOT
Article.objects.filter(Q(published=True) & ~Q(views=0))

# OR + AND
Article.objects.filter(
    (Q(author=1) | Q(author=2)) & Q(published=True)
)

Aggregation

aggregate() gibt ein Dict mit Summen zurück. annotate() ergänzt berechnete Werte pro Objekt.

django
from django.db.models import Count, Sum, Avg, Max, Min

# Single aggregate
total = Article.objects.aggregate(total=Count('id'))
avg_views = Article.objects.aggregate(Avg('views'))

# Per-group aggregate
Author.objects.annotate(
    article_count=Count('article'),
    total_views=Sum('article__views'),
)

Annotate

annotate() ergänzt berechnete Felder pro Objekt. Auf annotierten Feldern lässt sich filter() und order_by() anwenden.

django
from django.db.models import Count, Avg

# Add computed field to each object
authors = Author.objects.annotate(article_count=Count('book'))

# Filter on annotated field
Author.objects.annotate(
    avg_rating=Avg('book__rating')
).filter(avg_rating__gte=4.0)

select_related & prefetch_related

select_related nutzt SQL JOIN (vorwärts FK). prefetch_related nutzt eine zweite Abfrage (rückwärts/M2M). Beide verhindern N+1-Queries.

django
# select_related (FK/OneToOne - single query with JOIN)
books = Book.objects.select_related('author').all()
# book.author.name  -> no extra query

# prefetch_related (M2M/reverse - second query)
authors = Author.objects.prefetch_related('books').all()
# author.books.all()  -> no extra query

# Deep prefetch
Author.objects.prefetch_related('books', 'books__reviews').all()
06

Function-Based Views

Einfache Function-View

Eine View nimmt ein HttpRequest und gibt ein HttpResponse zurück. render() lädt ein Template und füllt es mit Kontext.

django
from django.shortcuts import render
from django.http import HttpResponse

def hello(request):
    return HttpResponse("Hello, World!")

def home(request):
    context = {'title': 'Home', 'items': [1, 2, 3]}
    return render(request, 'home.html', context)

HttpRequest-Objekt

request.GET/POST sind QueryDict (sicherheitshalber .get() verwenden). request.user ist der authentifizierte Nutzer oder AnonymousUser.

django
def my_view(request):
    method = request.method           # 'GET' or 'POST'
    get_data = request.GET.get('q')   # query param
    post_data = request.POST.get('name')
    path = request.path               # '/articles/1/'
    user = request.user               # current user
    files = request.FILES             # uploaded files
    meta = request.META.get('HTTP_HOST')

HttpResponse-Typen

JsonResponse serialisiert nach JSON. redirect() nimmt einen URL-Pfad oder eine benannte URL mit Argumenten.

django
from django.http import HttpResponse, JsonResponse
from django.shortcuts import redirect

def json_view(request):
    return JsonResponse({'status': 'ok', 'count': 42})

def redirect_view(request):
    return redirect('/home/')
    return redirect('article_detail', pk=1)

def csv_view(request):
    response = HttpResponse(content_type='text/csv')
    response['Content-Disposition'] = 'attachment; filename="data.csv"'
    return response

View-Decoratoren

login_required leitet unauthentifizierte Nutzer zu LOGIN_URL um. require_POST/GET beschränken HTTP-Methoden.

django
from django.contrib.auth.decorators import login_required
from django.views.decorators.http import require_POST, require_GET

@login_required
def dashboard(request):
    return render(request, 'dashboard.html')

@require_POST
def submit(request):
    pass  # Only accepts POST

@require_GET
def search(request):
    pass  # Only accepts GET

File-Upload-View

request.FILES enthält hochgeladene Dateien. Bei großen Dateien .chunks() verwenden, um nicht die ganze Datei in den Speicher zu laden.

django
def upload_file(request):
    if request.method == 'POST':
        uploaded = request.FILES['file']
        Document.objects.create(file=uploaded)
        # Or save manually
        with open(f'media/{uploaded.name}', 'wb') as f:
            for chunk in uploaded.chunks():
                f.write(chunk)
        return redirect('success')
    return render(request, 'upload.html')
07

Class-Based Views

TemplateView

TemplateView rendert ein statisches Template. get_context_data() überschreiben, um zusätzlichen Kontext zu ergänzen.

django
from django.views.generic import TemplateView

class AboutView(TemplateView):
    template_name = 'about.html'

    def get_context_data(self, **kwargs):
        context = super().get_context_data(**kwargs)
        context['title'] = 'About Us'
        return context

ListView

ListView paginiert automatisch und stellt object_list und page_obj im Kontext bereit. get_queryset() für Filterung überschreiben.

django
from django.views.generic import ListView

class ArticleListView(ListView):
    model = Article
    template_name = 'article_list.html'
    context_object_name = 'articles'
    paginate_by = 10

    def get_queryset(self):
        return Article.objects.filter(published=True)

DetailView

DetailView holt ein einzelnes Objekt über pk oder slug aus der URL. get_object() für eigenes Holen überschreiben.

django
from django.views.generic import DetailView

class ArticleDetailView(DetailView):
    model = Article
    template_name = 'article_detail.html'
    context_object_name = 'article'

    def get_object(self):
        return Article.objects.get(
            slug=self.kwargs['slug'], published=True
        )

CreateView & UpdateView

CreateView/UpdateView behandeln Formularanzeige, Validierung und Speichern. form_valid() überschreiben, um vor dem Speichern Logik zu ergänzen.

django
from django.views.generic.edit import CreateView, UpdateView

class ArticleCreateView(CreateView):
    model = Article
    fields = ['title', 'body', 'author']
    template_name = 'article_form.html'
    success_url = '/articles/'

class ArticleUpdateView(UpdateView):
    model = Article
    fields = ['title', 'body']
    template_name = 'article_form.html'

Mixins

Mixins ergänzen wiederverwendbares Verhalten zu class-based views. Django liefert LoginRequiredMixin, PermissionRequiredMixin.

django
from django.contrib.auth.mixins import LoginRequiredMixin

class OwnerRequiredMixin:
    def get_queryset(self):
        return super().get_queryset().filter(owner=self.request.user)

class ArticleListView(LoginRequiredMixin, OwnerRequiredMixin, ListView):
    model = Article
    paginate_by = 10
08

URL-Routing

Grundlegende URL-Konfiguration

path() mappt ein URL-Muster auf eine View. name= ermöglicht Reverse-URL-Lookup. <int:pk> fängt einen Integer ab.

django
from django.urls import path
from myapp import views

urlpatterns = [
    path('', views.home, name='home'),
    path('about/', views.about, name='about'),
    path('article/<int:pk>/', views.article_detail, name='article_detail'),
]

App-URLs einbinden

include() delegiert URL-Matching an die urls.py einer App. app_name erzeugt einen Namespace für URL-Reversing.

django
# myproject/urls.py
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('blog/', include('blog.urls')),
    path('api/', include('api.urls')),
]

# blog/urls.py
app_name = 'blog'
urlpatterns = [
    path('', views.list, name='list'),
    path('<int:pk>/', views.detail, name='detail'),
]

Path-Konverter

Path-Konverter wandeln URL-Segmente automatisch typum. Für komplexe Regex-Muster re_path verwenden.

django
path('article/<int:pk>/')        # integer
path('article/<slug:slug>/')     # slug string
path('article/<str:title>/')     # non-slash string
path('user/<uuid:user_id>/')    # UUID
path('file/<path:filepath>/')   # any string including /

# Regex path (re_path)
from django.urls import re_path
re_path(r'^article/(?P<year>[0-9]{4})/$', views.year_archive)

Benannte URLs & reverse()

Benannte URLs erlauben das Referenzieren von Routen per Name statt hartkodierter Pfade. reverse() erzeugt URLs in Python.

django
# urls.py
path('article/<int:pk>/', views.detail, name='article_detail')

# In views.py
from django.urls import reverse
url = reverse('article_detail', kwargs={'pk': 42})
# Returns '/article/42/'

# In templates
<a href="{% url 'article_detail' pk=article.pk %}">Read</a>

URL-Namespaces

Namespaces verhindern Namenskollisionen zwischen Apps. Der Namespace muss zur app_name der App passen.

django
# myproject/urls.py
path('blog/', include(('blog.urls', 'blog'), namespace='blog'))

# blog/urls.py
app_name = 'blog'
urlpatterns = [
    path('<int:pk>/', views.detail, name='detail'),
]

# Usage
reverse('blog:detail', kwargs={'pk': 1})
# Template: {% url 'blog:detail' pk=1 %}
09

Templates (DTL)

Template-Vererbung

extends erbt von einem Basis-Template. Blocks definieren überschreibbare Bereiche. Ein Template kann nur einen Elternteil erweitern.

django
{# base.html #}
<html>
<body>
  {% block content %}{% endblock %}
  {% block sidebar %}{% endblock %}
</body>
</html>

{# article.html #}
{% extends 'base.html' %}
{% block content %}
  <h1>{{ article.title }}</h1>
{% endblock %}

Variablen & Tags

{{ }} gibt Variablen aus. {% %} führt Tags aus. forloop.counter beginnt bei 1; forloop.counter0 bei 0.

django
{# Variables #}
{{ article.title }}
{{ user.get_full_name }}
{{ article.tags.0 }}

{# Tags #}
{% if article.published %}
    Published
{% elif article.draft %}
    Draft
{% else %}
    Archived
{% endif %}

{% for item in items %}
    {{ forloop.counter }}: {{ item }}
{% empty %}
    No items
{% endfor %}

Template-Filter

Filter verändern die Variablenausgabe über die Pipe | Syntax. Manche nehmen Argumente nach einem Doppelpunkt. Filter lassen sich verketten.

django
{{ name|lower }}
{{ text|truncatewords:30 }}
{{ date|date:"Y-m-d" }}
{{ value|default:"N/A" }}
{{ list|length }}
{{ text|striptags }}
{{ price|floatformat:2 }}
{{ value|add:5 }}

Eingebaute Template-Tags

csrf_token ist in allen POST-Formularen nötig. include rendert ein Sub-Template. load importiert eigene Tag-Bibliotheken.

django
{% url 'article_detail' pk=1 %}
{% csrf_token %}
{% load static %}
{% include 'header.html' %}
{% with total=items|length %}
    {{ total }}
{% endwith %}
{% now "Y-m-d" %}
{% blocktrans %}Hello{% endblocktrans %}

Eigene Template-Tags

Tags liegen im Verzeichnis app/templatetags/. @register.simple_tag für Funktionen; @register.filter für Wertmodifikatoren.

django
# templatetags/my_tags.py
from django import template
register = template.Library()

@register.simple_tag
def multiply(a, b):
    return a * b

@register.filter
def cut(value, arg):
    return value.replace(arg, '')

# In template:
{% load my_tags %}
{% multiply 3 4 %}
{{ "hello world"|cut:" " }}
10

Formulare

Ein Formular definieren

forms.Form erzeugt ein eigenständiges Formular. Jedes Feld generiert automatisch HTML-Widgets. Feldtypen liefern Validierung.

django
from django import forms

class ContactForm(forms.Form):
    name = forms.CharField(max_length=100)
    email = forms.EmailField()
    message = forms.CharField(widget=forms.Textarea)
    subject = forms.ChoiceField(
        choices=[('general', 'General'), ('bug', 'Bug Report')],
    )

ModelForm

ModelForm baut automatisch ein Formular aus einem Model. fields/exclude steuern, welche Felder erscheinen. widgets passen HTML an.

django
class ArticleForm(forms.ModelForm):
    class Meta:
        model = Article
        fields = ['title', 'body', 'author']
        # Or: fields = '__all__'
        # Or: exclude = ['created_at']
        widgets = {
            'body': forms.Textarea(attrs={'rows': 10}),
        }
        labels = {'title': 'Article Title'}

Formular-Validierung

clean_<field>() validiert ein einzelnes Feld. clean() validiert das ganze Formular. Bei Fehlschlag ValidationError werfen.

django
class SignupForm(forms.Form):
    username = forms.CharField(max_length=50)
    password = forms.CharField(widget=forms.PasswordInput)

    def clean_username(self):
        username = self.cleaned_data['username']
        if User.objects.filter(username=username).exists():
            raise forms.ValidationError("Username taken.")
        return username

    def clean(self):
        cleaned = super().clean()
        # Cross-field validation
        return cleaned

Formular im Template rendern

as_p/as_table/as_ul rendern alle Felder automatisch. Für eigenes Layout Felder einzeln rendern. csrf_token ist für POST nötig.

django
<form method="post">
    {% csrf_token %}
    {{ form.as_p }}
    {{ form.as_table }}
    {{ form.as_ul }}

    {# Manual rendering #}
    {{ form.title.label_tag }}
    {{ form.title }}
    {{ form.title.errors }}

    <button type="submit">Submit</button>
</form>

Formular in der View verarbeiten

request.POST übergeben, um das Formular zu binden. is_valid() führt die Validierung aus. save(commit=False) gibt ein ungespeichertes Objekt zurück.

django
def article_create(request):
    if request.method == 'POST':
        form = ArticleForm(request.POST)
        if form.is_valid():
            article = form.save(commit=False)
            article.author = request.user
            article.save()
            form.save_m2m()
            return redirect('article_detail', pk=article.pk)
    else:
        form = ArticleForm()
    return render(request, 'form.html', {'form': form})

Formular-Widgets

widgets steuern das HTML-Rendering. attrs-Dict für CSS-Klassen, Platzhalter oder HTML5-Input-Typen übergeben.

django
class UploadForm(forms.Form):
    title = forms.CharField(
        widget=forms.TextInput(attrs={'class': 'form-control'})
    )
    file = forms.FileField(widget=forms.ClearableFileInput)
    date = forms.DateField(widget=forms.DateInput(attrs={'type': 'date'}))
    tags = forms.MultipleChoiceField(
        choices=TAG_CHOICES,
        widget=forms.CheckboxSelectMultiple,
    )
11

Admin-Site

Model im Admin registrieren

@admin.register ist admin.site.register vorzuziehen. Models müssen registriert sein, um in der Admin-Oberfläche zu erscheinen.

django
from django.contrib import admin
from .models import Article

# Simple registration
admin.site.register(Article)

# With custom ModelAdmin
@admin.register(Article)
class ArticleAdmin(admin.ModelAdmin):
    list_display = ('title', 'author', 'published')

ModelAdmin anpassen

list_display zeigt Spalten in der Listenansicht. list_filter ergänzt Seitenleisten-Filter. search_fields aktiviert ein Suchfeld.

django
@admin.register(Article)
class ArticleAdmin(admin.ModelAdmin):
    list_display = ('title', 'author', 'status')
    list_filter = ('status', 'author', 'created_at')
    search_fields = ('title', 'body')
    ordering = ('-created_at',)
    list_editable = ('status',)
    list_per_page = 25
    date_hierarchy = 'created_at'
    readonly_fields = ('views', 'created_at')

Inline-Admin

Inlines bearbeiten verknüpfte Models auf derselben Seite wie das Elternteil. extra=1 zeigt standardmäßig eine leere Zeile.

django
class ReviewInline(admin.TabularInline):
    model = Review
    extra = 1

@admin.register(Article)
class ArticleAdmin(admin.ModelAdmin):
    inlines = [ReviewInline]

# TabularInline: compact table format
# StackedInline: full form fields stacked

Eigene Admin-Actions

Actions erscheinen im Dropdown der Listenseite. Sie erhalten request und queryset. message_user zeigt eine Flash-Meldung.

django
@admin.register(Article)
class ArticleAdmin(admin.ModelAdmin):
    actions = ['publish_selected']

    @admin.action(description='Publish selected')
    def publish_selected(self, request, queryset):
        updated = queryset.update(published=True)
        self.message_user(request, f'{updated} articles published.')

Admin-Site-Konfiguration

site_header/site_title fürs Branding überschreiben. Für mehrere Admin-Sites eigene AdminSite-Instanzen anlegen.

django
admin.site.site_header = 'My Site Admin'
admin.site.site_title = 'Admin Portal'
admin.site.index_title = 'Dashboard'

# Custom admin site
from django.contrib.admin import AdminSite
my_site = AdminSite(name='myadmin')
my_site.register(Article, ArticleAdmin)

# urls.py
path('myadmin/', my_site.urls)
12

Authentifizierung

Eingebautes User-Model

Djangos User-Model hat username, password (gehasht), email, first_name, last_name und Rechte-Flags.

django
from django.contrib.auth.models import User

user = User.objects.get(username='admin')
user.is_staff        # can access admin
user.is_superuser    # has all permissions
user.is_active       # account enabled
user.set_password('newpass')  # hash password
user.save()
user.check_password('secret')  # returns True/False

Login & Logout

authenticate() prüft Zugangsdaten (gibt User oder None zurück). login() erzeugt die Session. logout() löscht sie.

django
from django.contrib.auth import authenticate, login, logout

def login_view(request):
    user = authenticate(request, username='admin', password='pass')
    if user is not None:
        login(request, user)
        return redirect('dashboard')
    return render(request, 'login.html')

def logout_view(request):
    logout(request)
    return redirect('home')

Nutzer-Registrierung

UserCreationForm behandelt username, password und Passwort-Bestätigung mit eingebauter Validierung.

django
from django.contrib.auth.forms import UserCreationForm

def register(request):
    if request.method == 'POST':
        form = UserCreationForm(request.POST)
        if form.is_valid():
            user = form.save()
            login(request, user)  # auto-login after register
            return redirect('home')
    else:
        form = UserCreationForm()
    return render(request, 'register.html', {'form': form})

login_required-Decorator

login_required leitet zu LOGIN_URL um (Standard /accounts/login/). Für CBVs LoginRequiredMixin verwenden.

django
from django.contrib.auth.decorators import login_required

@login_required
def profile(request):
    return render(request, 'profile.html')

@login_required(login_url='/custom-login/')
def settings(request):
    return render(request, 'settings.html')

# Class-based view mixin
from django.contrib.auth.mixins import LoginRequiredMixin
class DashboardView(LoginRequiredMixin, ListView):
    login_url = '/login/'
    model = Article

Passwort-Verwaltung

update_session_auth_hash verhindert den Logout nach Passwortänderung. Passwort-Validatoren erzwingen Regeln site-weit.

django
from django.contrib.auth import update_session_auth_hash

# Change password
user.set_password('newpass123')
user.save()
update_session_auth_hash(request, user)  # keep user logged in

# Using form
from django.contrib.auth.forms import PasswordChangeForm
form = PasswordChangeForm(user, request.POST)
if form.is_valid():
    form.save()

Eigenes User-Model

AbstractUser ableiten, um Felder zu ergänzen. AUTH_USER_MODEL früh setzen — spätere Änderung ist schwierig.

django
from django.contrib.auth.models import AbstractUser

class CustomUser(AbstractUser):
    bio = models.TextField(blank=True)
    avatar = models.ImageField(upload_to='avatars/', blank=True)
    phone = models.CharField(max_length=20, blank=True)

# settings.py
AUTH_USER_MODEL = 'myapp.CustomUser'

# Admin
from django.contrib.auth.admin import UserAdmin
@admin.register(CustomUser)
class CustomUserAdmin(UserAdmin):
    pass
13

Middleware

Eingebaute Middleware

Reihenfolge zählt! SecurityMiddleware zuerst, dann Sessions, dann Auth. CSRF-Checks laufen vor der View-Verarbeitung.

django
MIDDLEWARE = [
    'django.middleware.security.SecurityMiddleware',
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
]

Eigene Function-Middleware

Function-Middleware nutzt das neue Factory-Muster. get_response ruft die nächste Middleware oder View auf.

django
def simple_middleware(get_response):
    def middleware(request):
        # Code before view (request phase)
        response = get_response(request)
        # Code after view (response phase)
        return response
    return middleware

# Example: timing middleware
import time
def timing_middleware(get_response):
    def middleware(request):
        start = time.time()
        response = get_response(request)
        response['X-Duration'] = str(time.time() - start)
        return response
    return middleware

Class-Based-Middleware

__init__ läuft einmalig beim Start. __call__ läuft pro Anfrage. process_view kann eine Antwort zurückgeben und die View überspringen.

django
class MyMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        # Request phase (before view)
        response = self.get_response(request)
        # Response phase (after view)
        return response

    def process_view(self, request, view_func, args, kwargs):
        return None  # or HttpResponse to short-circuit

Middleware-Reihenfolge & Fluss

Anfragen durchlaufen die Middleware von oben nach unten; Antworten steigen von unten nach oben auf. Security-Middleware zuerst platzieren.

django
# Request phase: top to bottom
# Response phase: bottom to top

MIDDLEWARE = [
    'A',  # req: 1st -> resp: last
    'B',  # req: 2nd -> resp: 2nd
    'C',  # req: 3rd -> resp: 1st
]

# Request flows: A -> B -> C -> view
# Response flows: view -> C -> B -> A

Middleware-Anwendungsfälle

Middleware kann kurzschließen (früh HttpResponse zurückgeben) oder Daten an request anhängen, die Views nutzen.

django
# IP restriction
class IPBlockMiddleware:
    BLOCKED_IPS = ['192.168.1.100']
    def __call__(self, request):
        if request.META['REMOTE_ADDR'] in self.BLOCKED_IPS:
            return HttpResponseForbidden('Blocked')
        return self.get_response(request)

# Add context to request
class UserPrefMiddleware:
    def __call__(self, request):
        request.is_mobile = 'Mobile' in request.META.get('HTTP_USER_AGENT', '')
        return self.get_response(request)
14

Statische & Media-Dateien

Konfiguration statischer Dateien

STATIC_URL ist das URL-Präfix. STATICFILES_DIRS sind Quellorte (Dev). STATIC_ROOT ist das Sammelziel in Produktion.

django
# settings.py
STATIC_URL = '/static/'
STATICFILES_DIRS = [BASE_DIR / 'static']  # dev location
STATIC_ROOT = BASE_DIR / 'staticfiles'     # collectstatic output

# Project structure:
# static/
#   css/style.css
#   js/app.js
#   img/logo.png

Statische Dateien in Entwicklung

Django liefert statische Dateien nur bei DEBUG=True selbst aus. In Produktion einen Webserver (nginx) oder WhiteNoise verwenden.

django
# urls.py (dev only)
from django.conf import settings
from django.conf.urls.static import static

urlpatterns = [
    path('admin/', admin.site.urls),
] + static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)

# Only active when DEBUG=True

Statische Dateien in Templates

{% load static %} ist nötig. {% static %} löst mit ManifestStaticFilesStorage in Produktion zum gehashten Dateinamen auf.

django
{% load static %}

<link rel="stylesheet" href="{% static 'css/style.css' %}">
<img src="{% static 'img/logo.png' %}" alt="Logo">
<script src="{% static 'js/app.js' %}"></script>

{# Dynamic static path #}
{% get_static_prefix as STATIC_URL %}
<img src="{{ STATIC_URL }}img/{{ theme }}.png">

Media-Dateien konfigurieren

MEDIA_ROOT ist der Dateisystempfad; MEDIA_URL das URL-Präfix. upload_to kann ein Pfad-String oder eine Callable sein.

django
# settings.py
MEDIA_URL = '/media/'
MEDIA_ROOT = BASE_DIR / 'media'

# urls.py (dev)
urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

# Model with file upload
class Document(models.Model):
    file = models.FileField(upload_to='documents/')
    image = models.ImageField(upload_to='images/')

# Access
doc.file.url    # '/media/documents/file.pdf'
doc.file.path   # '/full/path/to/file.pdf'

collectstatic-Befehl

collectstatic vor dem Deployment ausführen. WhiteNoise lässt Django statische Dateien in Produktion ohne nginx ausliefern.

django
# Collect all static files into STATIC_ROOT
python manage.py collectstatic

# With clearing
python manage.py collectstatic --clear

# Production with WhiteNoise
# pip install whitenoise
MIDDLEWARE = [..., 'whitenoise.middleware.WhiteNoiseMiddleware', ...]
STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'
15

Sessions & Cookies

Session-Konfiguration

Die Standard-Session-Engine speichert in der DB. cached_db schreibt in Cache + DB. signed_cookies speichert in Client-Cookies.

django
# settings.py
SESSION_ENGINE = 'django.contrib.sessions.backends.db'
SESSION_COOKIE_AGE = 86400  # seconds (1 day)
SESSION_SAVE_EVERY_REQUEST = False
SESSION_EXPIRE_AT_BROWSER_CLOSE = False
SESSION_COOKIE_SECURE = True  # HTTPS only (production)
SESSION_COOKIE_HTTPONLY = True  # JS cannot access

# Engines: db, cached_db, cache, file, signed_cookies

Session-Daten setzen & lesen

Die Session verhält sich wie ein Dict. .get() vermeidet KeyError. flush() löscht Daten und erzeugt einen neuen Session-Key (für Logout).

django
def set_session(request):
    request.session['user_id'] = 42
    request.session['theme'] = 'dark'
    request.session['cart'] = [1, 2, 3]

def get_session(request):
    user_id = request.session.get('user_id')       # None if missing
    user_id = request.session.get('user_id', 0)    # with default

    # Delete
    del request.session['theme']
    request.session.flush()  # clear all + regenerate key

Session-Backends

cache ist am schnellsten, aber flüchtig. cached_db ist ein guter Kompromiss. signed_cookies hat ein 4-KB-Limit, braucht aber keinen Server-Speicher.

django
# Database (default)
SESSION_ENGINE = 'django.contrib.sessions.backends.db'

# Cache (fastest, lost on restart)
SESSION_ENGINE = 'django.contrib.sessions.backends.cache'

# Cache + DB (fast reads, persistent)
SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db'

# File-based
SESSION_ENGINE = 'django.contrib.sessions.backends.file'

# Signed cookies (no server storage, 4KB limit)
SESSION_ENGINE = 'django.contrib.sessions.backends.signed_cookies'

Cookies

set_cookie ergänzt in der Antwort. request.COOKIES liest eingehende Cookies. httponly verhindert JS-Zugriff (XSS-Schutz).

django
# Set a cookie
response = HttpResponse('Hello')
response.set_cookie('key', 'value', max_age=3600)
response.set_cookie(
    'pref', 'dark',
    max_age=86400, httponly=True,
    secure=True, samesite='Lax',
)

# Read a cookie
value = request.COOKIES.get('key')

# Delete a cookie
response.delete_cookie('key')

Session-Ablauf

set_expiry(0) = beim Schließen des Browsers. set_expiry(None) = Settings verwenden. clearsessions als Cron-Job zum Aufräumen laufen lassen.

django
# Set expiry for this session
request.session.set_expiry(1800)  # 30 minutes
request.session.set_expiry(0)     # expire on browser close
request.session.set_expiry(None)  # use SESSION_COOKIE_AGE

# Check expiry
request.session.get_expiry_age()
request.session.get_expire_at_browser_close()

# Clear expired sessions (cron job)
python manage.py clearsessions
16

Signals

Eingebaute Signals

Signals erlauben entkoppelten Apps, auf Aktionen zu reagieren. post_save feuert nach abgeschlossenem save(); pre_save davor.

django
from django.db.models.signals import (
    post_save, pre_save, post_delete, pre_delete,
    m2m_changed,
)
from django.contrib.auth.signals import (
    user_logged_in, user_logged_out,
)

# Common signals:
# pre_save / post_save      - before/after model save
# pre_delete / post_delete   - before/after model delete
# m2m_changed               - M2M relationship changes
# user_logged_in / user_logged_out

Signal-Empfänger verbinden

@receiver verbindet die Funktion mit dem Signal. sender beschränkt auf ein bestimmtes Model. created ist nur bei neuen Objekten True.

django
from django.db.models.signals import post_save
from django.dispatch import receiver

@receiver(post_save, sender=User)
def create_profile(sender, instance, created, **kwargs):
    if created:
        Profile.objects.create(user=instance)

@receiver(post_save, sender=User)
def save_profile(sender, instance, **kwargs):
    instance.profile.save()

Signals trennen

disconnect() ist nützlich in Tests oder wenn kaskadierende Aktionen verhindert werden sollen. Immer receiver und sender zusammen angeben.

django
from django.db.models.signals import post_save

# Disconnect
post_save.disconnect(
    receiver=create_profile,
    sender=User,
)

# Temporarily disconnect in tests
post_save.disconnect(handler, sender=Article)
# ... do stuff without signal ...
post_save.connect(handler, sender=Article)

Eigene Signals

Signals auf Modulebene definieren. send() benachrichtigt alle Empfänger. kwargs gehen an alle verbundenen Empfänger.

django
from django.dispatch import Signal, receiver

# Define a custom signal
order_created = Signal()

# Send the signal
order_created.send(
    sender=Order,
    order=order_instance,
    user=request.user,
)

# Receive
@receiver(order_created, sender=Order)
def send_notification(sender, order, user, **kwargs):
    pass  # Send email notification

Signal-Anwendungsfälle & Fallstricke

Signal-Handler in AppConfig.ready() importieren, damit sie beim Start verbunden werden. Langsame Operationen vermeiden — für asynchrone Arbeit Celery nutzen.

django
# Good: Profile auto-creation
@receiver(post_save, sender=User)
def ensure_profile(sender, instance, created, **kwargs):
    if created:
        Profile.objects.get_or_create(user=instance)

# Register in AppConfig.ready()
# apps.py
class MyAppConfig(AppConfig):
    name = 'myapp'
    def ready(self):
        from . import signals  # noqa
17

Caching

Cache-Konfiguration

Redis ist für Produktion empfohlen. LocMemCache ist prozesslokal (keine gemeinsame Nutzung zwischen Workern).

django
# settings.py - Memcached
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.memcached.PyMemcacheCache',
        'LOCATION': '127.0.0.1:11211',
    }
}

# Redis
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.redis.RedisCache',
        'LOCATION': 'redis://127.0.0.1:6379',
    }
}

# Local memory (dev)
CACHES = {
    'default': {'BACKEND': 'django.core.cache.backends.locmem.LocMemCache'}
}

Low-Level-Cache-API

cache.get() gibt None für fehlende Keys zurück. get_or_set für set-if-not-exists-Atomizität verwenden.

django
from django.core.cache import cache

# Set
cache.set('key', 'value', timeout=300)  # 5 minutes
cache.set_many({'a': 1, 'b': 2}, timeout=60)

# Get
value = cache.get('key')              # None if missing
value = cache.get('key', 'default')   # with default
data = cache.get_many(['a', 'b'])     # dict

# Delete
cache.delete('key')
cache.clear()  # delete all

# get_or_set (atomic)
value = cache.get_or_set('key', 'value', 300)

Template-Caching

{% cache %} speichert gerenderte HTML-Fragmente. Variierende Argumente (User-ID, Seite) ergänzen, um falschen gecachten Inhalt zu vermeiden.

django
{% load cache %}

{# Cache block for 500 seconds #}
{% cache 500 sidebar %}
    <div class="sidebar">
        {{ expensive_data }}
    </div>
{% endcache %}

{# Cache with varying key #}
{% cache 500 user_sidebar request.user.id %}
    Welcome, {{ request.user.username }}
{% endcache %}

Cache pro View

cache_page cacht das gesamte HttpResponse. Der Cache-Key enthält die URL, also bekommt jede URL einen eigenen Cache-Eintrag.

django
from django.views.decorators.cache import cache_page

@cache_page(60 * 15)
def article_list(request):
    return render(request, 'list.html', {'articles': Article.objects.all()})

# With cache key prefix
@cache_page(60 * 15, key_prefix='articles')
def article_detail(request, pk):
    ...

# Class-based view
from django.utils.decorators import method_decorator
class ArticleListView(ListView):
    @method_decorator(cache_page(60 * 15))
    def dispatch(self, *args, **kwargs):
        return super().dispatch(*args, **kwargs)

Cache-Strategien

vary_on_headers erzeugt separate Cache-Einträge pro Header-Wert. Für APIs nach Accept-Language oder Authorization variieren.

django
# Per-view cache with Vary headers
from django.views.decorators.vary import vary_on_headers

@cache_page(60 * 15)
@vary_on_headers('User-Agent')
def api_data(request):
    ...

# Model-level caching
def get_articles():
    articles = cache.get('all_articles')
    if articles is None:
        articles = list(Article.objects.all())
        cache.set('all_articles', articles, 300)
    return articles
18

Testen

Tests schreiben

TestCase umwickelt Tests in einer DB-Transaktion (rollback). SimpleTestCase ist für Tests ohne DB-Zugriff (schneller).

django
from django.test import TestCase, SimpleTestCase
from .models import Article

class ArticleModelTest(TestCase):
    def setUp(self):
        self.article = Article.objects.create(
            title='Test', body='Content'
        )

    def test_str(self):
        self.assertEqual(str(self.article), 'Test')

    def test_field_default(self):
        self.assertEqual(self.article.views, 0)

# SimpleTestCase: no DB access
class MathTest(SimpleTestCase):
    def test_addition(self):
        self.assertEqual(1 + 1, 2)

Testen mit dem Test-Client

self.client simuliert HTTP-Anfragen ohne Server-Start. .login() authentifiziert für nachfolgende Anfragen.

django
class ViewTest(TestCase):
    def setUp(self):
        self.user = User.objects.create_user('test', '[email protected]', 'pass')

    def test_login(self):
        response = self.client.post('/login/', {
            'username': 'test', 'password': 'pass'
        })
        self.assertEqual(response.status_code, 302)

    def test_protected_view(self):
        self.client.login(username='test', password='pass')
        response = self.client.get('/dashboard/')
        self.assertEqual(response.status_code, 200)

Model- & QuerySet-Tests

Testdaten entstehen in setUp() und werden nach jedem Test zurückgerollt. Mit .count() und Indizierung Ergebnisse prüfen.

django
class ArticleQuerySetTest(TestCase):
    def setUp(self):
        Article.objects.create(title='A', views=100, published=True)
        Article.objects.create(title='B', views=50, published=False)

    def test_published_filter(self):
        published = Article.objects.filter(published=True)
        self.assertEqual(published.count(), 1)

    def test_ordering(self):
        articles = Article.objects.order_by('-views')
        self.assertEqual(articles[0].title, 'A')

URL- & Formular-Tests

reverse() baut URLs aus Namen. resolve() prüft, auf welche View eine URL mappt. Formulare testen, indem data=-Dict übergeben wird.

django
from django.urls import reverse, resolve

class URLTest(TestCase):
    def test_article_list_url(self):
        url = reverse('article_list')
        response = self.client.get(url)
        self.assertEqual(response.status_code, 200)

    def test_resolve(self):
        url = reverse('article_detail', kwargs={'pk': 1})
        self.assertEqual(resolve(url).func, views.article_detail)

class FormTest(TestCase):
    def test_valid_form(self):
        form = ArticleForm(data={'title': 'Hi', 'body': '...'})
        self.assertTrue(form.is_valid())

Fixtures & Test-Befehle

Fixtures laden Testdaten aus JSON-Dateien. Konkrete Tests per App-, Klassen- oder Methodenpfad ausführen.

django
# Create fixture
python manage.py dumpdata myapp.Article --indent=2 > fixtures/articles.json

# Use in test
class FixtureTest(TestCase):
    fixtures = ['articles.json']

    def test_data_loaded(self):
        self.assertEqual(Article.objects.count(), 10)

# Run tests
python manage.py test
python manage.py test myapp
python manage.py test myapp.tests.ArticleModelTest
19

Django REST Framework

DRF installieren & einrichten

rest_framework zu INSTALLED_APPS ergänzen. Standard-Auth/Permissions im REST_FRAMEWORK-Settings-Dict konfigurieren.

django
pip install djangorestframework

# settings.py
INSTALLED_APPS = [..., 'rest_framework', 'rest_framework.authtoken']

REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework.authentication.TokenAuthentication',
        'rest_framework.authentication.SessionAuthentication',
    ],
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.IsAuthenticated',
    ],
}

Serializers

ModelSerializer generiert Felder automatisch aus dem Model. source= zieht aus verknüpften Objekten. validate_<field>() ergänzt Validierung.

django
from rest_framework import serializers

class ArticleSerializer(serializers.ModelSerializer):
    author_name = serializers.CharField(source='author.username', read_only=True)

    class Meta:
        model = Article
        fields = ['id', 'title', 'body', 'author', 'author_name']
        read_only_fields = ['id', 'author_name']

    def validate_title(self, value):
        if len(value) < 5:
            raise serializers.ValidationError("Title too short.")
        return value

ViewSets

ModelViewSet liefert CRUD (list, create, retrieve, update, destroy). get_queryset() für Filterung überschreiben.

django
from rest_framework import viewsets, permissions

class ArticleViewSet(viewsets.ModelViewSet):
    queryset = Article.objects.all()
    serializer_class = ArticleSerializer
    permission_classes = [permissions.IsAuthenticatedOrReadOnly]

    def get_queryset(self):
        qs = super().get_queryset()
        author = self.request.query_params.get('author')
        if author:
            qs = qs.filter(author__username=author)
        return qs

    def perform_create(self, serializer):
        serializer.save(author=self.request.user)

Routers

DefaultRouter generiert URL-Muster und eine API-Root-View automatisch. basename wird für URL-Benennung genutzt, wenn das queryset dynamisch ist.

django
from rest_framework.routers import DefaultRouter
from .views import ArticleViewSet

router = DefaultRouter()
router.register(r'articles', ArticleViewSet, basename='article')
# router.register(r'users', UserViewSet)

# urls.py
urlpatterns = [
    path('api/', include(router.urls)),
]
# Generates: /api/articles/, /api/articles/{id}/

Authentifizierung

Token-Auth nutzt einen einzelnen statischen Token. JWT stellt access- und refresh-Tokens aus. SimpleJWT ist die populärste JWT-Bibliothek.

django
# Token Authentication
from rest_framework.authtoken.views import obtain_auth_token
urlpatterns = [
    path('api/token/', obtain_auth_token),
]

# JWT Authentication (pip install djangorestframework-simplejwt)
from rest_framework_simplejwt.views import (
    TokenObtainPairView, TokenRefreshView,
)
urlpatterns = [
    path('api/token/', TokenObtainPairView.as_view()),
    path('api/token/refresh/', TokenRefreshView.as_view()),
]

Permissions

SAFE_METHODS sind GET/HEAD/OPTIONS. has_object_permission prüft Zugriff pro Objekt. get_permissions() erlaubt Regeln pro Aktion.

django
from rest_framework import permissions

class IsOwnerOrReadOnly(permissions.BasePermission):
    def has_object_permission(self, request, view, obj):
        if request.method in permissions.SAFE_METHODS:
            return True  # GET, HEAD, OPTIONS
        return obj.author == request.user

# Built-in: IsAuthenticated, IsAdminUser,
# IsAuthenticatedOrReadOnly, AllowAny

# Per-action
class ArticleViewSet(viewsets.ModelViewSet):
    permission_classes = [IsOwnerOrReadOnly]
    def get_permissions(self):
        if self.action == 'create':
            return [permissions.IsAuthenticated()]
        return super().get_permissions()
20

Deployment & Sicherheit

Produktions-Einstellungen

SECRET_KEY niemals in die Versionskontrolle committen. Umgebungsvariablen verwenden. DEBUG=False verhindert Info-Leaks in Fehlerseiten.

django
# settings.py
DEBUG = False
ALLOWED_HOSTS = ['example.com', 'www.example.com']
SECRET_KEY = os.environ['SECRET_KEY']

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'mydb',
        'USER': os.environ['DB_USER'],
        'PASSWORD': os.environ['DB_PASS'],
        'HOST': 'localhost',
        'PORT': '5432',
    }
}

Statische Dateien in Produktion

collectstatic sammelt alle statischen Dateien nach STATIC_ROOT. WhiteNoise liefert gzippte, gehashte Dateien direkt aus Django.

django
# Collect static files
python manage.py collectstatic --noinput

# WhiteNoise for serving static
MIDDLEWARE = [..., 'whitenoise.middleware.WhiteNoiseMiddleware', ...]
STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'

# Or with nginx:
# location /static/ { alias /path/to/staticfiles/; }

Sicherheits-Einstellungen

SSL_REDIRECT erzwingt HTTPS. HSTS sagt Browsern, immer HTTPS zu verwenden. X_FRAME_OPTIONS verhindert Clickjacking.

django
# settings.py
SECURE_SSL_REDIRECT = True
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True
SECURE_HSTS_SECONDS = 31536000
SECURE_HSTS_INCLUDE_SUBDOMAINS = True
SECURE_HSTS_PRELOAD = True
SECURE_CONTENT_TYPE_NOSNIFF = True
X_FRAME_OPTIONS = 'DENY'
CSRF_TRUSTED_ORIGINS = ['https://example.com']

WSGI/ASGI-Deployment

Gunicorn ist synchron (traditionelles Django). Uvicorn unterstützt ASGI (async views, WebSockets). Einen Prozess-Manager verwenden.

django
# Gunicorn (WSGI)
# pip install gunicorn
gunicorn myproject.wsgi:application --bind 0.0.0.0:8000 --workers 3

# Uvicorn (ASGI, for async/websockets)
# pip install uvicorn
uvicorn myproject.asgi:application --host 0.0.0.0 --port 8000 --workers 4

# Supervisor config
[program:django]
command=gunicorn myproject.wsgi:application
directory=/app
autostart=true
autorestart=true

Produktions-Checkliste

check --deploy führt Djangos Deployment-Checkliste aus. Es markiert fehlende Sicherheits-Einstellungen und Probleme der Produktionsreife.

django
# Run security check
python manage.py check --deploy

# Key items:
# - DEBUG = False
# - ALLOWED_HOSTS set
# - SECRET_KEY from env
# - HTTPS enabled (SECURE_SSL_REDIRECT)
# - HSTS configured
# - collectstatic run
# - Database (PostgreSQL/MySQL)
# - Caching (Redis/Memcached)
# - Error monitoring (Sentry)

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.