Skip to content

Django Aide-mémoire

Framework web Python de haut niveau pour un développement rapide et sécurisé.

01

Démarrage

Installer et créer un projet

Installez Django via pip. Un projet contient les réglages et les URLs ; une app est un module réutilisable avec ses models et ses views.

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

Lancer le serveur de développement

Démarre le serveur de développement intégré avec rechargement automatique. À ne jamais utiliser en production.

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 et superutilisateur

makemigrations génère les fichiers de migration à partir des changements de modèles. migrate les applique à la base. createsuperuser crée un compte administrateur.

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

Structure du projet

manage.py est l'outil en ligne de commande. Le package interne contient la configuration du projet ; le répertoire de l'app contient le code propre à l'app.

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

Bases des settings

INSTALLED_APPS liste les apps actives. Passez DEBUG=False et configurez ALLOWED_HOSTS en production.

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

Champs de modèle

Définir un modèle

Chaque classe de modèle correspond à une table de la base. Chaque champ correspond à une colonne. __str__ définit le nom d'affichage.

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

Types de champs courants

CharField exige max_length. auto_now_add s'applique à la création ; auto_now se met à jour à chaque enregistrement. EmailField/URLField ajoutent une validation.

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)

Options de champ

null agit au niveau de la base ; blank au niveau de la validation. choices crée une liste déroulante dans les formulaires et l'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',
)

Options Meta

ordering définit l'ordre de tri par défaut. db_table remplace le nom de table généré automatiquement. constraints impose des règles au niveau de la base.

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

Méthodes et propriétés de modèle

Surchargez save() pour la logique avant enregistrement. @property ajoute des attributs calculés. Appelez toujours super().save().

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

Relations entre modèles

ForeignKey (plusieurs-à-un)

ForeignKey crée une relation plusieurs-à-un. related_name permet les requêtes inverses : 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 crée un lien un-à-un. Accès via user.profile ou profile.user.

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

ManyToManyField

ManyToManyField crée automatiquement une table de jonction. Ajout/retrait : 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)

Options on_delete

CASCADE supprime les enfants quand le parent est supprimé. SET_NULL exige null=True. PROTECT lève une 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)

Requêtes sur les objets liés

L'accès direct (forward) utilise le nom du champ. L'accès inverse utilise related_name (ou modelname_set par défaut).

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

QuerySet de l'ORM

Créer et enregistrer des objets

create() enregistre immédiatement. get_or_create renvoie (objet, booléen_créé) — récupère ou crée de façon atomique.

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'}
)

Récupérer un seul objet

get() lève DoesNotExist si rien n'est trouvé, MultipleObjectsReturned si plusieurs. Utilisez first() pour récupérer un objet sans risque.

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')

Filtrer et exclure

filter() renvoie un QuerySet (paresseux). L'enchaînement applique une logique AND. Les QuerySets ne sont évalués qu'à l'itération.

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)

Lookups de champs

Les lookups utilisent la syntaxe à double tiret bas. Courants : 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

Tri et découpage

Le slicing applique un LIMIT au niveau de la base. L'indexation négative n'est pas prise en charge sur les QuerySets.

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()

Mise à jour et suppression

update() est efficace pour les modifications en masse. save(update_fields=[...]) évite les conditions de course. delete() supprime en cascade par défaut.

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 avancé

Expressions F

F() référence la valeur d'une colonne en base, ce qui permet des mises à jour atomiques sans charger l'objet en Python.

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'))

Objets Q pour requêtes complexes

Les objets Q permettent la logique OR (|), AND (&) et NOT (~). Sans Q, plusieurs appels à filter() ne combinent que des AND.

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

Agrégation

aggregate() renvoie un dict de totaux. annotate() ajoute des valeurs calculées par objet.

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() ajoute des champs calculés par objet. Vous pouvez filter() et order_by() sur les champs annotés.

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 et prefetch_related

select_related utilise un JOIN SQL (FK directe). prefetch_related utilise une seconde requête (inverse/M2M). Les deux évitent les requêtes N+1.

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

Vues par fonctions

Vue fonction de base

Une view reçoit un HttpRequest et renvoie une HttpResponse. render() charge un template et le remplit avec le contexte.

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)

Objet HttpRequest

request.GET/POST sont des QueryDict (utilisez .get() par sécurité). request.user est l'utilisateur authentifié ou 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')

Types de HttpResponse

JsonResponse sérialise en JSON. redirect() accepte un chemin d'URL ou une URL nommée avec ses arguments.

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

Décorateurs de vue

login_required redirige les utilisateurs non authentifiés vers LOGIN_URL. require_POST/GET restreignent les méthodes HTTP.

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

Vue d'upload de fichiers

request.FILES contient les fichiers envoyés. Utilisez .chunks() pour les gros fichiers afin d'éviter de tout charger en mémoire.

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

Vues par classes

TemplateView

TemplateView affiche un template statique. Surchargez get_context_data() pour ajouter du contexte supplémentaire.

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 pagine automatiquement et fournit object_list et page_obj dans le contexte. Surchargez get_queryset() pour filtrer.

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 récupère un objet unique par pk ou slug depuis l'URL. Surchargez get_object() pour une récupération personnalisée.

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 et UpdateView

CreateView/UpdateView gèrent l'affichage du formulaire, la validation et l'enregistrement. Surchargez form_valid() pour ajouter une logique avant l'enregistrement.

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

Les mixins ajoutent un comportement réutilisable aux vues par classes. Django fournit LoginRequiredMixin et 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

Routage des URLs

Configuration d'URL de base

path() associe un motif d'URL à une vue. name= permet la recherche d'URL inverse. <int:pk> capture un entier.

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'),
]

Inclure les URLs d'une app

include() délègue la correspondance d'URL au urls.py d'une app. app_name crée un namespace pour la génération inverse d'URL.

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'),
]

Convertisseurs de chemin

Les convertisseurs de chemin convertissent automatiquement les segments d'URL. Utilisez re_path pour les motifs regex complexes.

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)

URLs nommées et reverse()

Les URLs nommées permettent de référencer les routes par leur nom au lieu de coder les chemins en dur. reverse() génère les URLs en 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>

Namespaces d'URL

Les namespaces évitent les collisions de noms entre apps. Le namespace doit correspondre au app_name de l'app.

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)

Héritage de templates

extends hérite d'un template de base. Les blocks définissent des zones remplaçables. Un template ne peut hériter que d'un seul parent.

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 %}

Variables et tags

{{ }} affiche les variables. {% %} exécute les tags. forloop.counter commence à 1 ; forloop.counter0 à 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 %}

Filtres de template

Les filtres modifient la sortie des variables via la syntaxe pipe |. Certains acceptent des arguments après deux points. Les filtres peuvent s'enchaîner.

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 }}

Tags de template intégrés

csrf_token est obligatoire dans tous les formulaires POST. include affiche un sous-template. load importe des bibliothèques de tags personnalisées.

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 %}

Tags de template personnalisés

Les tags vivent dans le répertoire app/templatetags/. @register.simple_tag pour les fonctions ; @register.filter pour les modificateurs de valeur.

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

Formulaires

Définir un formulaire

forms.Form crée un formulaire autonome. Chaque champ génère automatiquement les widgets HTML. Les types de champs assurent la validation.

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 construit automatiquement un formulaire à partir d'un modèle. fields/exclude contrôlent les champs affichés. widgets personnalise le HTML.

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'}

Validation de formulaire

clean_<field>() valide un champ unique. clean() valide le formulaire entier. Levez ValidationError en cas d'échec.

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

Afficher le formulaire dans un template

as_p/as_table/as_ul affichent tous les champs automatiquement. Pour une mise en page personnalisée, affichez les champs un par un. csrf_token est obligatoire en POST.

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>

Traiter le formulaire dans une vue

Passez request.POST pour lier le formulaire. is_valid() lance la validation. save(commit=False) renvoie un objet non enregistré.

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})

Widgets de formulaire

widgets contrôle le rendu HTML. Passez un dict attrs pour les classes CSS, les placeholders ou les types d'input HTML5.

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

Site d'administration

Enregistrer un modèle dans l'admin

@admin.register est préférable à admin.site.register. Les modèles doivent être enregistrés pour apparaître dans l'interface d'admin.

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')

Personnalisation de ModelAdmin

list_display affiche les colonnes de la vue liste. list_filter ajoute des filtres latéraux. search_fields active une zone de recherche.

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')

Admin avec inlines

Les inlines permettent de modifier les modèles liés sur la même page que le parent. extra=1 affiche une ligne vide par défaut.

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

Actions d'admin personnalisées

Les actions apparaissent dans le menu déroulant de la page liste. Elles reçoivent request et queryset. message_user affiche un message flash.

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

Configuration du site d'admin

Surchargez site_header/site_title pour la personnalisation. Pour plusieurs sites d'admin, créez des instances d'AdminSite personnalisées.

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

Authentification

Modèle User intégré

Le modèle User de Django comporte username, password (haché), email, first_name, last_name et des indicateurs de permissions.

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

Connexion et déconnexion

authenticate() vérifie les identifiants (renvoie un User ou None). login() crée la session. logout() la supprime.

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')

Inscription des utilisateurs

UserCreationForm gère username, password et la confirmation du mot de passe avec une validation intégrée.

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})

Décorateur login_required

login_required redirige vers LOGIN_URL (/accounts/login/ par défaut). Pour les CBV, utilisez LoginRequiredMixin.

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

Gestion des mots de passe

update_session_auth_hash évite la déconnexion après un changement de mot de passe. Les validateurs de mot de passe imposent des règles sur tout le site.

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()

Modèle User personnalisé

Héritez d'AbstractUser pour ajouter des champs. Définissez AUTH_USER_MODEL tôt — le changer plus tard est difficile.

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

Middleware intégrés

L'ordre compte ! SecurityMiddleware en premier, puis les sessions, puis l'auth. Les vérifications CSRF s'exécutent avant le traitement de la vue.

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',
]

Middleware fonction personnalisé

Le middleware fonctionnel suit le nouveau pattern de factory. get_response appelle le middleware suivant ou la vue.

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

Middleware par classes

__init__ s'exécute une fois au démarrage. __call__ s'exécute à chaque requête. process_view peut renvoyer une réponse pour court-circuiter la vue.

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

Ordre et flux des middleware

Les requêtes traversent les middleware de haut en bas ; les remontées de réponses vont de bas en haut. Placez le middleware de sécurité en premier.

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

Cas d'usage des middleware

Un middleware peut court-circuiter (renvoyer une HttpResponse tôt) ou attacher des données à request pour les vues.

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

Fichiers statiques et médias

Configuration des fichiers statiques

STATIC_URL est le préfixe d'URL. STATICFILES_DIRS sont les emplacements sources (dev). STATIC_ROOT est la destination de collecte en production.

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

Servir les statiques en développement

Django ne sert les fichiers statiques automatiquement que si DEBUG=True. En production, utilisez un serveur web (nginx) ou WhiteNoise.

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

Utiliser les statiques dans les templates

{% load static %} est obligatoire. {% static %} résout vers le nom de fichier haché en production avec ManifestStaticFilesStorage.

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">

Configuration des fichiers médias

MEDIA_ROOT est le chemin système ; MEDIA_URL est le préfixe d'URL. upload_to peut être une chaîne de chemin ou un callable.

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'

Commande collectstatic

Lancez collectstatic avant le déploiement. WhiteNoise permet à Django de servir les fichiers statiques en production sans nginx.

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 et cookies

Configuration des sessions

Par défaut, le moteur de session stocke en base. cached_db écrit dans le cache + la base. signed_cookies stocke dans les cookies du client.

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

Définir et lire les données de session

La session se comporte comme un dict. .get() évite les KeyError. flush() efface les données et crée une nouvelle clé de session (pour la déconnexion).

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

Backends de session

cache est le plus rapide mais volatile. cached_db offre un bon compromis. signed_cookies est limité à 4 Ko mais ne stocke rien côté serveur.

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 ajoute un cookie à la réponse. request.COOKIES lit les cookies entrants. httponly empêche l'accès en JS (protection XSS).

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')

Expiration des sessions

set_expiry(0) = à la fermeture du navigateur. set_expiry(None) = utilise les settings. Exécutez clearsessions en tâche cron pour nettoyer.

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

Signals intégrés

Les signals permettent à des apps découplées de réagir à des actions. post_save se déclenche après la fin de save() ; pre_save avant.

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

Connecter des récepteurs de signal

@receiver relie la fonction au signal. sender limite au modèle indiqué. created vaut True uniquement pour les nouveaux objets.

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()

Déconnecter des signals

disconnect() est utile en tests ou pour empêcher des actions en cascade. Fournissez toujours à la fois le receiver et le sender.

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)

Signals personnalisés

Définissez les signals au niveau du module. send() notifie tous les récepteurs. Les kwargs sont transmis à tous les récepteurs connectés.

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

Cas d'usage et pièges des signals

Importez les gestionnaires de signals dans AppConfig.ready() pour qu'ils se connectent au démarrage. Évitez les opérations lentes — utilisez Celery pour l'asynchrone.

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

Cache

Configuration du cache

Redis est recommandé en production. LocMemCache est propre au processus (pas de partage entre workers).

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'}
}

API de cache bas niveau

cache.get() renvoie None pour les clés absentes. Utilisez get_or_set pour créer la clé si absente, de façon atomique.

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)

Cache de template

{% cache %} stocke des fragments HTML rendus. Ajoutez des arguments variables (ID utilisateur, page) pour éviter un contenu en cache erroné.

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 par vue

cache_page met en cache l'intégralité de la HttpResponse. La clé de cache inclut l'URL, donc chaque URL a sa propre entrée.

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)

Stratégies de cache

vary_on_headers crée des entrées de cache distinctes par valeur d'en-tête. Pour les API, variez selon Accept-Language ou Authorization.

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

Tests

Écrire des tests

TestCase enveloppe chaque test dans une transaction de base (annulée ensuite). SimpleTestCase sert aux tests sans accès à la base (plus rapide).

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)

Tester avec le client de test

self.client simule des requêtes HTTP sans démarrer de serveur. .login() authentifie pour les requêtes suivantes.

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)

Tests de modèles et de QuerySets

Les données de test sont créées dans setUp() et annulées après chaque test. Utilisez .count() et l'indexation pour vérifier les résultats.

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')

Tests d'URL et de formulaires

reverse() construit les URLs à partir des noms. resolve() vérifie quelle vue correspond à une URL. Testez les formulaires en passant un dict data=.

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 et commandes de test

Les fixtures chargent des données de test depuis des fichiers JSON. Lancez des tests précis par chemin d'app, de classe ou de méthode.

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

Installer et configurer DRF

Ajoutez rest_framework à INSTALLED_APPS. Configurez l'authentification et les permissions par défaut dans le dict de settings REST_FRAMEWORK.

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 génère les champs à partir du modèle. source= lit depuis des objets liés. validate_<field>() ajoute une validation.

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 fournit le CRUD (list, create, retrieve, update, destroy). Surchargez get_queryset() pour filtrer.

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 génère automatiquement les motifs d'URL et une vue racine d'API. basename sert au nommage des URLs si le queryset est dynamique.

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}/

Authentification

L'auth par token utilise un token statique unique. JWT émet des tokens access + refresh. SimpleJWT est la bibliothèque JWT la plus répandue.

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 correspond à GET/HEAD/OPTIONS. has_object_permission vérifie l'accès par objet. get_permissions() permet des règles par action.

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

Déploiement et sécurité

Réglages de production

Ne commitez jamais SECRET_KEY dans le gestionnaire de versions. Utilisez des variables d'environnement. DEBUG=False évite les fuites d'informations dans les pages d'erreur.

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',
    }
}

Fichiers statiques en production

collectstatic rassemble tous les fichiers statiques dans STATIC_ROOT. WhiteNoise sert des fichiers compressés et hachés depuis Django lui-même.

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/; }

Réglages de sécurité

SSL_REDIRECT force le HTTPS. HSTS demande aux navigateurs de toujours utiliser HTTPS. X_FRAME_OPTIONS prévient le 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']

Déploiement WSGI/ASGI

Gunicorn est synchrone (Django traditionnel). Uvicorn prend en charge ASGI (vues async, websockets). Utilisez un gestionnaire de processus.

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

Checklist de production

check --deploy exécute la checklist de déploiement de Django. Il signale les réglages de sécurité manquants et les problèmes de mise en production.

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.