Django

1. 서론

1.1 Django의 탄생 배경과 역사

Django는 2003년 Python 기반으로 설계된 웹 프레임워크로, 신속한 웹 개발과 콘텐츠 관리에 특화된 구조로 설계됨.
로렌스 저널-월드의 뉴스 웹사이트 구축을 위해 개발된 도구로 시작되었으며, 2005년 오픈소스로 공개됨.
Django라는 이름은 재즈 기타리스트 Django Reinhardt에서 영감을 받아 명명됨.
이후 강력한 커뮤니티와 함께 빠르게 발전하여 Python 웹 개발의 표준 프레임워크로 자리 잡음.
Django는 지속적으로 발전하며, 최근 ASGI 지원과 GraphQL 통합 등 최신 기술 트렌드에 발맞춘 기능을 추가하고 있음.

1.2 Django가 해결하고자 하는 주요 문제

반복적인 웹 개발 작업의 자동화를 통해 개발 시간 단축을 지원함.
데이터베이스와 웹 서버 간 통신의 복잡성을 단순화하여 효율적인 데이터 처리 가능.
기본 제공 보안 기능(CSRF 방지, SQL Injection 방지 등)을 통해 보안 문제를 예방함.
프론트엔드와 백엔드의 효율적 통합을 지원하며, 개발자의 생산성을 극대화함.
콘텐츠 관리 시스템(CMS)과의 높은 호환성을 제공하여 다양한 웹 애플리케이션 개발에 적합함.

1.3 Django와 다른 웹 프레임워크 비교

배터리 포함 철학: 웹 개발에 필요한 대부분의 기능을 기본적으로 제공하여 개발 속도를 향상시킴.
ORM 지원: Django ORM은 데이터베이스 작업을 단순화하고, 통합된 방식으로 데이터베이스 작업을 처리함.
보안 중심 설계: CSRF 방지, 사용자 인증 시스템 등 내장된 보안 기능을 통해 일반적 취약점에 대한 방어 가능.
확장성: 소규모 프로젝트부터 대규모 프로젝트까지 유연하게 대응할 수 있는 구조 지원.
생산성 강조: 강력한 커뮤니티 지원과 높은 수준의 공식 문서를 통해 신속한 학습과 문제 해결 가능.
Flask와의 차별점: Flask는 유연성이 뛰어나며 마이크로서비스 아키텍처에 적합하지만, Django는 표준화된 구성을 통해 대규모 표준화된 프로젝트에 적합함.

1.4 Django의 확장성

Django는 다양한 기술과의 통합을 통해 확장 가능성을 강화하고 있음:
- ASGI 지원: Django는 비동기 서버와의 호환성을 제공하여 실시간 통신(WebSocket)과 대규모 비동기 작업에 적합함.
- GraphQL 통합: Graphene-Django를 통해 Django에서 GraphQL API를 쉽게 구현할 수 있음.
- Celery와의 통합: 백그라운드 작업 처리와 대규모 데이터 파이프라인에서 Celery와의 연계를 통해 높은 확장성 제공.
- 클라우드 네이티브 아키텍처 지원: Docker, Kubernetes와 같은 컨테이너 오케스트레이션 도구와의 호환성이 뛰어나며, AWS, GCP, Azure와 같은 클라우드 플랫폼에서도 안정적으로 동작함.
- AI/ML 연계 가능성: Django REST Framework를 활용하여 ML/DL API를 쉽게 배포할 수 있음.

1.5 Django의 대규모 활용 사례

Django는 다양한 산업군에서 대규모 트래픽 처리와 안정성이 요구되는 프로젝트에 활용되고 있음:
- Instagram: Django의 ORM을 활용하여 대규모 데이터베이스의 효율적 관리를 구현함. ASGI 기반 확장으로 실시간 알림과 같은 비동기 작업도 처리 가능.
- Pinterest: Django를 활용한 콘텐츠 관리 및 사용자 데이터를 처리하는 백엔드 시스템 구축. Redis와 Celery를 사용하여 대량의 비동기 작업을 안정적으로 처리함.
- Spotify: Django와 Celery를 결합하여 사용자 추천 시스템과 대규모 음악 스트리밍 데이터 처리.
- 전자상거래 플랫폼: Django의 보안 기능과 관리 도구를 활용하여 빠르게 커스터마이징 가능한 전자상거래 사이트 구축. 예: Shopify와 유사한 구조 지원.
- 핀테크 솔루션: Django REST Framework를 활용하여 결제 처리 및 사용자 데이터 암호화를 구현. 높은 보안 요구 사항을 만족함.

Django는 대규모 트래픽 처리, 실시간 데이터 관리, 클라우드 네이티브 환경 지원 등 다양한 기능을 통해 확장성과 실무 활용성을 입증하고 있음.

2. Django의 기본 개념

2.1 Django 프레임워크 소개

Django는 Python 기반의 고수준 웹 프레임워크로, 신속하고 효율적인 웹 애플리케이션 개발을 지원함.
"배터리 포함" 철학에 따라 웹 개발에 필요한 대부분의 구성 요소를 기본 제공함.
데이터베이스 관리, URL 라우팅, 템플릿 렌더링, 보안 기능 등을 포함한 통합 솔루션 제공.
Python의 심플한 문법과 결합되어 개발자 생산성을 극대화함.
최신 기술 트렌드인 비동기 처리(ASGI 지원)와 GraphQL API 통합 기능을 통해 확장성이 강화됨.

2.2 MTV 아키텍처: 작동 원리와 MVC와의 차이점

Django는 **MTV 아키텍처(Model, Template, View)**를 기반으로 작동하며, MVC(Model, View, Controller)와 유사한 구조를 가짐.
- Model: 데이터베이스의 구조와 비즈니스 로직을 정의하며, ORM을 사용하여 SQL 쿼리 작성을 단순화함.
- Template: 프론트엔드에 표시될 데이터를 정의하고 HTML로 렌더링하며, 재사용 가능한 구조 제공.
- View: 사용자의 요청을 처리하고 적절한 데이터를 반환하는 로직을 포함함.
MVC와 MTV의 차이점:
- MVC: View는 사용자 인터페이스(UI)를 렌더링하고, Controller는 사용자의 요청을 처리함.
- MTV: Django에서 View는 요청과 데이터를 처리하는 역할에 초점을 맞추며, 사용자 인터페이스 렌더링은 Template에서 담당함.
- Django에서 MTV를 채택한 이유:
  - Controller의 복잡성 증가
    - 요청 처리, 데이터 준비, URL 라우팅이 혼재되어 Controller 코드가 비대해질 가능성이 높음.
    - 예: 전자 상거래 시스템에서 상품 조회, 장바구니, 결제 등의 요청이 모두 Controller에 집중되면 유지보수가 어려워짐.
  - URL 라우팅과 비즈니스 로직의 혼재
    - URL 구조 변경 시 Controller 전체에 영향을 미칠 수 있어 확장성과 유지보수에 불리함.
    - 대규모 프로젝트에서 URL 라우팅과 요청 처리 로직의 결합은 주요 병목으로 작용.

구성 요소	MVC	MTV
Model	데이터베이스와 상호작용	데이터베이스와 상호작용
View	사용자 화면 렌더링	요청 처리 및 데이터 준비 수행
Controller	요청 처리 및 데이터 전달 담당	N/A (View & URL 라우팅이 분담)
URL 라우팅	N/A (Controller에 포함)	독립적으로 관리 (`urls.py`)
Template	N/A (MVC의 View에 포함)	사용자 화면(UI) 렌더링

MTV vs MVC 요청 처리 흐름 요약
- MVC 요청 흐름:
  사용자 요청 → Controller → Model과 상호작용 → View로 데이터 전달 → 사용자 화면 렌더링
- MTV 요청 흐름:
  사용자 요청 → URL 라우팅 → View → Model과 상호작용 → Template 렌더링 → 사용자 화면 렌더링

‌

2.3 주요 구성 요소

Model:
- Django Model은 Python 클래스를 기반으로 설계되며, models.Model을 상속받아 테이블과 매핑.
- 각 클래스의 속성은 데이터베이스의 컬럼(Column)에 해당하며, 필드 타입으로 정의.
- Django ORM을 통해 데이터베이스 스키마 정의와 데이터 작업을 간소화.
- 다양한 데이터베이스 엔진(PostgreSQL, MySQL, MongoDB 등)과의 호환성 제공.
- 성능 최적화를 위해 select_related, prefetch_related 등을 활용 가능.
- 예시:
```
from django.db import models

class BlogPost(models.Model):
    title = models.CharField(max_length=255)              # 블로그 글의 제목
    content = models.TextField()                          # 블로그 글의 내용
    created_at = models.DateTimeField(auto_now_add=True)  # 생성된 날짜
```
  - BlogPost 클래스는 데이터베이스 테이블을 나타냄.
    - title, content, created_at은 각각의 데이터베이스 필드.
  - BlogPost.objects.get(id=id)은 ORM을 통해 데이터베이스에서 ID가 id인 데이터를 조회.
Template:
- Django 템플릿 엔진을 사용하여 데이터를 HTML로 렌더링.
- 재사용 가능한 템플릿 블록 구조 제공.
- 템플릿 엔진 선택 기준:
  - Django 템플릿 엔진은 간단한 웹 애플리케이션 개발에 적합하며, Django의 보안 기능(CSRF 토큰 등)을 기본적으로 지원함.
  - Jinja2는 복잡한 템플릿 로직 처리와 성능 최적화에 강점이 있음. Django 프로젝트에서도 쉽게 통합 가능하며, 대규모 프로젝트에서 유용함.
  - 선택 기준:
    - 보안 기능 내장 및 간단한 구조가 필요한 경우: Django 템플릿 엔진.
    - 고성능 및 복잡한 템플릿 처리가 필요한 경우: Jinja2.
- 예시:
```
<h1>{{ post.title }}</h1>
<p>{{ post.content }}</p>
<p>Published on {{ post.created_at|date:"Y-m-d" }}</p>
```
  - {{ post.title }}와 같은 문법으로 View에서 전달된 데이터를 출력.
  - 필터(|date:"Y-m-d")를 사용해 날짜 데이터를 특정 형식으로 변환.

‌

View:
- 요청에 따라 데이터를 처리하고 적절한 응답을 반환.
- 함수형 View와 클래스형 View를 제공하며, 클래스형 View는 재사용성과 확장성이 뛰어남.
- 예시:
```
from django.shortcuts import render 
from .models import BlogPost  

def blog_detail(request, id):
    post = BlogPost.objects.get(id=id)
    return render(request, 'blog_detail.html', {'post': post})
```
  - 데이터 준비: BlogPost.objects.get(id=id)를 사용해 데이터베이스에서 블로그 데이터를 조회.
  - Template에 데이터 전달: render 함수는 조회된 데이터를 blog_detail.html 템플릿으로 전
URL 라우팅:
- urls.py를 사용하여 클라이언트 요청을 적절한 View로 매핑.
- 정규식 및 경로 기반 패턴으로 유연한 라우팅 가능.
- 예시:
```
from django.urls import path
from .views import blog_detail
urlpatterns = [
    path('blog/int:id/', blog_detail, name='blog_detail'),
]
```
  - URL 라우팅은 URL과 View를 연결하며, 요청이 들어오면 blog/<int:id>/에 맞는 View(blog_detail)로 매핑 → /blog/1 요청 시 id=1을 추출해 View 함수로 전달.
Middleware:
- 요청과 응답 사이에 동작하는 구성 요소로, 인증, 캐싱, 보안 등의 기능 제공.
- JWT 인증, 요청 로깅, 사용자 권한 검증과 같은 커스텀 Middleware 작성 가능.

‌

2.4 Django ORM: 개념, 장점, 그리고 SQL과의 비교

Django ORM(Object-Relational Mapping)은 데이터베이스 작업을 Python 객체로 처리할 수 있도록 설계됨.
- SQL 쿼리를 작성하지 않아도 데이터 삽입, 조회, 수정, 삭제 등의 작업 가능.
- Lazy Evaluation(지연 평가)을 통해 필요할 때만 SQL 쿼리를 실행하여 성능 최적화 가능.
- 복잡한 쿼리도 filter, annotate, aggregate 등의 메서드를 사용해 간단히 처리 가능.
장점:
- SQL에 대한 전문 지식 없이 데이터 작업 가능.
- 데이터베이스 변경 시 Python 코드만 수정하면 되므로 유지보수가 쉬움.
- 다중 데이터베이스와의 연결 및 관리 지원.
한계와 보완:
- 복잡한 SQL 쿼리(예: 다중 조인, 서브쿼리)에서 ORM 사용이 비효율적일 수 있음.
- 이를 해결하기 위해 Raw SQL을 병행하거나 데이터 접근 패턴을 최적화해야 함.

2.5 Django 프로젝트 구조

Django의 기본 폴더 구조

Project/                 # 프로젝트 루트 디렉토리
├── manage.py            # Django 커맨드 (서버 실행, 마이그레이션 등 주요 명령어 실행)
├── project/             # 프로젝트 설정 디렉토리 (전체 프로젝트의 설정 파일 저장)
│   ├── __init__.py      # Python 패키지로 인식시킴: from ~ import 가능
│   ├── settings.py      # 프로젝트 설정 파일 (데이터베이스, 앱 등록, 미들웨어 등)
│   ├── urls.py          # URL 라우팅 설정 파일 (클라이언트 요청을 적절한 View로 연결)
│   ├── asgi.py          # ASGI 서버 설정 파일 (비동기 지원 서버 구성)
│   └── wsgi.py          # WSGI 서버 설정 파일 (웹 서버와 Django 연결)
├── app1/                # 첫 번째 앱 디렉토리 (특정 기능 단위를 구현)
│   ├── __init__.py
│   ├── admin.py         # Admin 사이트 설정 (모델 등록 및 관리 설정)
│   ├── apps.py          # 앱 설정 파일 (앱 이름과 구성을 정의)
│   ├── migrations/      # 데이터베이스 마이그레이션 파일 저장소
│   │   └── __init__.py
│   ├── models.py        # 데이터베이스 모델 정의 (테이블 스키마 작성)
│   ├── tests.py         # 테스트 케이스 작성 파일 (유닛 및 통합 테스트 작성)
│   └── views.py         # 뷰 로직 정의 (요청 처리와 응답 반환 로직 포함)
├── app2/                # 두 번째 앱 디렉토리
│   ├── __init__.py
│   ├── admin.py
│   ├── apps.py
│   ├── migrations/
│   │   └── __init__.py
│   ├── models.py
│   ├── tests.py
│   └── views.py
├── templates/           # HTML 템플릿 파일 디렉토리
│   ├── base.html        # 기본 HTML 템플릿 파일 (재사용 가능한 레이아웃)
│   └── app1/            # app1 전용 템플릿 디렉토리
│       └── example.html # 특정 템플릿 파일
├── static/              # 정적 파일 디렉토리 (CSS, JS, 이미지 등)
│   ├── css/             # CSS 파일 디렉토리
│   ├── js/              # JavaScript 파일 디렉토리
│   └── images/          # 이미지 파일 디렉토리
└── db.sqlite3           # SQLite 데이터베이스 파일 (기본값, 개발용)

Django 프로젝트는 명확한 디렉토리 구조를 기반으로 하며, 각 구성 요소가 독립적으로 관리됨:
- settings.py: 프로젝트 설정(데이터베이스, 미들웨어, 앱 등록 등)을 정의.
  - 대규모 프로젝트에서는 환경별로 base.py, dev.py, prod.py로 분리하여 관리 가능.
- urls.py: URL 라우팅을 정의하여 클라이언트 요청을 적절한 View로 매핑.
- models.py: 데이터베이스 모델 정의.
- views.py: 요청 처리 및 데이터 반환 로직 포함.
- templates/: 프론트엔드 렌더링을 위한 HTML 템플릿 파일 저장.
- static/: CSS, JavaScript, 이미지 등 정적 파일 저장.
대규모 프로젝트 설계 사례:
- 앱 간 의존성을 최소화하고 독립적인 기능 단위로 설계:
  - 예: "사용자 관리", "상품 관리", "결제 처리"와 같이 각 앱을 모듈화.
- 환경별 설정 분리:
  - settings/base.py: 공통 설정.
  - settings/dev.py: 개발 환경 설정.
  - settings/prod.py: 운영 환경 설정.
- 공통 모듈(예: 유틸리티 함수, 공통 로직)을 별도의 common 디렉토리로 관리하여 중복 코드 최소화.

Django의 기본 개념과 구성 요소는 웹 개발의 모든 주요 단계를 체계적으로 지원하며, 생산성과 확장성을 극대화할 수 있도록 설계됨.

3. Django Model

3.1 데이터 모델 정의와 설계 전략

Django ORM은 Python 클래스를 기반으로 데이터베이스 테이블을 정의하며, 이를 통해 SQL 없이 데이터 작업을 간소화함.
모델 정의는 Django 애플리케이션 설계의 핵심으로, 데이터 구조와 작업 방식을 체계적으로 설계하는 데 사용됨.

3.1.1 필드 타입과 데이터베이스 매핑

Django는 다양한 필드 타입을 제공하며, 이를 통해 데이터베이스의 컬럼 속성을 정의.

주요 필드 타입:

CharField: 고정된 길이의 문자열. (max_length 필수 지정)
TextField: 긴 문자열.
IntegerField: 정수형 데이터.
DateTimeField: 날짜 및 시간 데이터.
BooleanField: True/False 값을 저장.
DecimalField: 고정 소수점 숫자. (max_digits와 decimal_places 필수)
ForeignKey: 다른 모델과 1:N 관계를 정의.
ManyToManyField: 다대다 관계 정의.

예시:

from django.db import models

class Product(models.Model):
    name = models.CharField(max_length=100)                            # 상품 이름
    description = models.TextField()                                   # 상품 설명
    price = models.DecimalField(max_digits=10, decimal_places=2)       # 상품 가격
    is_active = models.BooleanField(default=True)                      # 활성화 여부
    stock = models.IntegerField()                                      # 재고 수량
    created_at = models.DateTimeField(auto_now_add=True)               # 생성 날짜
    updated_at = models.DateTimeField(auto_now=True)                   # 업데이트 날짜
    launch_date = models.DateField(null=True, blank=True)              # 출시 날짜
    rating = models.FloatField(null=True, blank=True)                  # 사용자 평점
    tags = models.ManyToManyField('Tag')                               # 다대다 관계(태그)
    category = models.ForeignKey('Category', on_delete=models.CASCADE) # 1:N 관계(카테고리)

class Tag(models.Model):
    name = models.CharField(max_length=50) # Product는 여러 Tag를 가질 수 있음 (Many-to-Many)

class Category(models.Model):
    name = models.CharField(max_length=50) # Product는 하나의 카테고리(Category)에 속함 (1:N)

3.1.2 필드 옵션과 유효성 검증

각 필드는 다양한 옵션을 통해 데이터 유효성을 보장하고 기본값을 설정하며 데이터베이스 제약 조건을 정의 가능.

주요 필드 옵션:

null: 데이터베이스에서 NULL 값 허용 (default=False).
blank: Django 폼에서 빈 값 허용 (default=False).
default: 필드의 기본값 설정.
choices: 필드 값 선택지 제한.
unique: 필드 값의 중복을 허용하지 않음.
editable: 관리 화면에서 필드를 수정 가능 여부 결정.
help_text: 폼 필드에서 사용자를 위한 도움말 표시.
db_index: 인덱스를 추가해 검색 성능 최적화.

예시 필드 옵션:

from django.db import models
from django.core.validators import MinValueValidator, MaxValueValidator

class BlogPost(models.Model):
    STATUS_CHOICES = [
        ('draft', 'Draft'),
        ('published', 'Published'),
    ]

    title = models.CharField(               # 블로그 제목
        max_length=255,
        null=False,
        blank=False,
        db_index=True,
        help_text="Enter the title of the blog post."
    )  
    status = models.CharField(              # 블로그 상태
        max_length=10,
        choices=STATUS_CHOICES,
        default='draft'
    )  
    views = models.PositiveIntegerField(    # 조회수
        default=0,
        validators=[
            MinValueValidator(0),
            MaxValueValidator(10000)
        ]
    ) 
    is_featured = models.BooleanField(      # 주요 게시물 여부
        default=False,
        editable=True
    )

유효성 검증 옵션:

validators: 특정 필드에 대해 유효성을 검증.
clean(): 객체 단위의 유효성 검증.
validators는 특정 필드에 적용되며, clean()은 모델 전체에서 복합 검증 가능.

예시:

from django.db import models
from django.core.exceptions import ValidationError
from django.core.validators import MinValueValidator, MaxValueValidator

class Product(models.Model):
    name = models.CharField(max_length=255)  
    price = models.DecimalField(
        max_digits=10,
        decimal_places=2,
        validators=[MinValueValidator(0.01)]
    ) 
    stock = models.PositiveIntegerField(
        validators=[MinValueValidator(0), MaxValueValidator(10000)]
    )
     
    release_date = models.DateField(null=True, blank=True)  

    def clean(self):
        if self.price <= 0:
            raise ValidationError("Price must be greater than 0.")
        if self.stock < 0:
            raise ValidationError("Stock cannot be negative.")

    def save(self, *args, **kwargs):
        self.full_clean()  # 유효성 검사를 명시적으로 호출
        super().save(*args, **kwargs)

3.1.3 Meta 클래스 활용

Django 모델의 Meta 클래스는 데이터베이스 테이블의 동작 방식을 제어하는 설정 제공.

주요 Meta 옵션:

db_table: 데이터베이스에서 테이블 이름 지정.
ordering: QuerySet 기본 정렬 방식 지정.
verbose_name: 모델의 단수형 이름. → 관리자 페이지에서 보기좋게 표시
verbose_name_plural: 모델의 복수형 이름. → 관리자 페이지의 목록에서 보기좋게 표시
unique_together: 다중 필드의 고유성 정의.
index_together: 다중 필드에 인덱스를 추가 → 검색속도 최적화
permissions: 사용자 정의 권한 추가.
get_latest_by: 최신 데이터를 가져올 기본 필드 지정.

예시:

from django.db import models

class BlogPost(models.Model):
    title = models.CharField(max_length=255) 
    content = models.TextField() 
    created_at = models.DateTimeField(auto_now_add=True)  
    updated_at = models.DateTimeField(auto_now=True) 

    class Meta:
        db_table = 'blog_post'                       # 데이터베이스 테이블 이름
        ordering = ['-created_at']                   # 기본 정렬 기준: 생성일 내림차순
        verbose_name = 'Blog Post'                   # 관리자 페이지에서 단수형 이름
        verbose_name_plural = 'Blog Posts'           # 관리자 페이지에서 복수형 이름
        unique_together = ('title', 'created_at')    # title과 created_at의 고유 조합
        index_together = (('title', 'created_at'),)  # title과 created_at의 복합 인덱스
        permissions = [
            ("can_publish", "Can publish blog post"),         # 사용자 정의 권한
            ("can_delete_all", "Can delete all blog posts"),  # 사용자 정의 권한 추가
        ]

3.1.4 모델 설계 팁

Django 모델 설계는 애플리케이션 데이터 구조를 효율적으로 정의하고 유지보수성을 높이는 데 중점을 둬야 함.

1. 데이터 정규화와 비정규화의 전략적 적용

데이터 중복을 줄이고 저장 공간을 효율적으로 활용하기 위해 정규화를 우선적으로 고려.
성능 최적화가 중요한 경우, 자주 조회되는 데이터를 비정규화하여 읽기 성능을 높임.
예: 자주 사용되는 카테고리 이름을 다른 테이블에서 참조하기보다는 모델에 직접 포함.

2. 필드 타입과 옵션의 신중한 선택

문자열 데이터는 길이에 따라 CharField(짧은 데이터)와 TextField(긴 데이터)를 선택.
숫자 데이터는 사용 목적에 따라 IntegerField, DecimalField, FloatField를 선택:
- 예) 금액 계산은 정밀도가 높은 DecimalField 추천.
db_index=True를 사용해 검색 빈도가 높은 필드에 인덱스를 추가.
choices 옵션을 사용해 데이터 입력 범위를 제한하고 일관성을 유지.

3. Meta 클래스의 효과적인 활용

기본 정렬 순서를 자주 사용하는 필드로 설정하여 QuerySet 결과를 정렬하지 않아도 되도록 설계.
복합 인덱스(index_together 또는 indexes)를 사용해 자주 사용되는 검색 조건의 성능을 최적화.
고유성 보장이 필요한 필드 조합은 unique_together 또는 UniqueConstraint를 활용해 데이터 무결성을 유지.

4. 유효성 검증을 고려한 필드 설계

validators를 사용해 필드별 데이터 검증 로직을 간단히 처리.
예: 숫자 필드에 최소값과 최대값을 설정해 잘못된 데이터 입력 방지.
복합 조건 검증이 필요한 경우 clean 메서드를 통해 모델 수준에서 유효성을 확인.

5. 유지보수성과 성능을 고려한 설계

모델 설계 초기에 데이터의 성격(읽기/쓰기 비중, 데이터 크기, 관계)을 분석하여 필드와 관계를 설계.
정렬 및 검색이 많은 필드는 db_index와 Meta 클래스의 ordering을 통해 기본 동작을 최적화.
모델 변경이 예상되는 경우, 스키마 변경의 영향을 최소화하도록 설계.

‌

3.2 데이터베이스 마이그레이션

Django는 데이터베이스 스키마 변경 및 데이터 구조 관리를 효율적으로 수행할 수 있도록 마이그레이션 시스템을 제공.

3.2.1 기본 마이그레이션 작업과 명령어

Django의 마이그레이션은 모델 변경 사항을 데이터베이스에 반영하는 프로세스를 자동화하며, 주요 명령어는 다음과 같음:

makemigrations: 모델의 변경 사항을 감지하고 마이그레이션 파일을 생성.
migrate: 생성된 마이그레이션 파일을 기반으로 데이터베이스를 변경.
sqlmigrate: 마이그레이션 파일의 SQL 변환 결과를 확인.

예시:

python manage.py makemigrations

python manage.py migrate

python manage.py sqlmigrate app_name 0001_initial

‌

3.2.2 데이터베이스 구조 변환과 `RunPython` 활용

데이터베이스 구조변환 작업이 필요한 경우, Django는 RunPython을 통해 Python 코드를 실행할 수 있도록 지원.

적용 사례:

기존 데이터를 새로운 필드에 맞게 변환.
데이터 이관 작업(예: 한 모델에서 다른 모델로 데이터 복사).
데이터 변환 작업은 메모리 및 성능을 고려하여 배치 처리로 설계.
대규모 데이터 변환 시 쿼리 최적화를 적극 활용.

예시:

from django.db import migrations

# 데이터 변환 작업 정의
def update_existing_prices(apps, schema_editor):
    # 'shop' 앱의 'Product' 모델을 가져와 모든 상품의 가격에 10%를 추가
    Product = apps.get_model('shop', 'Product')
    for product in Product.objects.all():
        product.price *= 1.1  # 가격에 10% 인상 적용
        product.save()

# 마이그레이션 파일 생성
class Migration(migrations.Migration):
    dependencies = [
        ('shop', '0002_auto'),  # 이전 마이그레이션 파일 의존성
    ]

    operations = [
        migrations.RunPython(update_existing_prices),  # 데이터 변환 실행
    ]

‌

3.2.3 운영 환경에서의 안전한 마이그레이션 전략

운영 환경에서는 마이그레이션 작업이 애플리케이션의 가용성과 성능에 영향을 줄 수 있으므로, 다음과 같은 전략이 필요:

테이블 락 최소화:
- 스키마 변경 작업을 작은 단계로 나누어 테이블 잠금을 최소화.
- 예: 필드 추가 → 배포 → 기본값 설정 → 배포 순서로 작업.
점진적 변경 적용:
- 초기 배포 시에는 필드 추가만 수행하고, 데이터 갱신 작업은 별도 작업으로 나눔.
- 예: 새 필드 추가 후, 기존 데이터를 백그라운드에서 업데이트.
백업과 복구 전략:
- 중요한 데이터베이스 변경 전에는 항상 백업을 수행.
- 마이그레이션 실패 시, 롤백을 위한 스크립트를 준비.

예시:

# 단계 1: 필드 추가 - 테이블 락 최소화
from django.db import migrations, models

class Migration(migrations.Migration):
    dependencies = [
        ('shop', '0003_auto'),  # 이전 마이그레이션 파일
    ]

    operations = [
        migrations.AddField(
            model_name='product',
            name='discount_price',
            field=models.DecimalField(max_digits=10, decimal_places=2, null=True),  # 필드 추가
        ),
    ]

# 단계 2: 데이터 변환 및 기본값 설정
# 데이터 갱신 작업은 분리하여 점진적으로 적용
def populate_discount_price(apps, schema_editor):
    Product = apps.get_model('shop', 'Product')  # 모델 가져오기
    batch_size = 100  # 배치 처리 크기 설정
    qs = Product.objects.all()
    for start in range(0, qs.count(), batch_size):
        for product in qs[start:start + batch_size]:  # 배치 단위로 처리
            product.discount_price = product.price * 0.9  # 할인된 가격 계산
            product.save()

class Migration(migrations.Migration):
    dependencies = [
        ('shop', '0004_add_discount_price'),  # 필드 추가 이후 실행
    ]

    operations = [
        migrations.RunPython(populate_discount_price),  # 데이터 변환 실행
    ]

3.2.4 마이그레이션 요약

Django의 마이그레이션 시스템은 데이터베이스 스키마 변경을 효율적으로 관리하며, 데이터 변환과 운영 환경의 안정성을 지원함.
실무에서는 마이그레이션 작업의 영향을 최소화하기 위한 전략적 접근이 필요하며, 테스트 및 백업을 통해 안정성을 확보해야 함.

4. Django ORM 및 QuerySet 관리

Django ORM은 데이터베이스 작업을 추상화하여 SQL 작성 없이 효율적으로 데이터를 관리할 수 있게 함.

4.1 QuerySet 기본 사용법

QuerySet의 개념
- QuerySet은 데이터베이스 쿼리의 결과를 나타내는 Django의 핵심 객체.
- SQL의 SELECT 문과 동등한 역할 수행.

데이터 조회

all(): 모델의 모든 데이터를 반환.
get(): 특정 조건에 일치하는 한 개의 객체를 반환 (중복 시 오류 발생).
filter(): 조건에 맞는 데이터를 조회.
exclude(): 조건에 맞지 않는 데이터를 제외.

예시:

from myapp.models import BlogPost

# 모든 데이터를 조회
all_posts = BlogPost.objects.all()

# 특정 조건에 맞는 데이터 조회
published_posts = BlogPost.objects.filter(status='published')

# 조건에 맞지 않는 데이터 제외
draft_posts = BlogPost.objects.exclude(status='published')

# 특정 조건의 하나의 데이터 조회
single_post = BlogPost.objects.get(id=1)

조건 연산자

SQL의 WHERE 조건과 유사한 필터링 연산자:
- 정확한 일치: exact
- 부분 일치: icontains, startswith, endswith
- 범위: gte, lte, range
- Null 값: isnull

예시:

from myapp.models import Product

# 정확히 일치하는 조건
exact_match = Product.objects.filter(name__exact='Laptop')

# 부분 일치 조건
contains_match = Product.objects.filter(name__icontains='phone')
starts_with_match = Product.objects.filter(name__startswith='S')
ends_with_match = Product.objects.filter(name__endswith='Pro')

# 범위 조건
price_range = Product.objects.filter(price__gte=500, price__lte=1500)
price_range_alt = Product.objects.filter(price__range=(500, 1500))

# Null 값 필터링
null_category = Product.objects.filter(category__isnull=True)

데이터 존재 확인과 중복 제거

exists(): 데이터 존재 여부를 확인.
distinct(): 중복 데이터를 제거.

예시:

from myapp.models import Order

# 데이터 존재 여부 확인
has_orders = Order.objects.filter(customer_id=123).exists()

# 중복 제거 조회
unique_products = Order.objects.values('product_id').distinct()

Lazy Evaluation

Django QuerySet은 Lazy Evaluation(지연 평가)을 특징으로 함.
QuerySet은 데이터베이스 쿼리를 바로 실행하지 않고, 데이터가 실제로 필요할 때 쿼리를 실행.
명시적 평가 방법:
- list(): QuerySet을 리스트로 변환하여 즉시 데이터를 로드.
- len(): QuerySet의 개수를 계산하며 데이터를 로드.
- bool(): QuerySet이 데이터가 있는지 평가.
주의사항:
- QuerySet이 의도치 않게 여러 번 평가되지 않도록 주의.
- 대규모 데이터 작업에서 QuerySet을 캐싱하여 불필요한 쿼리 실행 방지.

예시:

from myapp.models import BlogPost

# QuerySet 정의
queryset = BlogPost.objects.filter(status='published')

# 데이터베이스 쿼리는 실행되지 않음 (Lazy Evaluation)
print(queryset)  # QuerySet 객체 출력, 실제 데이터는 아직 로드되지 않음

# 명시적 평가: 데이터를 리스트로 변환
post_list = list(queryset)  # 여기서 데이터베이스 쿼리가 실행됨

# 명시적 평가: 데이터 개수 확인
count = queryset.count()  # 쿼리를 실행하여 결과 개수를 계산

# 데이터 존재 여부 확인
exists = queryset.exists()  # 쿼리를 실행하여 데이터 존재 여부를 반환

‌

4.2 고급 QuerySet 활용

정렬과 슬라이싱

QuerySet 결과를 정렬하고 슬라이싱하여 제한된 데이터를 반환.
정렬: order_by()
슬라이싱: Python 리스트 슬라이싱 방식으로 사용 ([start:end]).

예시:

from myapp.models import Product

# 데이터 정렬
products = Product.objects.order_by('price')  # 가격 오름차순 정렬
products_desc = Product.objects.order_by('-price')  # 가격 내림차순 정렬

# 슬라이싱
top_5_expensive = Product.objects.order_by('-price')[:5]  # 상위 5개 비싼 제품
middle_range = Product.objects.order_by('price')[5:10]  # 6번째부터 10번째까지의 제품

집계 및 통계 처리

aggregate(): 데이터를 요약(Sum, Avg, Count 등).
annotate(): 계산된 필드를 각 객체에 추가.

예시:

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

# 전체 주문 금액의 합계
total_revenue = Order.objects.aggregate(total=Sum('amount'))

# 주문 금액의 평균과 최대값
stats = Order.objects.aggregate(average=Avg('amount'), maximum=Max('amount'))

# 고객별 주문 수 계산
customer_order_count = Order.objects.values('customer_id').annotate(order_count=Count('id'))

# 특정 고객의 총 지출 계산
customer_spending = Order.objects.filter(customer_id=123).aggregate(total_spent=Sum('amount'))

조건부 연산과 JSON 처리

Case와 When을 사용해 SQL의 CASE 문 구현.
JSON 필드(JSONField)를 활용하여 데이터 구조 변환 및 처리.
JSON 데이터에서 특정 키를 필터링하거나 업데이트하는 고급 사례:
- 예: JSON 데이터에 key="status"가 "active"인 데이터만 조회.

예시:

from django.db.models import Case, When, F, Value
from myapp.models import Employee

# 조건부 연산: 보너스 필드 생성
employees_with_bonus = Employee.objects.annotate(
    bonus=Case(
        When(salary__gte=100, then=F('salary') * 0.1),  # 급여 100 이상: 10% 보너스
        When(salary__lt=100, then=F('salary') * 0.05),  # 급여 100 미만: 5% 보너스
        default=Value(0)
    )
)

# JSON 데이터 처리: JSONField 활용
from myapp.models import Product

# 특정 JSON 키의 값으로 필터링
active_products = Product.objects.filter(metadata__status='active')

# JSON 키 값 업데이트
Product.objects.filter(metadata__contains={'status': 'active'}).update(
    metadata={'status': 'inactive'}
)

‌

4.3 관계형 데이터 처리

ForeignKey 관계

ForeignKey 필드를 사용하여 데이터 간 관계를 설정하고 조회.
최적화: select_related로 JOIN을 사용해 쿼리 성능을 향상.

예시:

from myapp.models import BlogPost

# 기본 ForeignKey 데이터 조회
posts = BlogPost.objects.all()
for post in posts:
    print(post.title, post.author.name)  # ForeignKey를 통해 author 데이터 조회 (N+1 문제 발생 가능)

# select_related로 ForeignKey 관계 최적화
optimized_posts = BlogPost.objects.select_related('author')  # JOIN을 사용해 author 데이터를 미리 로드
for post in optimized_posts:
    print(post.title, post.author.name)  # N+1 문제 없이 수행

ManyToMany 관계

ManyToMany 관계를 통해 다대다 데이터 처리.
최적화: prefetch_related로 추가 쿼리 최소화.

예시:

from myapp.models import Student

# ManyToMany 관계 데이터 조회
student = Student.objects.get(id=1)
enrolled_courses = student.courses.all()  # N+1 문제

# prefetch_related로 ManyToMany 관계 최적화
students = Student.objects.prefetch_related('courses')  # 추가 쿼리를 최소화하여 데이터 로드
for student in students:
    print(student.name, [course.name for course in student.courses.all()])

역참조와 중첩 관계 처리

역참조를 활용해 관계된 데이터를 조회.
중첩 관계에서 related_name과 필터링 활용.

예시:

from myapp.models import Author

# 역참조 기본 조회
author = Author.objects.get(id=1)
author_posts = author.blogpost_set.all()  # 역참조로 BlogPost 조회

# related_name 사용
author = Author.objects.get(id=1)
author_posts = author.posts.all()  # 역참조 이름을 related_name='posts'로 설정한 경우

# 중첩 관계 필터링
from myapp.models import Category

categories = Category.objects.prefetch_related('posts__author')  # 중첩 관계 데이터 로드
for category in categories:
    for post in category.posts.all():
        print(post.title, post.author.name)

Custom through 모델

ManyToMany 관계에서 추가 필드가 필요한 경우 Custom through 모델 사용.

예시:

from django.db import models

# Custom through 모델 정의
class Membership(models.Model):
    student = models.ForeignKey('Student', on_delete=models.CASCADE)
    course = models.ForeignKey('Course', on_delete=models.CASCADE)
    date_joined = models.DateField()  # 추가 필드
    is_active = models.BooleanField(default=True)

# ManyToMany 관계 정의에 through 사용
class Student(models.Model):
    name = models.CharField(max_length=100)
    courses = models.ManyToManyField('Course', through='Membership')

class Course(models.Model):
    title = models.CharField(max_length=100)

# Custom through 모델 데이터 사용
student = Student.objects.get(id=1)
for membership in student.membership_set.all():
    print(membership.course.title, membership.date_joined, membership.is_active)

4.4 성능 최적화

N+1 문제의 정의
- N+1 문제란, 관계형 데이터를 조회할 때 추가적인 쿼리가 반복적으로 발생하는 문제를 의미.
- 발생 원인:
  - ForeignKey 또는 ManyToMany 관계에서 관련 데이터를 조회할 때 각 객체마다 추가 쿼리가 실행됨.
- 예:
  - BlogPost와 Author 모델이 ForeignKey 관계에 있을 때, 모든 BlogPost와 각 BlogPost의 Author 데이터를 조회하면 다중 쿼리가 발생.
N+1 문제 해결
- select_related:
  - ForeignKey 및 OneToOne 관계를 JOIN으로 미리 로드하여 문제를 해결.
- prefetch_related:
  - ManyToMany 및 역참조 관계를 별도의 SELECT 쿼리로 미리 로드.

성능 개선 사례

N+1 문제 해결 전: 1개의 기본 쿼리 + N개의 추가 쿼리 실행.
N+1 문제 해결 후: 1개의 JOIN 쿼리 또는 1개의 기본 쿼리 + 1개의 추가 쿼리로 실행.

예시:

from myapp.models import BlogPost

# N+1 문제 발생: 각 BlogPost마다 Author 데이터를 추가로 조회
posts = BlogPost.objects.all()
for post in posts:
    print(post.title, post.author.name)  # 각 반복에서 추가 쿼리 발생

# 해결: select_related 사용 (ForeignKey 최적화)
optimized_posts = BlogPost.objects.select_related('author')
for post in optimized_posts:
    print(post.title, post.author.name)  # JOIN을 사용해 쿼리 횟수 최소화

# 해결: prefetch_related 사용 (ManyToMany 최적화)
from myapp.models import Student
students = Student.objects.prefetch_related('courses')
for student in students:
    print(student.name, [course.name for course in student.courses.all()])  # 쿼리 최소화

대규모 데이터 처리

배치 처리: iterator()로 메모리를 효율적으로 사용.
대량 작업:
- bulk_create: 여러 객체를 한 번에 생성.
- bulk_update: 여러 객체를 한 번에 수정.

예시:

from myapp.models import Order

# 대규모 데이터 배치 처리: iterator() 사용
for order in Order.objects.iterator(chunk_size=1000):  # 1000개씩 메모리에 로드
    print(order.id, order.amount)

# 대량 생성: bulk_create
from myapp.models import Product
products = [
    Product(name="Product A", price=10),
    Product(name="Product B", price=15),
    Product(name="Product C", price=20),
]
Product.objects.bulk_create(products)  # 단일 쿼리로 여러 객체 생성

# 대량 업데이트: bulk_update
Product.objects.bulk_update(products, ['price'])  # 단일 쿼리로 가격 업데이트

트랜잭션 관리와 데이터 락

atomic(): 트랜잭션을 묶어 데이터 일관성 유지.
select_for_update: 특정 행에 락을 걸어 동시성 문제 방지.

예시:

from django.db import transaction
from myapp.models import Account

# 트랜잭션 관리
with transaction.atomic():
    sender = Account.objects.select_for_update().get(id=1)  # 락을 걸어 동시성 문제 방지
    receiver = Account.objects.select_for_update().get(id=2)

    if sender.balance >= 100:
        sender.balance -= 100
        receiver.balance += 100

        sender.save()
        receiver.save()  # 작업이 원자적으로 수행됨 (모든 작업이 성공해야만 적용됨)

# 락 없이 데이터 수정 시: 동시성 문제가 발생할 수 있음

QuerySet 캐싱과 디버깅

QuerySet 결과를 캐싱하여 반복 사용 시 성능 향상.
SQL 디버깅: django.db.connection.queries를 사용해 생성된 쿼리 확인.
Django는 자체적으로 ORM 수준의 캐싱을 지원하지 않기 때문에 list(queryset) 같이 QuerySet을 즉시 평가해서 메모리에 로드하거나, Redis같은 외부 캐싱 도굴를 사용해야함

예시:

from django.db import connection
from myapp.models import Product

# QuerySet 캐싱
queryset = Product.objects.filter(price__gte=100)
products = list(queryset)  # 데이터를 명시적으로 캐싱
for product in products:  # 캐싱된 데이터를 재활용
    print(product.name)

# SQL 디버깅
queryset = Product.objects.filter(price__gte=100)
print(queryset.query)  # ORM이 생성한 SQL 쿼리 출력

# 전체 SQL 로그 확인
print(connection.queries)  # 현재 요청에서 실행된 모든 SQL 쿼리를 출력

# 주의사항: 데이터베이스에 변경이 발생해도 캐싱된 QuerySet 내용은 갱신되지 않음

# 캐싱된 QuerySet
products = list(Product.objects.filter(price__gte=100))

# 새로운 객체를 추가해도 캐싱된 데이터에는 반영되지 않음
Product.objects.create(name="New Product", price=150)
for product in products:  # New Product는 출력되지 않음
    print(product.name)

‌

4.5 ORM 응용 사례

대규모 데이터 분석

특정 기간의 매출 통계 생성.
annotate()와 Sum을 활용한 집계 계산.

예시:

from django.db.models import Sum, F, Case, When
from myapp.models import Order

# 특정 기간의 매출 통계 생성
sales_stats = Order.objects.filter(order_date__range=['2023-01-01', '2023-12-31']).aggregate(
    total_revenue=Sum('amount'),
    total_discount=Sum(F('amount') * F('discount_rate'))
)

print("총 매출:", sales_stats['total_revenue'])
print("총 할인 금액:", sales_stats['total_discount'])

# 조건부 집계를 통한 지역별 매출 계산
region_sales = Order.objects.values('region').annotate(
    total_sales=Sum('amount'),
    discounted_sales=Sum(Case(
        When(discount_rate__gt=0, then=F('amount') * (1 - F('discount_rate'))),
        default=0
    ))
)

for region in region_sales:
    print(region['region'], "매출:", region['total_sales'], "할인 후 매출:", region['discounted_sales'])

실시간 데이터 활용

최근 사용자 로그를 효율적으로 조회.
filter()와 order_by()로 최신 로그 가져오기.

예시:

from myapp.models import UserLog

# 최근 24시간 동안의 사용자 로그 조회
from datetime import timedelta
from django.utils.timezone import now

recent_logs = UserLog.objects.filter(timestamp__gte=now() - timedelta(hours=24)).order_by('-timestamp')

for log in recent_logs:
    print(log.user_id, log.action, log.timestamp)

# 특정 사용자별 최신 로그 가져오기
latest_logs = UserLog.objects.values('user_id').annotate(
    last_action=F('action'),
    last_time=F('timestamp')
).order_by('-last_time')

for log in latest_logs:
    print(log['user_id'], "최신 액션:", log['last_action'], "시간:", log['last_time'])

복잡한 비즈니스 로직

조건부 필드 생성과 동적 연산.
Case와 When으로 복잡한 조건 처리.

예시:

from django.db.models import Case, When, Value, F
from myapp.models import Invoice

# 조건부 연산: 동적으로 상태 필드 생성
invoices = Invoice.objects.annotate(
    payment_status=Case(
        When(amount_paid=F('total_amount'), then=Value('완납')),
        When(amount_paid__gt=0, amount_paid__lt=F('total_amount'), then=Value('부분납부')),
        default=Value('미납')
    )
)

for invoice in invoices:
    print(invoice.id, invoice.payment_status)

# 상태별 청구서 개수 집계
status_counts = Invoice.objects.values('payment_status').annotate(count=Count('id'))

for status in status_counts:
    print(status['payment_status'], "청구서 개수:", status['count'])

Raw SQL 활용

Django ORM으로 표현하기 어려운 복잡한 쿼리 수행.
raw() 또는 cursor.execute()를 활용해 고성능 쿼리 실행.

예시:

from django.db import connection

# Raw SQL을 사용하여 복잡한 쿼리 실행
query = """
SELECT region, COUNT(*) as order_count, SUM(amount) as total_sales
FROM orders
WHERE order_date BETWEEN %s AND %s
GROUP BY region
"""
params = ['2023-01-01', '2023-12-31']
with connection.cursor() as cursor:
    cursor.execute(query, params)
    results = cursor.fetchall()

for row in results:
    print("지역:", row[0], "주문 수:", row[1], "총 매출:", row[2])

# Django ORM과 raw() 메서드 활용
from myapp.models import Order
custom_query = Order.objects.raw(
    "SELECT id, amount FROM orders WHERE amount > %s", [100]
)

for order in custom_query:
    print("주문 ID:", order.id, "금액:", order.amount)

다중 데이터베이스 관리

using()과 데이터베이스 라우터를 활용해 다중 데이터베이스 처리.

예시:

from myapp.models import Product

# 기본 데이터베이스에서 조회
default_products = Product.objects.using('default').filter(is_active=True)

# 보조 데이터베이스에서 조회
backup_products = Product.objects.using('backup').filter(is_active=True)

for product in default_products:
    print("기본 DB 상품:", product.name)

for product in backup_products:
    print("백업 DB 상품:", product.name)

# 데이터베이스 간 데이터 복사
from myapp.models import ProductBackup
products = Product.objects.using('default').filter(is_active=True)

for product in products:
    ProductBackup.objects.using('backup').create(
        name=product.name,
        price=product.price,
        is_active=product.is_active
    )

4.6 Django ORM 요약

Django ORM은 기본 데이터 조회부터 고급 활용, 성능 최적화, 관계형 데이터 처리까지 다양한 기능을 제공.
실제 사용할 때는 Lazy Evaluation 이해, N+1 문제 해결, 대규모 데이터 최적화, Raw SQL 활용, 다중 데이터베이스 관리와 같은 고급 기능이 특히 중요.

5. Django View & Template

Django의 View와 Template는 사용자 요청을 처리하고 데이터를 렌더링하여 사용자에게 전달하는 핵심 요소. 이 섹션에서는 함수형 View와 클래스형 View의 비교, Django Template 엔진과 대체 엔진의 차이, 사용자 정의 태그와 필터 작성법, 비동기 View 작성 및 WebSocket 통합 등 고급 기술을 다룸.

5.1 함수형 View와 클래스형 View 비교

함수형 View
- Python의 함수로 작성되며, 단순한 요청 처리에 적합.
- 빠르게 작성 가능하지만, 복잡한 로직을 처리할 때 코드 중복이 발생할 수 있음.
장점:
- 구현이 간단하고 직관적.
- 작은 규모의 프로젝트나 단일 작업에 적합.
단점:
- 복잡한 로직에서는 유지보수와 코드 재사용성이 떨어질 수 있음.

from django.http import HttpResponse

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

클래스형 View
- Python의 클래스로 작성되며, 공통 로직을 재사용할 수 있음.
- 다양한 HTTP 메서드 (GET, POST, PUT 등)를 명확히 분리하여 처리 가능.
장점:
- Mixin과 Generic View를 활용해 코드 재사용성 및 확장성 향상.
- 복잡한 로직을 처리하기 용이.
단점:
- 초기 학습 곡선이 존재하며, 구조를 이해하는 데 시간이 필요.
```
from django.http import HttpResponse
from django.views import View

class HelloWorldView(View):
    def get(self, request):
        return HttpResponse("Hello, World!")
```
실무에서의 선택 기준
- 단순한 작업: 함수형 View.
- 복잡한 로직 처리 및 공통 코드 재사용: 클래스형 View.
- Generic View (ListView, DetailView)와 Mixin 활용으로 생산성 향상.
```
from django.views.generic import ListView
from django.contrib.auth.mixins import LoginRequiredMixin
from myapp.models import BlogPost

# Generic View와 Mixin 활용 예제
class BlogPostListView(LoginRequiredMixin, ListView):
    model = BlogPost
    template_name = 'blogpost_list.html'
    context_object_name = 'posts'
```

5.2 Django의 Template 엔진 원리와 대체 엔진 비교

Django Template 엔진
- Django에서 기본적으로 제공하는 템플릿 엔진으로 보안성과 간단함이 특징.
- 주요 기능:
  - autoescape를 통해 XSS 공격 방지.
  - 템플릿 태그와 필터로 복잡한 로직을 처리하지 않고 데이터를 렌더링.
```

<h1>{{ post.title }}</h1>
<p>{{ post.content }}</p>
<p>작성자: {{ post.author }}</p>
```
대체 엔진: Jinja2
- Django Template 엔진보다 더 빠르고 유연한 Python 기반 템플릿 엔진.
- 특징:
  - 블록 기반 구문 사용.
  - Django Template보다 성능이 뛰어남.
  - 복잡한 로직 처리와 고성능 프로젝트에 적합.
```

<h1>{{ post.title }}</h1>
<p>{{ post.content }}</p>
<p>작성자: {{ post.author }}</p>
```
템플릿 엔진 선택 기준
- Django Template: 보안이 중요하고, Django와의 통합이 간편한 경우.
- Jinja2: 성능과 복잡한 데이터 렌더링이 중요한 대규모 프로젝트.

5.3 사용자 정의 템플릿 태그와 필터 작성

템플릿 태그
- 템플릿에서 복잡한 로직을 처리하거나 반복 작업을 줄이기 위해 사용.
- 사용자 정의 템플릿 태그 작성 과정:
  - templatetags 디렉토리를 생성하고 Python 모듈을 작성.
  - @register.simple_tag 또는 @register.inclusion_tag 데코레이터 사용.
```
# templatetags/custom_tags.py
from django import template

register = template.Library()

@register.simple_tag
def greet_user(name):
    return f"Hello, {name}!"


# html    

{% load custom_tags %}
{% greet_user "John" %}
```

템플릿 필터

데이터를 변환하거나 포맷을 변경하는 데 사용.
사용자 정의 필터 작성 과정:
- templatetags 디렉토리에 필터를 정의하고 @register.filter를 사용해 등록.

# templatetags/custom_filters.py
from django import template

register = template.Library()

@register.filter
def upper_case(value):
    return value.upper()    
    
# html
<!-- 템플릿에서 사용 -->
{% load custom_filters %}
<p>{{ post.title|upper_case }}</p>

실무 활용

다국어 지원을 위한 태그 작성.
사용자 정의 날짜 포맷 필터로 데이터 표현 유연성 강화.

# templatetags/translation_tags.py
from django import template
from django.utils.translation import gettext as _

register = template.Library()

@register.simple_tag
def translate_word(word):
    return _(word)
    
# html

<!-- 템플릿에서 사용 -->
{% load translation_tags %}
<p>{% translate_word "Welcome" %}</p>

5.4 비동기 View: ASGI 기반 실시간 데이터 처리

Django의 ASGI 지원

Django 3.x부터 ASGI를 지원하며, 비동기 View 작성이 가능.
실시간 데이터 처리를 포함한 고성능 작업을 지원.

import asyncio
from django.http import JsonResponse

# 비동기 View 예제
async def async_view(request):
    await asyncio.sleep(2)  # 비동기 작업 예제
    return JsonResponse({'message': 'Hello, World!'})

비동기 View 작성

async def를 사용하여 비동기 View를 정의.
비동기 View 내부에서 ORM 호출은 동기적으로 처리되므로 주의가 필요.

from django.http import JsonResponse
from myapp.models import Product

# ORM은 동기적이므로 주의
async def product_list_view(request):
    products = Product.objects.all()  # ORM 호출은 여전히 동기적으로 처리됨
    data = list(products.values('name', 'price'))
    return JsonResponse(data, safe=False)

실시간 데이터 활용

실시간 알림 시스템 구현.
데이터 스트리밍(예: 대시보드 차트 업데이트) 활용.

from django.http import JsonResponse
import asyncio

async def notification_view(request):
    # 비동기 알림 전송 예제
    await asyncio.sleep(1)
    return JsonResponse({'notification': 'You have a new message!'})

5.5 Django와 WebSocket 통합: 실시간 업데이트 구현

Django Channels

Django에 WebSocket과 비동기 기능을 추가하는 라이브러리.
기존 Django의 WSGI 기반 동기 처리 모델을 보완.

# asgi.py
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
from myapp.routing import websocket_urlpatterns

application = ProtocolTypeRouter({
    'websocket': AuthMiddlewareStack(
        URLRouter(websocket_urlpatterns)
    ),
})

WebSocket 활용

클라이언트와 서버 간의 양방향 통신 구현.
채팅 애플리케이션, 실시간 알림 시스템 등에 적합.

from channels.generic.websocket import AsyncWebsocketConsumer
import json

class ChatConsumer(AsyncWebsocketConsumer):
    async def connect(self):
        await self.accept()
        await self.send(text_data=json.dumps({'message': 'Connected!'}))

    async def disconnect(self, close_code):
        pass

    async def receive(self, text_data):
        data = json.loads(text_data)
        await self.send(text_data=json.dumps({'response': f"Received: {data['message']}"}))

실제 적용

WebSocket 기반 실시간 주식 데이터 업데이트.
채팅 애플리케이션과 알림 시스템 구현.
WebSocket 연결 시 인증 및 권한 관리.

const socket = new WebSocket('ws://localhost:8000/ws/chat/');

socket.onmessage = function(event) {
    const data = JSON.parse(event.data);
    console.log('Message from server:', data.message);
};

socket.onopen = function() {
    socket.send(JSON.stringify({ message: 'Hello, Server!' }));
};

6. Django 관리자(Admin) 활용

Django Admin은 기본적으로 제공되는 강력한 데이터 관리 도구로, 빠른 프로토타이핑과 관리 인터페이스 구축에 적합.

‌

6.1 Django Admin 설정 및 기본 사용법

Django Admin 활성화 및 관리자 계정 생성.
모델 등록을 통한 데이터 관리.
기본적으로 제공되는 검색, 필터링, 정렬 기능 활용.
list_display, search_fields, list_filter와 같은 옵션을 사용해 관리 인터페이스 개선.

# admin.py
from django.contrib import admin
from myapp.models import BlogPost

# 모델 등록
@admin.register(BlogPost)
class BlogPostAdmin(admin.ModelAdmin):
    list_display = ('title', 'author', 'created_at')  # 표시할 필드
    search_fields = ('title', 'author__username')     # 검색 필드
    list_filter = ('status', 'created_at')            # 필터링 필드

6.2 Admin 커스터마이징 기법

관계형 데이터 관리: Inline Admin을 활용한 관계 데이터 처리.
Action 커스터마이징: 관리자 인터페이스에서 사용자 정의 작업 추가.
Form 커스터마이징: 데이터 유효성 검증 및 필드 레이아웃 조정.
관리자 인터페이스 디자인 개선: Django Grappelli와 같은 서드파티 패키지 활용.

# admin.py
from django.contrib import admin
from myapp.models import BlogPost, Comment

class CommentInline(admin.TabularInline):  # StackedInline도 가능
    model = Comment
    extra = 1  # 빈 입력 행 추가

@admin.register(BlogPost)
class BlogPostAdmin(admin.ModelAdmin):
    list_display = ('title', 'author', 'created_at')
    inlines = [CommentInline]  # 관계형 데이터 관리
    
    
# admin.py
from django.contrib import admin
from myapp.models import Order

@admin.register(Order)
class OrderAdmin(admin.ModelAdmin):
    list_display = ('id', 'customer', 'status', 'created_at')
    actions = ['mark_as_shipped']  # 사용자 정의 작업 추가

    # 사용자 정의 Action
    def mark_as_shipped(self, request, queryset):
        queryset.update(status='shipped')  # 선택한 주문 상태를 'shipped'로 변경
        self.message_user(request, f"{queryset.count()}개의 주문이 발송 상태로 업데이트되었습니다.")
    mark_as_shipped.short_description = "선택된 주문을 발송 처리"

6.3 대규모 데이터 관리 시 Admin 최적화

대규모 데이터에서의 성능 문제 이해:
- QuerySet 최적화(select_related, prefetch_related 활용).
- 페이지네이션을 활용해 로드 시간 단축.
캐싱 및 Lazy Evaluation:
- 자주 조회되는 데이터를 캐싱해 응답 속도 향상.
관리자 인터페이스의 성능 디버깅:
- Django Debug Toolbar와 같은 도구를 사용해 쿼리 성능 분석.

# admin.py
from django.contrib import admin
from myapp.models import Product

@admin.register(Product)
class ProductAdmin(admin.ModelAdmin):
    list_display = ('name', 'category', 'price', 'stock')
    list_select_related = ('category',)  # select_related를 활용해 쿼리 최적화
    list_per_page = 50  # 페이지네이션 적용

6.4 보안 및 사용자 관리 강화

Django Admin 보안 설정:
- 관리자 URL 경로 변경: 보안 강화를 위해 기본 경로(/admin/)를 변경.
- HTTPS 설정: 민감한 데이터 보호를 위해 보안 연결 활성화.
- 관리자 접근 제한: IP 제한 및 추가 인증 계층 설정.
사용자 권한 관리:
- 기본 권한 클래스(is_staff, is_superuser) 활용.
- Custom User Model 설계를 통한 관리자 계층 구조 추가.
- 사용자 역할에 따른 Admin 액세스 제한.

# settings.py

# 관리자 URL 경로 변경
ADMIN_URL = 'secureadmin/'  # 기본 경로 변경

# HTTPS 설정
SECURE_SSL_REDIRECT = True  # HTTPS 리다이렉션 활성화
SECURE_HSTS_SECONDS = 3600  # HSTS 설정
SECURE_HSTS_INCLUDE_SUBDOMAINS = True

# IP 제한 미들웨어 설정
ALLOWED_ADMIN_IPS = ['192.168.1.1', '203.0.113.0']

# middleware.py
from django.http import HttpResponseForbidden

class RestrictAdminAccessMiddleware:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        if request.path.startswith('/secureadmin/') and request.META['REMOTE_ADDR'] not in ALLOWED_ADMIN_IPS:
            return HttpResponseForbidden("관리자 페이지에 접근할 수 없습니다.")
        return self.get_response(request)

6.5 Admin 활용 사례

Inline Admin을 활용한 댓글 관리:
- 블로그 게시글과 댓글 간의 관계를 처리하고, Admin에서 댓글을 게시글과 함께 관리.
Action 커스터마이징으로 대량 데이터 업데이트:
- 여러 항목의 상태를 한 번에 변경하거나, 선택 항목에 대해 맞춤 작업 수행.
대규모 데이터 관리 사례:
- 대량의 주문 데이터를 빠르게 조회 및 처리.
- 특정 기간별 매출 데이터를 QuerySet 최적화로 집계.

# admin.py
from django.contrib import admin
from myapp.models import BlogPost, Comment

# Inline Admin: 댓글 관리
class CommentInline(admin.TabularInline):
    model = Comment
    extra = 1  # 빈 입력 행 추가

@admin.register(BlogPost)
class BlogPostAdmin(admin.ModelAdmin):
    list_display = ('title', 'author', 'created_at')
    inlines = [CommentInline]  # 댓글 관리 추가

# Action: 대량 업데이트
@admin.register(Comment)
class CommentAdmin(admin.ModelAdmin):
    list_display = ('post', 'author', 'created_at', 'is_approved')
    actions = ['approve_comments']

    # 대량 승인 작업
    def approve_comments(self, request, queryset):
        queryset.update(is_approved=True)
        self.message_user(request, f"{queryset.count()}개의 댓글이 승인되었습니다.")
    approve_comments.short_description = "선택된 댓글 승인"

7. Django REST Framework (DRF)

Django REST Framework(DRF): Django에서 RESTful API를 쉽게 개발할 수 있도록 지원하는 확장 패키지.

7.1 DRF의 개요 및 필요성

Django REST Framework(DRF)는 Django에서 RESTful API를 쉽게 개발할 수 있도록 지원하는 확장 패키지입니다. DRF는 API 개발에 필요한 다양한 기능(데이터 직렬화, 인증, 권한 관리 등)을 제공하여 생산성을 높이고 유지보수를 용이하게 합니다.

RESTful API의 개념

REST(Representational State Transfer)는 클라이언트-서버 간의 데이터를 효율적으로 주고받기 위한 설계 방식.
RESTful API는 HTTP를 기반으로 CRUD(Create, Read, Update, Delete) 작업을 표준화하여 구현.
클라이언트는 HTTP 메서드(GET, POST, PUT, DELETE 등)를 통해 서버와 상호작용하며, 데이터는 주로 JSON 형식으로 교환됨.

7.1.2 Django REST Framework의 필요성

직렬화 및 데이터 검증 자동화
- DRF는 Python 객체와 JSON 데이터 간의 변환(직렬화)을 자동으로 처리.
- 클라이언트가 전송한 데이터의 유효성을 검사하여 잘못된 데이터가 저장되는 것을 방지.
표준화된 API 설계 지원
- RESTful 규칙에 따라 API를 쉽게 설계 가능.
- URL 라우팅, HTTP 메서드 매핑 등을 DRF가 자동으로 처리.
다양한 인증 및 권한 관리
- DRF는 TokenAuthentication, SessionAuthentication, JWT 인증 등 다양한 인증 방식을 지원.
- 권한 클래스(예: IsAuthenticated, IsAdminUser)를 통해 API 접근을 제어할 수 있음.
확장성 및 커스터마이징
- DRF는 기본 기능 외에도 사용자 정의 Serializer, ViewSet, 권한 클래스 등을 지원하여 유연하게 확장 가능.
- 다양한 서드파티 패키지와 통합 가능.

7.2 Serializer와 데이터 검증

Serializer는 Python 객체와 JSON 데이터 간 변환을 담당하며, RESTful API에서 데이터 무결성을 보장하기 위해 필수적임.
데이터 검증을 통해 잘못된 요청이 서버에 저장되는 것을 방지함.

Serializer의 역할

직렬화 (Serialization): Python 객체를 JSON 형식으로 변환하여 응답 제공.
역직렬화 (Deserialization): 클라이언트가 전송한 JSON 데이터를 Python 객체로 변환 후 저장.
데이터 검증: 필드와 객체 수준에서 유효성 검사 수행.

Serializer의 종류

ModelSerializer

Django 모델과 연동하여 직렬화 및 역직렬화를 자동화함.
코드 중복을 줄이고 CRUD 작업에 적합함.

# serializers.py
from rest_framework import serializers
from myapp.models import BlogPost

class BlogPostSerializer(serializers.ModelSerializer):
    class Meta:
        model = BlogPost                 # 직렬화할 Django 모델 지정
        fields = ['id', 'title', 'content', 'author', 'created_at']

Custom Serializer

비즈니스 로직에 맞춘 복잡한 데이터 처리 시 사용.
중첩 데이터 구조나 조건부 검증 로직 구현 가능.

# serializers.py
from rest_framework import serializers

class CustomDataSerializer(serializers.Serializer):
    title = serializers.CharField(max_length=100)       # 제목 필드
    description = serializers.CharField(max_length=255) # 설명 필드
    is_active = serializers.BooleanField(default=True)  # 활성화 상태 필드

    def validate_title(self, value):
        if not value.startswith("Django"):
            raise serializers.ValidationError("Title must start with 'Django'.")
        return value

Serializer 검증 방법

필드 수준 검증

validate_<필드명>() 메서드를 통해 특정 필드에 대한 유효성을 검사.
예: 가격이 양수인지 확인

# serializers.py
from rest_framework import serializers

class ProductSerializer(serializers.Serializer):
    name = serializers.CharField(max_length=100)
    price = serializers.DecimalField(max_digits=10, decimal_places=2)

    def validate_price(self, value):
        if value <= 0:
            raise serializers.ValidationError("Price must be greater than zero.")
        return value

객체 수준 검증

validate() 메서드로 여러 필드 간 관계를 기반으로 유효성을 검사.
예: 결제 상태가 True이 경우, 결제 총액이 0보다 커야함.

# serializers.py
from rest_framework import serializers

class OrderSerializer(serializers.Serializer):
    order_id = serializers.CharField(max_length=20)
    total_amount = serializers.DecimalField(max_digits=10, decimal_places=2)
    is_paid = serializers.BooleanField()

    def validate(self, data):
        if data['is_paid'] and data['total_amount'] <= 0:
            raise serializers.ValidationError("Paid orders must have a positive total amount.")
        return data

Serializer 기능

API 데이터 전송 관리: 응답 데이터와 요청 데이터에 대한 명확한 정의와 검증 제공.
중첩 데이터 구조 처리: 관계형 데이터를 JSON으로 변환하여 효율적으로 전송 가능.
데이터 변환 로직 중앙화: 직렬화 및 검증 로직이 Serializer에 통합되어 유지보수 용이.

7.3 ViewSet과 Router 활용

ViewSet과 Router는 DRF에서 RESTful API의 개발을 단순화하고 효율적으로 관리하기 위한 주요 기능임.
ViewSet은 CRUD 작업을 하나의 클래스에서 통합적으로 처리하며, Router는 URL 라우팅을 자동으로 연결함으로써 URL 설정을 간소화함.

ViewSet의 개념과 기능

ViewSet은 API View와 유사하지만 기본적으로 제공되는 CRUD 메서드(list, retrieve, create, update, destroy)를 통해 코드 중복을 줄임.
한 개의 ViewSet 클래스에서 여러 HTTP 메서드(GET, POST, PUT, DELETE)를 처리 가능함.
주요 ViewSet 유형:
- ModelViewSet: Django 모델과 연동하여 CRUD 작업을 자동으로 처리함.
- ReadOnlyModelViewSet: 읽기 전용 API로, list와 retrieve 메서드만 제공.

ViewSet의 기본 메서드

ViewSet은 다음 5가지 CRUD 메서드를 기본적으로 제공:
1. list(): 모든 객체 목록을 반환.
2. retrieve(): 특정 객체를 기본 키(PK)로 조회하여 반환.
3. create(): 새로운 객체 생성.
4. update() & partial_update(): 기존 객체 수정.
5. destroy(): 특정 객체 삭제.
이 메서드들은 ModelViewSet에서 자동으로 제공되며, 필요에 따라 커스터마이징 가능.

# views.py
from rest_framework import viewsets
from rest_framework.response import Response
from myapp.models import BlogPost
from myapp.serializers import BlogPostSerializer

class BlogPostViewSet(viewsets.ModelViewSet):
    queryset = BlogPost.objects.all()
    serializer_class = BlogPostSerializer

    def list(self, request):                               # 전체 게시글 조회
        posts = BlogPost.objects.all()
        serializer = self.get_serializer(posts, many=True) # 사용할 직렬화 클래스 지정
        return Response(serializer.data)                   # 응답으로 json 반환

    def retrieve(self, request, pk=None):                  # 특정 게시글 조회
        post = self.get_object()
        serializer = self.get_serializer(post)
        return Response(serializer.data)

    def create(self, request):                             # 새 게시글 생성
        serializer = self.get_serializer(data=request.data)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data, status=201)
        return Response(serializer.errors, status=400)

    def update(self, request, pk=None):                    # 게시글 수정
        post = self.get_object()
        serializer = self.get_serializer(post, data=request.data, partial=True)
        if serializer.is_valid():
            serializer.save()
            return Response(serializer.data)
        return Response(serializer.errors, status=400)

    def destroy(self, request, pk=None):                    # 게시글 삭제
        post = self.get_object()
        post.delete()
        return Response({'message': 'Post deleted successfully'}, status=204)

Custom Action

Custom Action은 기본 CRUD 메서드 외에 추가적인 API 기능을 정의할 때 사용됨.
@action 데코레이터를 사용하여 사용자 정의 엔드포인트 생성 가능.
Custom Action은 detail 옵션에 따라 객체 단위(detail=True) 또는 컬렉션 단위(detail=False)로 작동.

from rest_framework.decorators import action

class BlogPostViewSet(viewsets.ModelViewSet):
    queryset = BlogPost.objects.all()
    serializer_class = BlogPostSerializer

    @action(detail=True, methods=['post'])            # 게시글 발행 기능 정의
    def publish(self, request, pk=None):
        post = self.get_object()
        post.is_published = True
        post.save()
        return Response({'status': 'Post published successfully'})

Router의 개념과 활용

Router는 ViewSet과 URL을 자동으로 연결해주는 클래스.
Router를 사용하면 명시적으로 URL 패턴을 작성할 필요 없이, ViewSet에 등록된 메서드에 따라 엔드포인트가 자동 생성됨.
예: /api/blogposts/, /api/blogposts/{id}/와 같은 URL이 자동으로 설정됨.

# urls.py
from django.urls import path, include
from rest_framework.routers import DefaultRouter
from myapp.views import BlogPostViewSet

router = DefaultRouter()                        # 기본 라우터 생성
router.register(r'blogposts', BlogPostViewSet)  # blogposts' 경로와 BlogPostViewSet 연결

urlpatterns = [
    path('api/', include(router.urls)),         # '/api/blogposts/' 경로 API 제공
]

ViewSet & Router 기능

CRUD 작업 자동화: 기본 메서드 제공으로 API 구현 시 반복 작업을 줄임.
URL 관리 간소화: Router가 URL 라우팅을 자동으로 설정하여 명시적 URL 정의가 불필요함.
맞춤형 API 기능 확장: Custom Action을 통해 추가적인 비즈니스 로직을 구현 가능.

7.4 인증(Authentication) 및 권한 관리

DRF는 다양한 인증(Authentication)과 권한 관리(Permissions) 기능을 통해 API의 보안을 강화함.
RESTful API는 다양한 클라이언트가 접근할 수 있으므로, 민감한 데이터를 보호하기 위해 철저한 인증과 권한 관리가 필요함.

‌

인증 방식 (Authentication)

Token Authentication

클라이언트는 로그인 후 API 서버로부터 인증 토큰을 발급받음.
이후 요청마다 Authorization 헤더에 토큰을 포함하여 인증 수행.
토큰이 유효하지 않을 경우 서버는 401 Unauthorized 상태 코드를 반환.
TokenAuthentication을 사용하여 인증된 사용자만 API에 접근 가능.
클라이언트는 Authorization 헤더에 Token <토큰값>을 포함해야 함.

# settings.py
INSTALLED_APPS += [
    'rest_framework',
    'rest_framework.authtoken',           # Token 인증 앱 추가
]

REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework.authentication.TokenAuthentication',  # Token 인증 설정
    ],
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.IsAuthenticated',         # 인증된 사용자만 접근 허용
    ],
}

# views.py
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticated

class SecureDataView(APIView):
    permission_classes = [IsAuthenticated]  # 인증된 사용자만 접근 가능

    def get(self, request):
        return Response({'message': 'Secure data access granted'})  # 인증 성공 시 메시지 반환
        
# 로그인 후 발급받은 토큰을 Authorization 헤더에 포함하여 요청
curl -X GET http://localhost:8000/api/secure-data/ \
     -H "Authorization: Token <발급받은_토큰>"

Session Authentication

Django의 기본 인증 방식으로, 사용자가 로그인하면 세션 ID가 클라이언트에 저장됨.
API 요청 시 세션 정보를 통해 인증 상태가 유지됨.
웹 브라우저 기반의 클라이언트에 적합한 방식임.

# settings.py
REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework.authentication.SessionAuthentication',  # Django 기본 세션 인증 사용
    ],
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.IsAuthenticated',           # 인증된 사용자만 접근 허용
    ],
}

# views.py
class UserDashboardView(APIView):
    permission_classes = [IsAuthenticated]  # 세션을 통해 인증된 사용자만 접근 가능

    def get(self, request):
        return Response({'dashboard': 'User-specific data displayed here'})
        
# 1. 로그인 요청
curl -X POST http://localhost:8000/api/login/ \
     -d "username=<아이디>&password=<비밀번호>"
     
# 2. 로그인 후 반환된 세션 쿠키를  포함하여 요청     
curl -X GET http://localhost:8000/api/user-dashboard/ \
     -b "sessionid=<세션ID>"

JWT (JSON Web Token) Authentication

경량화된 인증 방식으로, 클라이언트가 JWT 토큰을 발급받아 요청에 사용함.
토큰은 암호화된 페이로드를 포함하여, 자체적으로 인증 정보를 검증 가능.
토큰 갱신(Refresh)을 지원하여 장기적인 세션 유지 가능.

# settings.py
INSTALLED_APPS += [
    'rest_framework_simplejwt',  # JWT 인증 라이브러리 추가
]

REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework_simplejwt.authentication.JWTAuthentication',  # JWT 인증 사용
    ],
}

# views.py
from rest_framework_simplejwt.views import TokenObtainPairView, TokenRefreshView

# 로그인 시 JWT 토큰 발급 뷰
urlpatterns = [
    path('api/token/', TokenObtainPairView.as_view(), name='token_obtain_pair'),
    path('api/token/refresh/', TokenRefreshView.as_view(), name='token_refresh'),
]

# 1. 토큰 발급 요청
curl -X POST http://localhost:8000/api/token/ \
     -d "username=<아이디>&password=<비밀번호>"
     
# 2. 응답 예시
{
    "access": "<JWT_ACCESS_TOKEN>",
    "refresh": "<JWT_REFRESH_TOKEN>"
}     

#. 발급받은 Access Token을 이용하여 API 요청
curl -X GET http://localhost:8000/api/secure-data/ \
     -H "Authorization: Bearer <JWT_ACCESS_TOKEN>"

‌

권한 관리 (Permissions)

권한 관리는 사용자의 인증 상태와 역할에 따라 API 접근을 제어함.
DRF에서 기본적으로 제공하는 권한 클래스:
1. AllowAny: 누구나 API에 접근 가능.
2. IsAuthenticated: 인증된 사용자만 접근 가능.
3. IsAdminUser: 관리자 사용자만 접근 가능.

Custom Permission 예시

Custom 권한 클래스를 통해 세부적인 접근 제어를 구현 가능.

예: 특정 조건을 만족하는 사용자만 데이터를 수정할 수 있도록 제한.

# permissions.py
from rest_framework.permissions import BasePermission

class IsAuthorOrReadOnly(BasePermission):
    """
    사용자 권한: 작성자는 수정 가능, 그 외 사용자는 읽기 전용.
    """

    def has_object_permission(self, request, view, obj):
        if request.method in ('GET', 'HEAD', 'OPTIONS'):
            return True  # 읽기 요청은 누구나 허용
        return obj.author == request.user  # 작성자만 수정 가능
        
# views.py
from rest_framework import viewsets
from myapp.models import BlogPost
from myapp.serializers import BlogPostSerializer
from myapp.permissions import IsAuthorOrReadOnly

class BlogPostViewSet(viewsets.ModelViewSet):
    queryset = BlogPost.objects.all()
    serializer_class = BlogPostSerializer
    permission_classes = [IsAuthorOrReadOnly]  # Custom 권한 클래스 적용
    
    
# 1. 요청
curl -X PUT http://localhost:8000/api/blogposts/1/ \
     -H "Authorization: Token <작성자가_아닌_사용자의_토큰>" \ # 작성자가 아닌 사용자가 PUT 요청을 보내면 접근 거부됨
     -d '{"title": "New Title"}'
     
# 2.응답 예시 (403 Forbidden)
{
    "detail": "You do not have permission to perform this action."
}

7.5 Pagination과 필터링

RESTful API에서는 대량의 데이터를 효율적으로 제공하기 위해 **페이지네이션(Pagination)**과 필터링이 필수적임.
Django REST Framework(DRF)는 다양한 페이지네이션 옵션과 필터링 기능을 기본 제공하여 개발 생산성을 높임.

페이지네이션의 개념과 필요성

클라이언트가 대량의 데이터를 한 번에 요청할 경우, 서버 부하와 네트워크 트래픽이 증가할 수 있음.
페이지네이션을 통해 데이터를 일정 단위로 나누어 전송하여 응답 속도와 성능을 최적화.

페이지네이션 옵션

DRF는 다음과 같은 페이지네이션 방식을 제공함:

PageNumberPagination

데이터를 페이지 단위로 나눔 (예: /api/posts/?page=2).
클라이언트가 요청한 페이지 번호에 해당하는 데이터만 반환.

# settings.py
REST_FRAMEWORK = {
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.PageNumberPagination',  # 페이지 단위 페이지네이션 설정
    'PAGE_SIZE': 10,  # 한 페이지당 10개 항목 반환
}

# views.py
from rest_framework import viewsets
from myapp.models import BlogPost
from myapp.serializers import BlogPostSerializer

class BlogPostViewSet(viewsets.ModelViewSet):
    queryset = BlogPost.objects.all()
    serializer_class = BlogPostSerializer
    
# 두 번째 페이지 데이터를 요청
curl -X GET "http://localhost:8000/api/blogposts/?page=2"

LimitOffsetPagination

시작 위치(offset)와 개수(limit)를 지정하여 데이터 반환 (예: /api/posts/?limit=10&offset=20).

# settings.py
REST_FRAMEWORK = {
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.LimitOffsetPagination',  # 제한 및 시작 위치 설정
    'PAGE_SIZE': 10,  # 기본 limit 값
}

# 20번째부터 10개의 데이터를 요청
curl -X GET "http://localhost:8000/api/blogposts/?limit=10&offset=20"

CursorPagination

커서 기반으로 페이지네이션을 구현하여 데이터 변경에도 일관된 결과 제공.

# settings.py
REST_FRAMEWORK = {
    'DEFAULT_PAGINATION_CLASS': 'rest_framework.pagination.CursorPagination',  # 커서 기반 페이지네이션 설정
    'PAGE_SIZE': 5,  # 한 페이지에 5개 항목 반환
    'ordering': 'created_at',  # 생성일 기준으로 정렬
}

# 커서를 사용하여 페이지 이동
curl -X GET "http://localhost:8000/api/blogposts/"

‌

필터링과 검색 기능

DRF는 필터링 및 검색을 지원하는 여러 백엔드를 제공함.
클라이언트가 Query Parameters를 사용해 원하는 조건에 맞는 데이터를 동적으로 조회 가능.

주요 필터링 옵션

DjangoFilterBackend

모델 필드를 기준으로 필터링을 수행.
예: /api/posts/?author=Cho

# views.py
from django_filters.rest_framework import DjangoFilterBackend
from rest_framework import viewsets
from myapp.models import BlogPost
from myapp.serializers import BlogPostSerializer

class BlogPostViewSet(viewsets.ModelViewSet):
    queryset = BlogPost.objects.all()
    serializer_class = BlogPostSerializer
    filter_backends = [DjangoFilterBackend]  # 필터 백엔드 설정
    filterset_fields = ['author', 'is_published']  # 필터링 가능한 필드 목록
    
# 특정 작성자의 게시글을 필터링
curl -X GET "http://localhost:8000/api/blogposts/?author=Cho"

SearchFilter

특정 텍스트가 포함된 데이터를 검색.
예: /api/posts/?search=django

# views.py
from rest_framework.filters import SearchFilter

class BlogPostViewSet(viewsets.ModelViewSet):
    queryset = BlogPost.objects.all()
    serializer_class = BlogPostSerializer
    filter_backends = [SearchFilter]
    search_fields = ['title', 'content']  # 검색 가능한 필드 목록
    
# 제목이나 내용에 'django'가 포함된 게시글 검색
curl -X GET "http://localhost:8000/api/blogposts/?search=django"

OrderingFilter

지정된 필드를 기준으로 데이터 정렬.
예: /api/posts/?ordering=-created_at

# views.py
from rest_framework.filters import OrderingFilter

class BlogPostViewSet(viewsets.ModelViewSet):
    queryset = BlogPost.objects.all()
    serializer_class = BlogPostSerializer
    filter_backends = [OrderingFilter]
    ordering_fields = ['created_at', 'title']  # 정렬 가능한 필드 목록

# 최신 게시글 순으로 정렬
curl -X GET "http://localhost:8000/api/blogposts/?ordering=-created_at"

Pagination & Filtering 기능

대량 데이터 처리 최적화: 페이지네이션을 통해 대량 데이터를 효율적으로 나누어 전송하여 서버 부하를 줄임.
고급 페이지네이션 구현: 다양한 페이지네이션 방식(PageNumber, LimitOffset, Cursor)을 상황에 맞게 적용 가능.
조건 기반 조회: 클라이언트가 다양한 조건으로 데이터를 조회할 수 있도록 동적 필터링과 검색 기능 제공.
정렬과 커스터마이징: 정렬 기준과 필터링 로직을 커스터마이징하여 다양한 API 요구사항에 대응 가능.

7.6 실시간 API 및 WebSocket 구현

현대 웹 애플리케이션에서는 실시간 데이터 제공이 중요한 기능 중 하나로 자리 잡음.
Django REST Framework(DRF)는 기본적으로 HTTP 기반의 요청-응답 사이클을 제공하지만, 실시간 기능은 Django Channels와 WebSocket을 통해 구현할 수 있음.

‌

WebSocket의 개념과 필요성

WebSocket은 양방향 통신을 지원하여 클라이언트와 서버 간의 실시간 데이터 전송이 가능함.
일반적인 HTTP 요청 방식보다 빠르고 효율적인 통신을 제공함.

Django Channels의 역할

Django Channels는 Django 애플리케이션에 비동기 기능을 추가하여 WebSocket 통신을 지원함.
Redis와 같은 채널 레이어(Channel Layer)를 통해 연결 상태를 관리하고, 메시지를 브로드캐스트하는 기능을 제공함.
이를 통해 비동기 이벤트 처리가 필요한 웹 애플리케이션에서 효율적인 통신이 가능함.

‌

실시간 API 기능 구현 단계

Channels 설치 및 설정

Django 프로젝트에 channels 패키지를 설치하고, 프로젝트 설정에 추가함.

pip install channels

INSTALLED_APPS += [
    'channels',  # Channels 앱 추가 (WebSocket 및 비동기 지원)
]

# ASGI 설정 추가 (Django가 ASGI 서버로 동작하도록 설정)
ASGI_APPLICATION = 'myproject.asgi.application'

# Channels 레이어 설정 (예: Redis 사용)
CHANNEL_LAYERS = {
    'default': {
        'BACKEND': 'channels_redis.core.RedisChannelLayer',  # Redis를 채널 레이어로 사용
        'CONFIG': {
            'hosts': [('127.0.0.1', 6379)],  # Redis 서버 주소 및 포트 설정
        },
    },
}

WebSocket Consumer 정의

컨슈머는 WebSocket 연결, 메시지 수신 및 전송을 담당하는 클래스임.
클라이언트와 서버 간의 실시간 통신을 관리하는 핵심 역할을 수행함.

# consumers.py
from channels.generic.websocket import AsyncWebsocketConsumer
import json

class ChatConsumer(AsyncWebsocketConsumer):
    async def connect(self):                # WebSocket 연결 시 호출되는 메서드
        self.room_name = 'chat_room'
        self.room_group_name = f'chat_{self.room_name}' # 채팅 그룹 이름 생성

        # WebSocket 연결 시 해당 그룹에 참여
        await self.channel_layer.group_add(
            self.room_group_name,            # 그룹 이름
            self.channel_name                # 현재 WebSocket 채널 이름
        )

        await self.accept()  # WebSocket 연결 수락

    async def disconnect(self, close_code):
        # WebSocket 연결 종료 시 그룹에서 제거
        await self.channel_layer.group_discard(
            self.room_group_name,
            self.channel_name                 # 현재 WebSocket 채널 이름 제거
        )

    async def receive(self, text_data):  # 클라이언트로부터 메시지를 수신할 때 호출되는 메서드
        data = json.loads(text_data)
        message = data['message']

        # 그룹에 메시지 브로드캐스트 (모든 연결된 클라이언트에게 전송)
        await self.channel_layer.group_send(
            self.room_group_name,
            {
                'type': 'chat_message', # 이벤트 타입 정의
                'message': message      # 전송할 메시지 데이터
            }
        )

    async def chat_message(self, event):  # 그룹 메시지를 수신했을 때 호출되는 메서드
        message = event['message']   # 그룹에서 수신한 메시지 데이터
        await self.send(text_data=json.dumps({'message': message})) # 클라이언트에 메시지 전송

라우팅 설정

WebSocket 요청을 처리할 경로(URL)를 설정하고, 해당 경로에 컨슈머를 연결함.
프로젝트의 `asgi.py` 파일에 WebSocket 라우팅을 추가하여 비동기 서버 구성을 완료함.

# routing.py
from django.urls import path
from myapp.consumers import ChatConsumer  # ChatConsumer 클래스 가져오기

# WebSocket 라우팅 설정
websocket_urlpatterns = [
    path('ws/chat/', ChatConsumer.as_asgi()),  # '/ws/chat/' 경로에 ChatConsumer 연결
]

# asgi.py (ASGI 설정 파일)
import os
from django.core.asgi import get_asgi_application
from channels.routing import ProtocolTypeRouter, URLRouter
from channels.auth import AuthMiddlewareStack
import myapp.routing

# Django 설정 환경 변수 지정
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myproject.settings')

# ASGI 애플리케이션 설정 (HTTP와 WebSocket 요청 라우팅)
application = ProtocolTypeRouter({
    'http': get_asgi_application(),    # HTTP 요청 처리
    'websocket': AuthMiddlewareStack(  # WebSocket 요청에 인증 미들웨어 적용
        URLRouter(
            myapp.routing.websocket_urlpatterns  # WebSocket 라우팅 설정
        )
    ),
})

클라이언트 요청 및 데이터 송수신

클라이언트는 WebSocket 연결을 통해 서버에 메시지를 전송하고, 서버로부터 실시간 데이터를 수신함.

# 클라이언트 측 WebSocket 연결 및 메시지 전송 코드
const socket = new WebSocket('ws://localhost:8000/ws/chat/');

# WebSocket 연결 성공 시 호출
socket.onopen = function () {
    console.log('WebSocket 연결 성공'); # 서버에 메시지 전송
    socket.send(JSON.stringify({ message: 'Hello, WebSocket!' }));
};

# 서버로부터 메시지를 수신할 때 호출
socket.onmessage = function (event) {
    const data = JSON.parse(event.data);             # 수신한 데이터 파싱
    console.log('서버로부터 메시지 수신:', data.message);  # 메시지 출력
};

# WebSocket 연결이 종료될 때 호출
socket.onclose = function () {
    console.log('WebSocket 연결 종료');
};

‌

실시간 API 기능 예시

실시간 채팅 시스템: 사용자가 메시지를 전송하면, 서버가 해당 메시지를 다른 사용자들에게 즉시 전달.
실시간 알림: 특정 이벤트(예: 댓글 작성, 새로운 메시지 수신 등)가 발생할 때 클라이언트에 즉시 알림 제공.
데이터 스트리밍: 실시간 주식 시세, 경기 점수, 센서 데이터와 같은 지속적 업데이트가 필요한 데이터 전송에 활용.

8. Django의 성능 최적화

Django는 다양한 기능을 제공하는 고수준 웹 프레임워크로, 성능 최적화를 통해 대규모 트래픽과 복잡한 비즈니스 로직을 효율적으로 처리할 수 있음. 캐싱, 비동기 처리, 배포 전략 등 성능을 개선하기 위한 방법들이 존재.

‌

8.1 Caching

캐싱은 빈번하게 호출되는 데이터를 임시 저장하여 성능을 개선하는 핵심 기술임.
Django는 다양한 캐싱 백엔드를 지원하며, 캐시를 적절히 활용하면 응답 속도와 서버 부하를 크게 줄일 수 있음.

‌

Django 캐시 백엔드 유형

로컬 메모리 캐시 (Local Memory Cache)
- 단일 서버에서 메모리에 데이터를 저장하여 빠른 응답 제공.
- 서버 인스턴스마다 별도의 캐시를 사용하며, 다중 서버 환경에서는 공유되지 않음.
```
# settings.py
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.locmem.LocMemCache',  # 로컬 메모리 캐시 사용
        'LOCATION': 'unique-cache-name',  # 캐시 식별자
    }
}
```
분산 캐시 (Distributed Cache)
- 여러 서버 인스턴스에서 Redis나 Memcached와 같은 외부 캐시 서버를 공유함.
- 대규모 트래픽을 처리할 때 캐시 데이터를 중앙에서 관리하여 효율성을 높임.
```
# settings.py
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.redis.RedisCache',  # Redis 캐시 사용
        'LOCATION': 'redis://127.0.0.1:6379/1',  # Redis 서버 주소
    }
}
```

파일 캐시 (File-based Cache)

데이터를 파일 형태로 로컬 디스크에 저장함.
디스크 접근 속도가 느리기 때문에 성능이 중요한 애플리케이션에서는 권장되지 않음.

# settings.py
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.filebased.FileBasedCache',  # 파일 기반 캐시 사용
        'LOCATION': '/var/tmp/django_cache',  # 캐시 파일 저장 경로
    }
}

데이터베이스 캐시

캐시 데이터를 데이터베이스 테이블에 저장하여 관리함.
기존 데이터베이스 시스템을 활용할 수 있지만, 성능이 다소 제한적일 수 있음.

# settings.py
CACHES = {
    'default': {
        'BACKEND': 'django.core.cache.backends.db.DatabaseCache',  # 데이터베이스 캐시 사용
        'LOCATION': 'my_cache_table',  # 캐시 데이터를 저장할 테이블 이름
    }
}

‌

Caching 종류

Template cache
- 복잡한 템플릿 렌더링 결과를 캐싱하여 HTML 응답 속도를 개선함.
- {% cache %} 템플릿 태그를 사용하여 특정 블록의 렌더링 결과를 캐싱 가능.
```

{% load cache %}

{% cache 600 some_cache_key %}  
    <h1>이 콘텐츠는 캐시됨</h1>
{% endcache %}
```

View cache

특정 뷰의 전체 응답을 캐싱하여 빠르게 반환함.
@cache_page 데코레이터를 사용하여 뷰의 결과를 일정 시간 동안 캐싱 가능.
동일한 요청에 대해 캐시된 응답을 빠르게 반환함.

# views.py
from django.views.decorators.cache import cache_page
from django.http import JsonResponse

@cache_page(60 * 5)  # 5분 동안 캐시 유지
def cached_view(request):
    return JsonResponse({'message': '이 응답은 5분 동안 캐시됩니다.'})

QuerySet cache

복잡한 쿼리셋의 결과를 캐싱하여 반복적인 데이터베이스 접근을 줄임.
데이터 변경이 자주 발생하지 않는 경우에 유용함.

# views.py
from django.core.cache import cache
from myapp.models import BlogPost

def cached_queryset_view(request):
    # 쿼리셋 결과를 캐시에 저장 (30분 동안 유지)
    cached_posts = cache.get('cached_blog_posts')
    if not cached_posts:
        cached_posts = BlogPost.objects.filter(is_published=True)
        cache.set('cached_blog_posts', cached_posts, timeout=60 * 30)
    
    return JsonResponse({'posts': list(cached_posts.values())})

‌

캐시 만료 및 무효화 전략

Time-to-Live (TTL): 캐시 항목에 만료 시간을 설정하여 일정 시간이 지나면 자동으로 제거함.
조건부 무효화: 특정 이벤트(데이터 업데이트 등)가 발생했을 때 캐시를 무효화하여 최신 데이터를 유지함.
캐시 키 기반 무효화: 데이터베이스 변경 시 관련 캐시 키를 직접 삭제하여 동기화 유지.

‌

캐싱의 기능

로컬 및 분산 캐시를 통해 서버 부하를 줄이고 응답 시간을 단축함.
Template, View, QuerySet 캐시를 적절히 활용하여 애플리케이션 전반의 성능을 최적화함.
캐시 만료 및 무효화 전략을 통해 최신 데이터와 성능 간의 균형을 유지함.

8.2 비동기 처리와 Celery 통합

웹 애플리케이션에서 장시간 소요되는 작업(예: 이메일 전송, 대규모 데이터 처리 등)을 백그라운드에서 처리하면 성능과 사용자 경험이 크게 개선됨.
Django는 Celery를 활용하여 작업 큐(Task Queue) 기반의 비동기 작업을 효과적으로 관리할 수 있음.

‌

비동기 처리의 필요성

동기 방식에서는 작업이 완료될 때까지 서버가 응답하지 않아 사용자 경험이 저하될 수 있음.
비동기 처리는 서버가 즉시 응답을 반환하고 작업을 백그라운드에서 수행하도록 함으로써 응답 속도를 개선함.
특히, 다수의 작업을 병렬로 처리하여 서버 부하를 분산시킬 수 있음.

‌

Celery 개요 및 주요 개념

Celery 애플리케이션 설정

프로젝트에 Celery 애플리케이션을 생성하고, 메시지 브로커(예: RabbitMQ) 설정을 추가함.

# myproject/celery.py

from __future__ import absolute_import, unicode_literals
import os
from celery import Celery

# Django 설정 모듈 환경 변수 설정
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myproject.settings')

# Celery 애플리케이션 생성 및 설정
app = Celery('myproject')

# Celery에 RabbitMQ 브로커 설정 (AMQP 프로토콜 사용)
app.conf.broker_url = 'amqp://guest:guest@localhost:5672//'

# Django의 설정에서 Celery 관련 설정 가져오기
app.config_from_object('django.conf:settings', namespace='CELERY')

# Django에 등록된 태스크(Task) 자동 검색
app.autodiscover_tasks()

@app.task(bind=True)
def debug_task(self):
    print(f'Request: {self.request!r}')  # 작업 요청 디버그 정보 출력
    
# myproject/__init__.py
from __future__ import absolute_import, unicode_literals
from .celery import app as celery_app  # Celery 앱 초기화
__all__ = ('celery_app',)

비동기 작업(Task) 정의

@shared_task 데코레이터를 사용하여 비동기로 실행할 작업을 정의함.
작업은 Celery 워커(worker)가 처리함.

# tasks.py
from celery import shared_task
from time import sleep

@shared_task
def send_email_task(email_address):
    # 이메일 전송 작업 (5초 지연 시뮬레이션)
    sleep(5)
    return f'Email sent to {email_address}'

비동기 작업 호출

클라이언트 요청 시 태스크를 호출하고 즉시 응답을 반환함.

# views.py
from django.http import JsonResponse
from .tasks import send_email_task

def send_email_view(request):
    email = request.GET.get('email', 'hanjun.cho@allganize.ai')
    # 비동기 작업 호출
    send_email_task.delay(email)
    return JsonResponse({'message': 'Email sending task started.'})

Celery 워커 실행 및 관리
- Celery 워커는 태스크 큐에 등록된 작업을 처리함.
- 워커 실행 명령어를 통해 작업 상태와 로그를 확인 가능함.
```
# 워커 실행 명령어 
celery -A myproject worker --loglevel=info
```

예약 작업 설정

반복적이거나 정기적인 작업을 Celery Beat를 통해 관리할 수 있음.
예: 일정 주기마다 데이터베이스 백업 작업 실행.

# Celery Beat 설치 
pip install django-celery-beat

# tasks.py (주기적 작업 정의 추가)
@shared_task
def backup_database():
    # 데이터베이스 백업 작업
    print('Database backup completed.')

# admin.py
from django_celery_beat.models import PeriodicTask, IntervalSchedule

# 1분마다 실행되는 데이터베이스 백업 작업 설정
schedule, created = IntervalSchedule.objects.get_or_create(
    every=1,
    period=IntervalSchedule.MINUTES,
)

PeriodicTask.objects.create(
    interval=schedule,
    name='Database Backup Task',
    task='myapp.tasks.backup_database',
)

‌

비동기 처리의 기능

응답 속도 개선: 서버가 즉시 응답을 반환하고, 장시간 소요 작업은 백그라운드에서 처리함.
서버 부하 분산: 여러 Celery 워커가 병렬로 작업을 처리하여 서버 리소스를 효율적으로 사용함.
자동화 및 스케줄 관리: Celery Beat를 사용하여 반복적이고 정기적인 작업을 자동으로 실행함.

8.3 대규모 트래픽 처리 및 배포 전략

Django는 기본적으로 단일 프로세스 기반의 WSGI 서버에서 실행됨. 대규모 트래픽을 효과적으로 처리하기 위해 배포 전략과 서버 구성 최적화가 필수적임.
Gunicorn, Nginx, Docker, Kubernetes 등을 활용해서 확장성과 성능 최적화 확보 가능.

‌

Gunicorn과 Nginx를 활용한 배포

Gunicorn
- Python WSGI 애플리케이션 서버로, Django와 같은 웹 애플리케이션을 실행함.
- 병렬 처리를 위해 여러 워커(worker)를 생성하여 동시에 다수의 요청을 처리 가능함.
- Gunicorn은 비동기 기능이 없으므로 정적 파일 제공과 같은 작업을 Nginx와 분리하여 관리하는 것이 일반적임.
```
# 동시 요청을 처리할 워커(worker) 프로세스를 4개 생성하여 병렬 처리
gunicorn myproject.wsgi:application --bind 0.0.0.0:8000 --workers 4 
```

Nginx 설정

정적 파일 제공 및 리버스 프록시 역할을 수행함.
클라이언트 요청을 Gunicorn으로 전달하고, 정적 파일(HTML, CSS, JS 등)을 직접 제공하여 성능을 최적화함.
다중 인스턴스 환경에서는 Nginx가 로드 밸런서를 통해 요청을 분산시킬 수 있음.

# Nginx 설정 예시 (nginx.conf)
server {
    listen 80;                  # nginx가 80번 포트에서 클라이언트 요청을 받음.
    server_name example.com;

    location / {
        proxy_pass http://127.0.0.1:8000;  # Gunicorn으로 요청 전달
        proxy_set_header Host $host; # 요청 헤더에 클라이언트의 호스트 정보와 실제 IP 주소 전달
        proxy_set_header X-Real-IP $remote_addr;
    }

    location /static/ {
        alias /path/to/staticfiles/;  # 정적 파일 경로
    }
}

정적 파일 제공
- Django 프로젝트의 모든 정적 파일(CSS, JS 등)을 지정된 폴더에 수집함.
- Django의 collectstatic 명령어를 사용하여 정적 파일을 한곳에 모아 Nginx가 제공하도록 설정함.
```
# Django의 정적 파일 수집 명령어
python manage.py collectstatic
```

‌

컨테이너 기반 배포

Docker

컨테이너를 통해 애플리케이션의 환경을 독립적으로 실행함.
Docker 이미지는 Django와 관련된 모든 환경 설정(예: Python 버전, 패키지 의존성 등)을 캡슐화하여 배포 환경을 표준화함.
Docker Compose를 사용하여 애플리케이션의 여러 서비스(웹 서버, 데이터베이스 등)를 손쉽게 관리 가능함.

# Django 프로젝트를 위한 Dockerfile 예시
FROM python:3.9-slim


WORKDIR /app # 컨테이너 내에서 작업 디렉토리를 /app 으로 설정.
COPY requirements.txt .
RUN pip install -r requirements.txt

COPY . . # 현재 프로젝트의 모든 파일을 컨테이너의 /app 디렉토리로 복사

# 컨테이너가 실행될 때 Gunicorn 서버를 실행
CMD ["gunicorn", "myproject.wsgi:application", "--bind", "0.0.0.0:8000", "--workers", "4"]

Docker Compose 설정

여러 컨테이너 서비스를 정의하고 네트워크로 연결하여 하나의 애플리케이션처럼 관리 가능함.

version: '3'
services:
  web:
    build: .
    ports:
      - "8000:8000" # 호스트의 8000번 포트와 컨테이너의 8000번 포트를 연결 -> 외부접근 가능
    volumes:
      - .:/app      # 현재 디렉토리를 컨테이너의 /app 디렉토리에 마운트
    environment:
      - DJANGO_SETTINGS_MODULE=myproject.settings # 환경 변수 설정

Kubernetes 배포

Kubernetes는 컨테이너를 관리하고 확장할 수 있는 오케스트레이션 도구임.
여러 복제본(Pod)을 생성하고 트래픽을 자동으로 분산시켜 대규모 트래픽을 처리함.
Horizontal Pod Autoscaler(HPA)를 사용하여 트래픽 변화에 따라 인스턴스를 자동 확장 가능함.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: django-deployment
spec:
  replicas: 3  # 복제본 수
  selector:
    matchLabels:
      app: django-app
  template:
    metadata:
      labels:
        app: django-app
    spec:
      containers:
      - name: django-container
        image: my-django-image:latest
        ports:
        - containerPort: 8000

‌

확장성과 성능 최적화를 위한 주요 전략

로드 밸런싱: Nginx 및 Kubernetes의 로드 밸런서를 사용하여 트래픽을 균등하게 분산함.
자동 확장: Kubernetes의 HPA 기능을 통해 트래픽 증가에 따라 애플리케이션 복제본 수를 동적으로 조정함.
컨테이너 표준화: Docker 이미지를 사용하여 개발 환경과 배포 환경의 일관성을 유지함.
정적 파일 제공 최적화: Nginx가 정적 파일을 제공하여 응답 속도를 향상시키고, Gunicorn은 동적 요청 처리에 집중.

9. 보안 및 테스트

Django는 내장된 보안 기능과 다양한 테스트 도구를 통해 애플리케이션의 안전성과 신뢰성을 확보할 수 있음.

‌

9.1 Django의 보안 메커니즘

Django는 다양한 보안 위협으로부터 애플리케이션을 보호하기 위해 기본적인 보안 기능을 제공함.
대표적인 보안 위협인 CSRF, SQL 인젝션, XSS 등이 존재하고, Django는 이를 방어하는 메커니즘이 존재.

‌

CSRF (Cross-Site Request Forgery)

공격 방법
- 사용자가 신뢰하는 웹사이트에 로그인한 상태에서 공격자가 사용자의 브라우저를 통해 악의적인 요청을 전송하는 방식.
- 예를 들어, 사용자가 로그인된 상태에서 악성 사이트에 접속할 경우 해당 사이트가 사용자의 세션 정보를 이용해 원치 않는 요청(계정 삭제 등)을 전송할 수 있음.
- 브라우저가 자동으로 쿠키와 세션을 포함하기 때문에 사용자는 공격 사실을 인지하지 못함.
- ```
사용자가 로그인된 상태에서 이 페이지를 방문하면, 브라우저가 https://example.com/api/delete_account에 요청을 자동으로 전송하게 됨.

<img src="https://example.com/api/delete_account" />
```
방지 방법
- Django는 POST 요청에 대해 CSRF 토큰을 사용하여 요청의 출처를 검증함.
- 모든 HTML 폼에 {% csrf_token %}을 삽입하거나, API 요청 시 HTTP 헤더에 토큰을 포함하여 전송해야 함
- 서버는 클라이언트가 전송한 CSRF 토큰이 유효한지 확인하여 요청을 허용함.
- ```

<form method="post" action="/submit">
    {% csrf_token %}  
    <input type="text" name="data" />
    <button type="submit">Submit</button>
</form>
```

‌

SQL 인젝션 (SQL Injection)

공격 방법
- 공격자가 사용자 입력을 통해 악의적인 SQL 명령을 삽입하여 데이터베이스를 조작하는 방식.
- 검증되지 않은 사용자 입력이 직접 SQL 쿼리에 포함될 경우, 공격자가 데이터 조회, 삭제 또는 권한 탈취 등의 작업을 수행할 수 있음.
- 예를 들어, 쿼리에 삽입된 입력 값이 "OR 1=1"과 같은 명령일 경우 모든 데이터가 반환될 수 있음.
- ```
# 위험한 코드: 사용자 입력을 직접 SQL에 포함
username = input("Enter your username: ")
query = f"SELECT * FROM users WHERE username = '{username}'"

# 공격자가 입력한 값: 'admin' OR '1'='1'
# 실행되는 SQL 쿼리
# SELECT * FROM users WHERE username = 'admin' OR '1'='1';
# 모든 사용자 정보가 조회됨.
```

방지 방법

Django ORM은 쿼리셋(QuerySet)을 사용하여 SQL 쿼리를 안전하게 생성함으로써 SQL 인젝션을 방지함.
사용자 입력은 자동으로 이스케이프 처리되어 쿼리의 일부로 실행되지 않음.
직접 SQL을 사용할 경우에도 params 매개변수를 활용하여 안전하게 값을 전달해야 함.

# models.py 
from django.db import models

class User(models.Model):
    username = models.CharField(max_length=150)
    password = models.CharField(max_length=128)

# views.py
from django.shortcuts import get_object_or_404
from .models import User

def get_user(request, username):
    # ORM을 사용하여 안전하게 데이터 조회
    user = get_object_or_404(User, username=username)
    return HttpResponse(f'User found: {user.username}')

# SQL 인젝션 위험이 있는 직접 쿼리 예시
# cursor.execute(f"SELECT * FROM users WHERE username = '{username}'")

‌

XSS (Cross-Site Scripting)

공격 방법
- 공격자가 악의적인 스크립트를 웹 페이지에 삽입하여 해당 페이지를 방문한 사용자의 브라우저에서 실행하는 방식.
- 사용자 입력이 제대로 검증되지 않고 출력될 경우 발생하며, 피해자는 브라우저에 저장된 세션 쿠키 탈취, 악성 스크립트 실행 등의 피해를 입을 수 있음.
- 주로 댓글 시스템, 입력 폼과 같은 사용자 콘텐츠가 포함된 페이지에서 발생함.
- ```

<script>alert('You have been hacked');</script>

# 사용자 입력이 이스케이프 처리되지 않고 그대로 출력되면, 페이지를 방문한 모든 사용자의 브라우저에서 해당 스크립트가 실행됨.
 
<p>{{ comment }}</p>
```