← 블로그 홈

Django Ninja 비동기 API 완전 가이드: 고성능 웹 API 구축하기

13분 읽기
Django Python API Async
#Django #Django-Ninja #Async #API #FastAPI #Performance #WebAPI #ASGI #Uvicorn #Pydantic
웹 API의 성능이 중요해진 시대, Django Ninja는 FastAPI의 장점을 Django 생태계에 가져온 혁신적인 라이브러리입니다. Django 3.1부터 지원되는 비동기 뷰를 활용하여 높은 동시성과 성능을 제공합니다. 이 글에서는 Django Ninja를 사용한 비동기...

웹 API의 성능이 중요해진 시대, Django Ninja는 FastAPI의 장점을 Django 생태계에 가져온 혁신적인 라이브러리입니다. Django 3.1부터 지원되는 비동기 뷰를 활용하여 높은 동시성과 성능을 제공합니다. 이 글에서는 Django Ninja를 사용한 비동기 API 구현 방법을 단계별로 알아보겠습니다.

🚀 Django Ninja란?

Django Ninja는 Django를 위한 웹 API 프레임워크로, FastAPI에서 영감을 받아 개발되었습니다. Python 3.6+ 타입 힌트와 Pydantic을 활용하여 자동 검증, 직렬화, API 문서화를 제공합니다.

주요 특징

  • Easy: 직관적이고 사용하기 쉬운 설계
  • FAST execution: Pydantic과 비동기 지원으로 고성능
  • Fast to code: 타입 힌트와 자동 문서화로 빠른 개발
  • Standards-based: OpenAPI(Swagger)와 JSON Schema 기반
  • Django friendly: Django 코어와 ORM과의 훌륭한 통합
  • Production ready: 여러 회사에서 실제 프로덕션 사용 중

📦 설치 및 기본 설정

1. 패키지 설치

# Django Ninja 설치
pip install django-ninja

# 비동기 지원을 위한 Django 3.1 이상 필요
pip install Django>=3.1

# Django 5.2 LTS (2025년 4월 출시) 권장
# Python 3.10-3.13 지원, 향상된 비동기 지원과 복합 기본 키 지원
pip install Django>=5.2

# ASGI 서버 (Uvicorn 권장)
pip install uvicorn[standard]

2. 기본 API 생성

Django Ninja는 INSTALLED_APPS에 추가할 필요가 없습니다 (Django 앱이 아닌 라이브러리이기 때문).

# api.py (프로젝트 루트의 urls.py와 같은 위치)
from ninja import NinjaAPI

api = NinjaAPI()

@api.get("/hello")
def hello(request):
    return "Hello world"

3. URL 설정

# urls.py
from django.contrib import admin
from django.urls import path
from .api import api

urlpatterns = [
    path("admin/", admin.site.urls),
    path("api/", api.urls),  # API 경로 등록
]

🔧 기본 API 구현

1. 간단한 동기 API

# api.py
from ninja import NinjaAPI
from ninja import Schema
from typing import List

api = NinjaAPI()

# 요청/응답 스키마 정의
class UserSchema(Schema):
    id: int
    username: str
    email: str

@api.get("/add")
def add(request, a: int, b: int):
    """간단한 덧셈 API"""
    return {"result": a + b}

@api.get("/users", response=List[UserSchema])
def list_users(request):
    """사용자 목록 조회 (동기)"""
    # 실제 구현에서는 데이터베이스에서 조회
    return [
        {"id": 1, "username": "user1", "email": "user1@example.com"},
        {"id": 2, "username": "user2", "email": "user2@example.com"},
    ]

2. API 문서 확인

서버를 실행하고 다음 URL에서 자동 생성된 API 문서를 확인할 수 있습니다:

  • Swagger UI: http://127.0.0.1:8000/api/docs
  • ReDoc: http://127.0.0.1:8000/api/redoc

⚡ 비동기 API 구현

Django Ninja의 비동기 지원은 Django 3.1+의 비동기 뷰를 기반으로 합니다.

1. 기본 비동기 엔드포인트

import asyncio
from ninja import NinjaAPI

api = NinjaAPI()

# 동기 버전
@api.get("/say-sync")
def say_after_sync(request, delay: int, word: str):
    import time
    time.sleep(delay)
    return {"saying": word}

# 비동기 버전 - async 키워드만 추가!
@api.get("/say-async")
async def say_after_async(request, delay: int, word: str):
    await asyncio.sleep(delay)  # 비동기 대기
    return {"saying": word}

2. 외부 API 호출 예제

import httpx
from ninja import NinjaAPI

api = NinjaAPI()

@api.get("/external-data/{user_id}")
async def get_external_data(request, user_id: int):
    """외부 API에서 사용자 데이터 조회"""
    async with httpx.AsyncClient() as client:
        response = await client.get(
            f"https://jsonplaceholder.typicode.com/users/{user_id}"
        )
        return response.json()

3. Elasticsearch 비동기 검색 예제

from ninja import NinjaAPI
from elasticsearch import AsyncElasticsearch

api = NinjaAPI()
es = AsyncElasticsearch()

@api.get("/search")
async def search(request, q: str):
    """Elasticsearch 비동기 검색"""
    resp = await es.search(
        index="documents", 
        body={"query": {"query_string": {"query": q}}},
        size=20,
    )
    return resp["hits"]

🔄 Django ORM과 비동기 처리

Django ORM은 기본적으로 “async-unsafe”입니다. 비동기 환경에서 ORM을 사용하려면 특별한 방법이 필요합니다.

1. sync_to_async 사용 (Django 4.1 이전)

from asgiref.sync import sync_to_async
from django.contrib.auth.models import User
from ninja import NinjaAPI

api = NinjaAPI()

# 방법 1: 함수 데코레이터 사용
@sync_to_async
def get_user_by_id(user_id):
    return User.objects.get(pk=user_id)

@api.get("/users/{user_id}")
async def get_user(request, user_id: int):
    try:
        user = await get_user_by_id(user_id)
        return {"id": user.id, "username": user.username}
    except User.DoesNotExist:
        return {"error": "User not found"}

# 방법 2: 인라인 사용
@api.get("/users")
async def list_users(request):
    # ❌ 잘못된 방법 - QuerySet은 lazy evaluation
    # users = await sync_to_async(User.objects.all)()
    
    # ✅ 올바른 방법 - list()로 즉시 평가
    users = await sync_to_async(list)(User.objects.all())
    return users

2. Django 4.1+ 비동기 ORM 인터페이스

Django 4.1부터는 네이티브 비동기 ORM 메서드를 제공합니다:

from django.contrib.auth.models import User
from ninja import NinjaAPI, ModelSchema

api = NinjaAPI()

class UserSchema(ModelSchema):
    class Meta:
        model = User
        fields = ['id', 'username', 'email', 'first_name', 'last_name']

@api.get("/users/{user_id}", response=UserSchema)
async def get_user(request, user_id: int):
    """Django 4.1+ 비동기 ORM 사용"""
    try:
        user = await User.objects.aget(pk=user_id)  # aget = async get
        return user
    except User.DoesNotExist:
        return {"error": "User not found"}

@api.get("/users", response=list[UserSchema])
async def list_users(request):
    """QuerySet을 리스트로 변환"""
    users = [user async for user in User.objects.all()]
    return users

@api.post("/users", response=UserSchema)
async def create_user(request, username: str, email: str):
    """비동기 사용자 생성"""
    user = await User.objects.acreate(
        username=username,
        email=email
    )
    return user

# Django 4.2에서 추가된 관계 관리자 비동기 메서드
@api.post("/users/{user_id}/groups")
async def add_user_to_group(request, user_id: int, group_id: int):
    """사용자를 그룹에 추가 (Django 4.2+)"""
    user = await User.objects.aget(pk=user_id)
    group = await Group.objects.aget(pk=group_id)
    await user.groups.aadd(group)  # Django 4.2+
    return {"success": True}

@api.delete("/users/{user_id}/groups/{group_id}")
async def remove_user_from_group(request, user_id: int, group_id: int):
    """사용자를 그룹에서 제거 (Django 4.2+)"""
    user = await User.objects.aget(pk=user_id)
    group = await Group.objects.aget(pk=group_id)
    await user.groups.aremove(group)  # Django 4.2+
    return {"success": True}

3. ModelSchema 활용

Django Ninja는 Django 모델에서 자동으로 스키마를 생성하는 ModelSchema를 제공합니다:

from ninja import ModelSchema
from django.contrib.auth.models import User

# 모든 필드 포함 (권장하지 않음)
class UserSchemaAll(ModelSchema):
    class Meta:
        model = User
        fields = "__all__"

# 특정 필드만 포함 (권장)
class UserSchema(ModelSchema):
    class Meta:
        model = User
        fields = ['id', 'username', 'email', 'first_name', 'last_name']

# 특정 필드 제외
class UserSchemaExclude(ModelSchema):
    class Meta:
        model = User
        exclude = ['password', 'last_login', 'user_permissions']

# PATCH용 스키마 (모든 필드 선택적)
class UserPatchSchema(ModelSchema):
    class Meta:
        model = User
        fields = ['username', 'email', 'first_name', 'last_name']
        fields_optional = ['username', 'email', 'first_name', 'last_name']  # 명시적으로 지정

🚀 서버 실행

1. 개발 환경

# Django 개발 서버 (권장하지 않음)
python manage.py runserver

# Uvicorn 사용 (권장)
uvicorn myproject.asgi:application --reload

# 또는 포트 지정
uvicorn myproject.asgi:application --host 0.0.0.0 --port 8000 --reload

2. 성능 테스트

비동기의 효과를 확인해보겠습니다:

# 100개의 동시 요청으로 테스트
ab -c 100 -n 100 "http://127.0.0.1:8000/api/say-async?delay=3&word=hello"

결과 예시:

  • 동기 버전: 각 요청이 순차적으로 처리되어 총 300초 소요
  • 비동기 버전: 모든 요청이 동시에 처리되어 약 3초 소요

📊 고급 비동기 패턴

1. 병렬 작업 실행

import asyncio
import httpx
from ninja import NinjaAPI

api = NinjaAPI()

@api.get("/combined-data/{user_id}")
async def get_combined_data(request, user_id: int):
    """여러 소스에서 데이터를 병렬로 가져오기"""
    
    async def get_user_data():
        # Django 4.1+ 비동기 ORM
        return await User.objects.aget(pk=user_id)
    
    async def get_posts_data():
        posts = [post async for post in Post.objects.filter(author_id=user_id)]
        return posts
    
    async def get_external_data():
        async with httpx.AsyncClient() as client:
            response = await client.get(f"https://api.example.com/users/{user_id}")
            return response.json()
    
    # 모든 작업을 병렬로 실행
    user, posts, external = await asyncio.gather(
        get_user_data(),
        get_posts_data(),
        get_external_data(),
        return_exceptions=True  # 일부 실패해도 계속 진행
    )
    
    return {
        "user": user,
        "posts": posts if not isinstance(posts, Exception) else [],
        "external": external if not isinstance(external, Exception) else {}
    }

2. Django 5.2 LTS 신규 기능 활용

Django 5.2는 2025년 4월에 출시된 최신 LTS 버전입니다. Python 3.10-3.13을 지원하며, 향상된 비동기 지원과 복합 기본 키(Composite Primary Keys) 지원이 추가되었습니다.

from django.db import models

# Django 5.2의 복합 기본 키 지원
class OrderItem(models.Model):
    order = models.ForeignKey('Order', on_delete=models.CASCADE)
    product = models.ForeignKey('Product', on_delete=models.CASCADE)
    quantity = models.IntegerField()
    
    class Meta:
        constraints = [
            models.UniqueConstraint(
                fields=['order', 'product'],
                name='unique_order_product'
            )
        ]

@api.get("/order-items/{order_id}/{product_id}")
async def get_order_item(request, order_id: int, product_id: int):
    """복합 키를 사용한 조회"""
    try:
        order_item = await OrderItem.objects.aget(
            order_id=order_id,
            product_id=product_id
        )
        return {
            "order_id": order_item.order_id,
            "product_id": order_item.product_id,
            "quantity": order_item.quantity
        }
    except OrderItem.DoesNotExist:
        return {"error": "Order item not found"}

2. 비동기 트랜잭션

from django.db import transaction
from asgiref.sync import sync_to_async

@api.post("/bulk-create")
async def bulk_create_users(request, users_data: list[dict]):
    """트랜잭션을 사용한 대량 생성"""
    
    @sync_to_async
    @transaction.atomic
    def create_users_in_transaction(users_list):
        created_users = []
        for user_data in users_list:
            user = User.objects.create(
                username=user_data['username'],
                email=user_data['email']
            )
            created_users.append(user)
        return created_users
    
    try:
        users = await create_users_in_transaction(users_data)
        return {"created": len(users), "success": True}
    except Exception as e:
        return {"error": str(e), "success": False}

# Django 4.1+에서는 비동기 트랜잭션도 지원
@api.post("/async-transaction-example")
async def async_transaction_example(request, user_data: dict):
    """비동기 트랜잭션 사용 (Django 4.1+)"""
    try:
        async with transaction.atomic():
            user = await User.objects.acreate(**user_data)
            # 추가 비동기 작업들...
            return {"user_id": user.id, "success": True}
    except Exception as e:
        return {"error": str(e), "success": False}

📊 성능 최적화

1. 데이터베이스 쿼리 최적화

from django.db.models import Prefetch
from ninja import NinjaAPI

api = NinjaAPI()

@api.get("/optimized-users")
async def get_optimized_users(request):
    """최적화된 사용자 목록 조회"""
    
    # select_related와 prefetch_related 활용
    async def get_users_with_relations():
        users_queryset = User.objects.select_related('profile').prefetch_related(
            'groups',
            Prefetch('posts', queryset=Post.objects.filter(published=True))
        )
        return [user async for user in users_queryset]
    
    users = await get_users_with_relations()
    
    return [
        {
            "id": user.id,
            "username": user.username,
            "email": user.email,
            "profile": user.profile.bio if hasattr(user, 'profile') else None,
            "groups_count": await user.groups.acount(),  # Django 4.1+
            "published_posts_count": len([p for p in user.posts.all() if p.published])
        }
        for user in users
    ]

2. 연결 풀링 설정

# settings.py
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',
        'NAME': 'myproject',
        'USER': 'myuser',
        'PASSWORD': 'mypassword',
        'HOST': 'localhost',
        'PORT': '5432',
        'CONN_MAX_AGE': 60,  # 1-5분 권장 (0은 매 요청마다 새 연결)
        'OPTIONS': {
            'MAX_CONNS': 20,
        },
    }
}

3. 캐싱 전략

import json
from django.core.cache import cache
from asgiref.sync import sync_to_async

@api.get("/cached-data/{key}")
async def get_cached_data(request, key: str):
    """비동기 캐싱 패턴"""
    cache_key = f"data_{key}"
    
    # 캐시 확인
    cached_data = await sync_to_async(cache.get)(cache_key)
    if cached_data:
        return json.loads(cached_data)
    
    # 데이터 생성 (비용이 많이 드는 작업)
    async def expensive_operation():
        await asyncio.sleep(2)  # 가상의 무거운 작업
        return {"result": f"processed_{key}", "timestamp": time.time()}
    
    data = await expensive_operation()
    
    # 캐시에 저장 (10분)
    await sync_to_async(cache.set)(
        cache_key, 
        json.dumps(data, default=str), 
        600
    )
    
    return data

🧪 테스트

1. 비동기 API 테스트

# test_api.py
import pytest
from ninja.testing import TestAsyncClient
from myapp.api import api

@pytest.mark.asyncio
async def test_async_endpoint():
    """비동기 엔드포인트 테스트"""
    client = TestAsyncClient(api)
    
    response = await client.get("/say-async?delay=1&word=test")
    assert response.status_code == 200
    assert response.json() == {"saying": "test"}

@pytest.mark.asyncio
async def test_concurrent_requests():
    """동시 요청 테스트"""
    client = TestAsyncClient(api)
    
    import asyncio
    tasks = [
        client.get("/say-async?delay=1&word=test")
        for _ in range(10)
    ]
    
    responses = await asyncio.gather(*tasks)
    
    for response in responses:
        assert response.status_code == 200
        assert response.json()["saying"] == "test"

2. 부하 테스트

# Apache Bench를 사용한 동시성 테스트
ab -c 100 -n 1000 "http://127.0.0.1:8000/api/say-async?delay=1&word=hello"

# wrk를 사용한 더 정밀한 테스트
wrk -t12 -c100 -d30s "http://127.0.0.1:8000/api/say-async?delay=1&word=hello"

🚀 프로덕션 배포

1. Uvicorn 설정

# uvicorn_config.py
import multiprocessing

# CPU 코어 수에 따라 워커 수 결정
workers = multiprocessing.cpu_count()

bind = "0.0.0.0:8000"
worker_class = "uvicorn.workers.UvicornWorker"
worker_connections = 1000
max_requests = 1000
max_requests_jitter = 100

2. Docker 컨테이너화

# Dockerfile
FROM python:3.11-slim

WORKDIR /app

# 시스템 의존성 설치
RUN apt-get update && apt-get install -y \
    gcc \
    && rm -rf /var/lib/apt/lists/*

# Python 의존성 설치
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# 애플리케이션 복사
COPY . .

# 정적 파일 수집
RUN python manage.py collectstatic --noinput

# 포트 노출
EXPOSE 8000

# Uvicorn으로 서버 실행
CMD ["uvicorn", "myproject.asgi:application", "--host", "0.0.0.0", "--port", "8000", "--workers", "4"]

3. Nginx 리버스 프록시

# nginx.conf
upstream django_app {
    server app1:8000;
    server app2:8000;
    server app3:8000;
    server app4:8000;
}

server {
    listen 80;
    server_name api.example.com;

    # 정적 파일 직접 서빙
    location /static/ {
        alias /app/staticfiles/;
        expires 1y;
        add_header Cache-Control "public, immutable";
    }

    # API 요청 프록시
    location /api/ {
        proxy_pass http://django_app;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        
        # 타임아웃 설정
        proxy_connect_timeout 60s;
        proxy_send_timeout 60s;
        proxy_read_timeout 60s;
        
        # 버퍼링 설정
        proxy_buffering on;
        proxy_buffer_size 128k;
        proxy_buffers 4 256k;
        proxy_busy_buffers_size 256k;
    }
}

🎯 실전 활용 팁

1. 에러 처리 패턴

from ninja import NinjaAPI
from ninja.errors import HttpError
import logging

logger = logging.getLogger(__name__)
api = NinjaAPI()

@api.exception_handler(Exception)
def general_exception_handler(request, exc):
    """전역 예외 처리기"""
    logger.error(f"Unexpected error: {exc}", exc_info=True)
    return api.create_response(
        request,
        {"error": "Internal server error"}, 
        status=500
    )

@api.exception_handler(HttpError)
def http_error_handler(request, exc):
    """HTTP 에러 처리기"""
    return api.create_response(
        request,
        {"error": str(exc)}, 
        status=exc.status_code
    )

# 커스텀 예외 처리
class UserNotFoundError(Exception):
    pass

@api.exception_handler(UserNotFoundError)
def user_not_found_handler(request, exc):
    return api.create_response(
        request,
        {"error": "User not found"}, 
        status=404
    )

2. 인증 및 권한 처리

from ninja.security import HttpBearer
from django.contrib.auth.models import User
from django.contrib.auth import authenticate
import jwt
from django.conf import settings

class AuthBearer(HttpBearer):
    def authenticate(self, request, token):
        try:
            # JWT 토큰 검증
            payload = jwt.decode(token, settings.SECRET_KEY, algorithms=['HS256'])
            user_id = payload.get('user_id')
            
            if user_id:
                user = User.objects.get(id=user_id)
                return user
        except (jwt.InvalidTokenError, User.DoesNotExist):
            pass
        
        return None

auth = AuthBearer()

@api.post("/login")
def login(request, username: str, password: str):
    """로그인 엔드포인트"""
    user = authenticate(username=username, password=password)
    if user:
        token = jwt.encode(
            {'user_id': user.id}, 
            settings.SECRET_KEY, 
            algorithm='HS256'
        )
        return {"token": token}
    return {"error": "Invalid credentials"}

@api.get("/profile", auth=auth)
async def get_profile(request):
    """인증이 필요한 엔드포인트"""
    user = request.auth  # 인증된 사용자
    return {
        "id": user.id,
        "username": user.username,
        "email": user.email
    }

3. API 버전 관리

from ninja import Router

# V1 API
router_v1 = Router()

@router_v1.get("/users")
async def list_users_v1(request):
    """API v1 사용자 목록"""
    users = [user async for user in User.objects.all()]
    return {"version": "1.0", "users": users}

# V2 API (향상된 기능)
router_v2 = Router()

@router_v2.get("/users")
async def list_users_v2(request, page: int = 1, size: int = 10):
    """API v2 사용자 목록 (페이지네이션 지원)"""
    offset = (page - 1) * size
    users_query = User.objects.all()[offset:offset + size]
    users = [user async for user in users_query]
    
    total_count = await User.objects.acount()
    
    return {
        "version": "2.0",
        "users": users,
        "pagination": {
            "page": page,
            "size": size,
            "total": total_count,
            "has_next": offset + size < total_count
        }
    }

# 메인 API에 라우터 등록
api.add_router("/v1/", router_v1)
api.add_router("/v2/", router_v2)

4. 응답 스키마 정의

from ninja import Schema
from typing import Optional

class UserResponse(Schema):
    id: int
    username: str
    email: str
    is_active: bool

class PaginatedResponse(Schema):
    items: list[UserResponse]
    total: int
    page: int
    size: int
    has_next: bool

@api.get("/users", response=PaginatedResponse)
async def list_users_paginated(request, page: int = 1, size: int = 10):
    """스키마를 사용한 타입 안전한 응답"""
    # 구현 생략
    pass

📈 성능 비교

실제 벤치마크 결과를 기반으로 한 성능 비교:

Django REST Framework vs Django Ninja

항목 DRF Django Ninja (동기) Django Ninja (비동기)
처리량 (req/sec) ~1,200 ~2,000 ~4,000+
응답 시간 (ms) ~80 ~50 ~25
메모리 사용량 높음 보통 보통
개발 생산성 보통 높음 높음
타입 안전성 낮음 높음 높음
자동 문서화 수동 자동 자동

벤치마크 조건

  • 테스트 환경: 4코어 8GB RAM
  • 동시 연결: 100개
  • 총 요청: 10,000개
  • 작업: 간단한 JSON 응답

🔧 문제 해결

1. 일반적인 이슈

문제: Django ORM 비동기 관련 오류

# ❌ 잘못된 방법
@api.get("/users")
async def get_users(request):
    return User.objects.all()  # SynchronousOnlyOperation 오류

# ✅ Django 4.1+ 방법
@api.get("/users")
async def get_users(request):
    return [user async for user in User.objects.all()]

# ✅ 이전 버전 방법
@api.get("/users")
async def get_users(request):
    return await sync_to_async(list)(User.objects.all())

문제: 트랜잭션 관련 이슈

# Django 4.1+에서 비동기 트랜잭션
from django.db import transaction

@api.post("/users")
async def create_user(request, user_data: UserSchema):
    async with transaction.atomic():
        user = await User.objects.acreate(**user_data.dict())
        # 추가 작업...
        return user

2. 디버깅 팁

import asyncio
import logging

# 비동기 디버깅 설정
logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(__name__)

@api.get("/debug")
async def debug_endpoint(request):
    """디버깅 정보 제공"""
    current_task = asyncio.current_task()
    all_tasks = asyncio.all_tasks()
    
    return {
        "current_task": str(current_task),
        "total_tasks": len(all_tasks),
        "event_loop": str(asyncio.get_event_loop()),
        "debug": True
    }

3. 모니터링 및 로깅

import time
from functools import wraps

def monitor_performance(func):
    """API 성능 모니터링 데코레이터"""
    @wraps(func)
    async def wrapper(*args, **kwargs):
        start_time = time.time()
        request = args[0] if args else None
        
        try:
            result = await func(*args, **kwargs)
            duration = time.time() - start_time
            
            # 메트릭 수집 (예: Prometheus, DataDog)
            logger.info(f"API {func.__name__} completed in {duration:.3f}s")
            
            return result
        except Exception as e:
            duration = time.time() - start_time
            logger.error(f"API {func.__name__} failed after {duration:.3f}s: {e}")
            raise
    
    return wrapper

@api.get("/monitored")
@monitor_performance
async def monitored_endpoint(request):
    """모니터링이 적용된 엔드포인트"""
    await asyncio.sleep(0.1)  # 가상의 작업
    return {"status": "success"}

🎯 마무리

Django Ninja의 비동기 API는 현대적인 웹 개발의 요구사항을 만족시키는 강력한 도구입니다.

✅ 핵심 장점

  • 개발 생산성: 타입 힌트 기반의 직관적인 API 개발
  • 고성능: 비동기 처리로 높은 동시성 달성
  • 자동 문서화: OpenAPI/Swagger 기반 API 문서 자동 생성
  • Django 통합: 기존 Django 프로젝트와의 완벽한 호환성
  • 타입 안전성: Pydantic을 통한 강력한 데이터 검증

⚠️ 주의사항

  • Django 버전: Django 3.1+ 필요 (비동기 지원), Django 5.2 LTS 권장
  • ORM 사용법: sync_to_async 또는 Django 4.1+ 비동기 ORM 메서드 사용
  • ASGI 서버: 프로덕션에서는 Uvicorn 또는 Daphne 사용 권장
  • 데이터베이스 연결: CONN_MAX_AGE는 60-300초로 설정 권장
  • 학습 곡선: 비동기 프로그래밍 개념 이해 필요

🚀 시작하기

  1. 간단한 프로젝트로 시작: 기본적인 CRUD API부터 구현
  2. 공식 문서 활용: django-ninja.dev 참고
  3. 성능 측정: 기존 API와 성능 비교 테스트
  4. 점진적 마이그레이션: 기존 DRF 프로젝트에서 부분적으로 도입

Django Ninja로 고성능 비동기 API를 구축하여 더 나은 사용자 경험을 제공해보세요! 🎉

이 글을 공유해보세요!