Skip to content

Django 치트시트

빠르고 안전한 개발을 위한 고수준 Python 웹 프레임워크입니다.

01

시작하기

설치 & 프로젝트 생성

Django는 pip로 설치합니다. 프로젝트는 설정과 URL을 담고, 앱은 모델과 뷰를 갖춘 재사용 가능한 모듈입니다.

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

개발 서버 실행

자동 리로드가 있는 내장 개발 서버를 시작합니다. 프로덕션에서는 절대 사용하지 마세요.

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

마이그레이션 & 슈퍼유저

makemigrations는 모델 변경으로부터 마이그레이션 파일을 생성합니다. migrate는 DB에 적용합니다. createsuperuser는 관리자 계정을 만듭니다.

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

프로젝트 구조

manage.py는 CLI 도구입니다. 안쪽 패키지가 프로젝트 설정을 담고, 앱 디렉터리가 앱 수준 코드를 담습니다.

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

설정 기본

INSTALLED_APPS가 활성화된 앱을 나열합니다. 프로덕션에서는 DEBUG=False로 두고 ALLOWED_HOSTS를 설정하세요.

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

모델 필드

모델 정의

각 모델 클래스는 DB 테이블에 매핑됩니다. 각 필드는 컬럼에 매핑됩니다. __str__이 표시 이름을 정의합니다.

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

흔한 필드 타입

CharField는 max_length가 필요합니다. auto_now_add는 생성 시 설정되고, auto_now는 저장할 때마다 갱신됩니다. EmailField/URLField는 검증을 추가합니다.

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)

필드 옵션

null은 DB 수준이고, blank는 검증 수준입니다. choices는 폼과 관리자에서 드롭다운을 만듭니다.

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 옵션

ordering은 기본 정렬 순서를 설정합니다. db_table은 자동 생성된 테이블 이름을 덮어씁니다. constraints는 DB 수준 규칙을 강제합니다.

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

모델 메서드 & 프로퍼티

저장 전 로직에는 save()를 오버라이드합니다. @property는 계산된 속성을 추가합니다. 항상 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

모델 관계

ForeignKey (다대일)

ForeignKey는 다대일 관계를 만듭니다. related_name으로 역방향 조회가 가능해집니다: 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는 일대일 링크를 만듭니다. user.profile 또는 profile.user로 접근합니다.

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

ManyToManyField

ManyToManyField는 조인 테이블을 자동으로 만듭니다. 추가/제거: 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 옵션

CASCADE는 부모가 삭제되면 자식도 삭제합니다. SET_NULL에는 null=True가 필요합니다. PROTECT는 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)

관련 객체 조회

순방향 접근은 필드 이름을 쓰고, 역방향 접근은 related_name(기본값은 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

생성 & 저장

create()는 즉시 저장합니다. get_or_create는 (객체, 생성 여부 불리언)을 반환합니다 — 원자적으로 가져오거나 생성합니다.

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

단일 객체 조회

get()은 없으면 DoesNotExist를, 여러 개면 MultipleObjectsReturned를 발생시킵니다. 안전하게 하나를 얻으려면 first()를 쓰세요.

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()는 QuerySet을 반환합니다(지연 평가). 체이닝하면 AND 로직이 됩니다. QuerySet은 순회할 때만 평가됩니다.

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)

필드 룩업

룩업은 더블 언더스코어 문법을 씁니다. 흔한 것: 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

정렬 & 슬라이싱

슬라이싱은 DB 수준에서 LIMIT를 적용합니다. QuerySet에서는 음수 인덱싱이 지원되지 않습니다.

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()는 대량 변경에 효율적입니다. save(update_fields=[...])는 경쟁 상태를 피합니다. delete()는 기본적으로 캐스케이드됩니다.

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 심화

F 표현식

F()는 DB 컬럼 값을 참조해, 객체를 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'))

복잡한 쿼리의 Q 객체

Q 객체는 OR(|), AND(&), NOT(~) 로직을 가능하게 합니다. Q 없이 여러 filter() 호출은 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)
)

집계

aggregate()는 합계 등의 dict를 반환합니다. annotate()는 객체별 계산 값을 추가합니다.

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()는 객체별 계산 필드를 추가합니다. 어노테이션된 필드로 filter()와 order_by()도 가능합니다.

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는 SQL JOIN을 씁니다(순방향 FK). prefetch_related는 두 번째 쿼리를 씁니다(역방향/M2M). 둘 다 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

함수 기반 뷰

기본 함수 뷰

뷰는 HttpRequest를 받아 HttpResponse를 반환합니다. render()는 템플릿을 불러와 컨텍스트로 채웁니다.

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 객체

request.GET/POST는 QueryDict입니다(.get()이 안전합니다). request.user는 인증된 사용자 또는 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 타입

JsonResponse는 JSON으로 직렬화합니다. redirect()는 URL 경로나 인수가 있는 네임드 URL을 받습니다.

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

뷰 데코레이터

login_required는 미인증 사용자를 LOGIN_URL로 리다이렉트합니다. require_POST/GET은 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

파일 업로드 뷰

request.FILES에 업로드된 파일이 들어 있습니다. 큰 파일은 메모리에 통째로 올리지 않도록 .chunks()를 사용하세요.

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

클래스 기반 뷰

TemplateView

TemplateView는 정적 템플릿을 렌더링합니다. 추가 컨텍스트는 get_context_data()를 오버라이드하세요.

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는 자동 페이징하며 컨텍스트에 object_list와 page_obj를 제공합니다. 필터링에는 get_queryset()을 오버라이드하세요.

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는 URL의 pk나 slug로 단일 객체를 가져옵니다. 커스텀 조회에는 get_object()를 오버라이드하세요.

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는 폼 표시, 검증, 저장을 처리합니다. 저장 전 로직에는 form_valid()를 오버라이드하세요.

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'

믹스인

믹스인은 클래스 기반 뷰에 재사용 가능한 동작을 더합니다. Django는 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 라우팅

기본 URL 설정

path()는 URL 패턴을 뷰에 매핑합니다. name=은 역방향 URL 조회를 가능하게 합니다. <int:pk>는 정수를 캡처합니다.

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

앱 URL 포함

include()는 URL 매칭을 앱의 urls.py에 위임합니다. app_name은 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'),
]

패스 컨버터

패스 컨버터는 URL 세그먼트를 자동으로 타입 캐스팅합니다. 복잡한 정규식 패턴에는 re_path를 쓰세요.

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)

네임드 URL & reverse()

네임드 URL은 경로를 하드코딩하는 대신 이름으로 라우트를 참조하게 합니다. reverse()는 Python에서 URL을 생성합니다.

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 네임스페이스

네임스페이스는 앱 간 이름 충돌을 막습니다. 네임스페이스는 앱의 app_name과 일치해야 합니다.

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

템플릿 (DTL)

템플릿 상속

extends는 기본 템플릿을 상속합니다. 블록은 재정의 가능한 영역을 정의합니다. 템플릿은 부모를 하나만 상속할 수 있습니다.

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

변수 & 태그

{{ }}는 변수를 출력하고, {% %}는 태그를 실행합니다. forloop.counter는 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 %}

템플릿 필터

필터는 파이프 | 문법으로 변수 출력을 변형합니다. 일부는 콜론 뒤에 인수를 받습니다. 필터는 체이닝할 수 있습니다.

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

내장 템플릿 태그

csrf_token은 모든 POST 폼에 필요합니다. include는 서브 템플릿을 렌더링합니다. load는 커스텀 태그 라이브러리를 임포트합니다.

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

커스텀 템플릿 태그

태그는 app/templatetags/ 디렉터리에 둡니다. 함수에는 @register.simple_tag, 값 변형에는 @register.filter를 씁니다.

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

폼

폼 정의

forms.Form은 독립적인 폼을 만듭니다. 각 필드는 HTML 위젯을 자동 생성합니다. 필드 타입이 검증을 제공합니다.

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은 모델로부터 폼을 자동 생성합니다. fields/exclude가 나타날 필드를 결정합니다. widgets이 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'}

폼 검증

clean_<field>()는 단일 필드를 검증합니다. clean()은 폼 전체를 검증합니다. 실패 시 ValidationError를 발생시키세요.

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

템플릿에서 폼 렌더링

as_p/as_table/as_ul은 모든 필드를 자동 렌더링합니다. 커스텀 레이아웃에는 필드를 개별 렌더링하세요. POST에는 csrf_token이 필요합니다.

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>

뷰에서 폼 처리

request.POST를 전달하면 폼이 바인딩됩니다. is_valid()가 검증을 실행합니다. save(commit=False)는 저장되지 않은 객체를 반환합니다.

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이 HTML 렌더링을 제어합니다. CSS 클래스, 플레이스홀더, HTML5 입력 타입에는 attrs dict를 전달하세요.

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.register보다 @admin.register가 권장됩니다. 모델은 등록되어야 관리자 인터페이스에 나타납니다.

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 커스터마이징

list_display는 목록 뷰의 컬럼을 보여줍니다. list_filter는 사이드바 필터를 추가합니다. search_fields는 검색 상자를 활성화합니다.

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

인라인 관리

인라인은 부모와 같은 페이지에서 관련 모델을 편집합니다. extra=1이면 빈 행 하나가 기본 표시됩니다.

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

커스텀 관리자 액션

액션은 목록 페이지의 드롭다운에 나타납니다. request와 queryset을 받습니다. message_user가 플래시 메시지를 보여줍니다.

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

관리자 사이트 설정

브랜딩에는 site_header/site_title을 오버라이드하세요. 여러 관리자 사이트에는 커스텀 AdminSite 인스턴스를 만듭니다.

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

인증

내장 User 모델

Django의 User 모델에는 username, password(해시됨), email, first_name, last_name, 권한 flag가 있습니다.

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

로그인 & 로그아웃

authenticate()는 자격 증명을 검증합니다(User 또는 None 반환). login()이 세션을 만들고, logout()이 지웁니다.

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

사용자 등록

UserCreationForm은 내장 검증과 함께 username, 비밀번호, 비밀번호 확인을 처리합니다.

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는 LOGIN_URL(기본값 /accounts/login/)로 리다이렉트합니다. CBV에서는 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

비밀번호 관리

update_session_auth_hash는 비밀번호 변경 후 로그아웃되는 것을 막습니다. 비밀번호 검증기는 사이트 전체 규칙을 강제합니다.

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

커스텀 User 모델

필드를 추가하려면 AbstractUser를 서브클래싱하세요. AUTH_USER_MODEL은 초반에 설정하세요 — 나중에 바꾸기 어렵습니다.

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

미들웨어

내장 미들웨어

순서가 중요합니다! SecurityMiddleware가 먼저, 그다음 세션, 그다음 인증입니다. CSRF 검사는 뷰 처리 전에 실행됩니다.

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

커스텀 함수 미들웨어

함수 미들웨어는 신식 팩토리 패턴을 씁니다. get_response가 다음 미들웨어나 뷰를 호출합니다.

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

클래스 기반 미들웨어

__init__은 시작 시 한 번, __call__은 요청마다 실행됩니다. process_view가 응답을 반환하면 뷰를 건너뜁니다.

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

미들웨어 순서 & 흐름

요청은 위→아래로 미들웨어를 통과하고, 응답은 아래→위로 거슬러 올라갑니다. 보안 미들웨어를 가장 앞에 두세요.

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

미들웨어 활용 사례

미들웨어는 조기 종료(즉시 HttpResponse 반환)할 수도 있고, 뷰에서 쓸 데이터를 request에 붙일 수도 있습니다.

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

정적 & 미디어 파일

정적 파일 설정

STATIC_URL은 URL 접두사입니다. STATICFILES_DIRS는 소스 위치(개발)이고, STATIC_ROOT는 프로덕션 수집 대상입니다.

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

개발 중 정적 파일 서빙

Django는 DEBUG=True일 때만 정적 파일을 자동 서빙합니다. 프로덕션에서는 웹 서버(nginx)나 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

템플릿에서 정적 파일 사용

{% load static %}이 필요합니다. {% static %}은 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">

미디어 파일 설정

MEDIA_ROOT는 파일시스템 경로이고, MEDIA_URL은 URL 접두사입니다. upload_to는 경로 문자열이나 콜러블이 될 수 있습니다.

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 명령

배포 전에 collectstatic을 실행하세요. WhiteNoise를 쓰면 nginx 없이 Django가 직접 프로덕션 정적 파일을 서빙할 수 있습니다.

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

세션 & 쿠키

세션 설정

기본 세션 엔진은 DB에 저장합니다. cached_db는 캐시 + DB에 기록합니다. signed_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

세션 데이터 설정 & 조회

세션은 dict처럼 동작합니다. .get()은 KeyError를 피합니다. flush()는 데이터를 지우고 새 세션 키를 만듭니다(로그아웃용).

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

세션 백엔드

cache가 가장 빠르지만 휘발성입니다. cached_db가 좋은 균형입니다. signed_cookies는 4KB 제한이 있지만 서버 저장소가 필요 없습니다.

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'

쿠키

set_cookie는 응답에 추가합니다. request.COOKIES는 들어온 쿠키를 읽습니다. httponly는 JS 접근을 막습니다(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')

세션 만료

set_expiry(0)는 브라우저 닫힘, set_expiry(None)는 설정값 사용입니다. 정리는 clearsessions를 cron으로 실행하세요.

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

시그널

내장 시그널

시그널은 결합도 낮은 앱들이 액션에 반응하게 합니다. post_save는 save() 완료 후, pre_save는 그 전에 발생합니다.

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

시그널 수신자 연결

@receiver가 함수를 시그널에 연결합니다. sender는 특정 모델로 제한합니다. created는 새 객체일 때만 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()

시그널 연결 해제

disconnect()는 테스트 중이거나 캐스케이드 액션을 막아야 할 때 유용합니다. receiver와 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)

커스텀 시그널

시그널은 모듈 수준에서 정의합니다. send()가 모든 수신자에게 알립니다. kwargs는 연결된 모든 수신자에게 전달됩니다.

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

시그널 활용 & 주의점

시그널 핸들러는 시작 시 연결되도록 AppConfig.ready()에서 임포트하세요. 느린 작업은 피하세요 — 비동기 작업은 Celery를 쓰세요.

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

캐싱

캐시 설정

프로덕션에는 Redis가 권장됩니다. LocMemCache는 프로세스 로컬입니다(워커 간 공유 불가).

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

cache.get()은 없는 키에 대해 None을 반환합니다. 없을 때만 설정하는 원자성에는 get_or_set을 쓰세요.

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 %}는 렌더링된 HTML 조각을 저장합니다. 잘못된 캐시 콘텐츠를 피하려면 변동되는 인수(사용자 ID, 페이지)를 추가하세요.

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_page는 HttpResponse 전체를 캐시합니다. 캐시 키에 URL이 포함되므로 URL마다 별도 캐시 항목을 갖습니다.

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)

캐시 전략

vary_on_headers는 헤더 값별로 별도 캐시 항목을 만듭니다. API에서는 Accept-Language나 Authorization으로 vary하세요.

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

테스트

테스트 작성

TestCase는 테스트를 DB 트랜잭션으로 감쌉니다(롤백됨). SimpleTestCase는 DB 접근이 없는 테스트용입니다(더 빠름).

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)

테스트 클라이언트

self.client는 서버를 띄우지 않고 HTTP 요청을 흉내 냅니다. .login()은 이후 요청을 위해 인증합니다.

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)

모델 & QuerySet 테스트

테스트 데이터는 setUp()에서 만들고 각 테스트 후 롤백됩니다. 결과 확인에는 .count()와 인덱싱을 쓰세요.

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 & 폼 테스트

reverse()는 이름으로 URL을 만듭니다. resolve()는 URL이 어떤 뷰로 매핑되는지 검사합니다. 폼 테스트는 data= dict로 하세요.

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

픽스처 & 테스트 명령

픽스처는 JSON 파일에서 테스트 데이터를 불러옵니다. 특정 테스트는 앱, 클래스, 메서드 경로로 실행하세요.

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 설치 & 설정

INSTALLED_APPS에 rest_framework를 추가합니다. 기본 인증/권한은 REST_FRAMEWORK 설정 dict에서 구성합니다.

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

시리얼라이저

ModelSerializer는 모델로부터 필드를 자동 생성합니다. source=는 관련 객체에서 가져옵니다. validate_<field>()가 검증을 추가합니다.

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

ViewSet

ModelViewSet은 CRUD(list, create, retrieve, update, destroy)를 제공합니다. 필터링에는 get_queryset()을 오버라이드하세요.

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)

라우터

DefaultRouter는 URL 패턴과 API 루트 뷰를 자동 생성합니다. queryset이 동적이면 URL 네이밍에 basename이 쓰입니다.

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

인증

토큰 인증은 단일 정적 토큰을 씁니다. JWT는 access + refresh 토큰을 발급합니다. SimpleJWT가 가장 인기 있는 JWT 라이브러리입니다.

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

권한

SAFE_METHODS는 GET/HEAD/OPTIONS입니다. has_object_permission은 객체별 접근을 검사합니다. get_permissions()는 액션별 규칙을 허용합니다.

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

배포 & 보안

프로덕션 설정

SECRET_KEY를 버전 관리에 커밋하지 마세요. 환경 변수를 쓰세요. DEBUG=False는 에러 페이지의 정보 누출을 막습니다.

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

프로덕션 정적 파일

collectstatic은 모든 정적 파일을 STATIC_ROOT로 모읍니다. WhiteNoise는 Django 자체에서 gzip 압축·해시된 파일을 서빙합니다.

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

보안 설정

SSL_REDIRECT는 HTTPS를 강제합니다. HSTS는 브라우저에게 항상 HTTPS를 쓰라고 알립니다. X_FRAME_OPTIONS는 클릭재킹을 막습니다.

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 배포

Gunicorn은 동기식입니다(전통적인 Django). Uvicorn은 ASGI(비동기 뷰, 웹소켓)를 지원합니다. 프로세스 매니저를 함께 쓰세요.

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

프로덕션 체크리스트

check --deploy는 Django의 배포 체크리스트를 실행합니다. 빠진 보안 설정과 프로덕션 준비 문제를 지적해 줍니다.

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.