DJango 서버개발, 비동기 작업 처리 (Celery) 소개 및 설정

Django는 높은 생산성과 인기 있는 웹 프레임워크로서, 강력한 기능을 제공합니다. 하지만 복잡한 비즈니스 로직이나 대량의 데이터 처리 작업을 수행할 때는 일반적인 웹 요청 흐름의 외부에서 비동기 처리를 시행할 필요가 있습니다. 이 과정에서 많은 개발자들이 선호하는 도구가 바로 Celery입니다. 이 글에서는 Django에서 Celery를 설정하고 사용하는 방법에 대해 자세히 설명하고, 실습 예제를 통해 비동기 작업 처리의 실제적인 적용 방법을 알아보겠습니다.

1. Celery란?

Celery는 Python으로 작성된 비동기 작업 큐 시스템입니다. 작업(queue) 및 작업자(worker) 개념을 바탕으로 하여, 분산 환경에서 태스크를 비동기적으로 처리할 수 있습니다. 이를 통해 웹 애플리케이션에서 사용자 요청에 대한 응답 속도를 개선하고, 시간 소모적인 작업을 별개로 처리할 수 있습니다.

1.1 주요 특징

  • 비동기 처리: Celery를 사용하여 웹 요청과는 별도로 작업을 실행하여 응답 속도를 개선할 수 있습니다.
  • 분산 시스템 지원: 여러 대의 서버에서 작업을 분산 처리하여 확장성 및 성능을 높일 수 있습니다.
  • 입력 및 결과 저장: 작업의 결과를 데이터베이스나 파일 등 외부 시스템에 저장할 수 있습니다.
  • 스케줄러 기능: 주기적으로 반복되는 작업을 쉽게 관리할 수 있습니다.
  • 다양한 브로커 지원: RabbitMQ, Redis 등 다양한 메시지 브로커와 연동하여 사용할 수 있습니다.

2. Django와 Celery 통합하기

2.1 Celery 설치

Celery를 사용하기 위해서는 먼저 프로젝트에 설치해야 합니다. pip를 사용하여 Celery와 메시지 브로커(여기서는 Redis를 예시로 사용합니다)를 설치합니다. 다음 명령어를 사용하세요:

pip install celery redis

2.2 Django 프로젝트 설정

이제 Django 프로젝트를 설정해야 합니다. 새로운 Django 프로젝트를 생성합니다.

django-admin startproject myproject

그리고 생성된 디렉토리로 이동합니다.

cd myproject

2.3 Redis 설치 및 실행

Redis를 설치하는 방법은 운영 체제에 따라 다릅니다. 만약 Homebrew가 설치되어 있다면, 다음과 같은 명령으로 Redis를 설치하고 실행할 수 있습니다:

brew install redis
brew services start redis

2.4 Celery 설정 파일 생성

Django 프로젝트 디렉토리에 `celery.py`라는 파일을 생성하고 다음과 같이 설정합니다.

import os
from celery import Celery

os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'myproject.settings')

app = Celery('myproject')
app.config_from_object('django.conf:settings', namespace='CELERY')
app.autodiscover_tasks()

여기서 `namespace=’CELERY’`는 Django 설정 파일에서 Celery 관련 설정을 찾을 수 있도록 도와주며, `autodiscover_tasks`는 앱 내의 `tasks.py`에서 자동으로 작업을 발견하고 등록할 수 있게 합니다.

2.5 Django 설정 변경

이제 `settings.py` 파일을 열어 다음과 같이 Celery와 Redis를 설정합니다.

CELERY_BROKER_URL = 'redis://localhost:6379/0'
CELERY_ACCEPT_CONTENT = ['json']
CELERY_TASK_SERIALIZER = 'json'

2.6 비동기 작업 생성

Celery를 사용할 준비가 되었습니다. 다음으로, 실제 비동기 작업을 생성해보겠습니다. 앱 내에 `tasks.py` 파일을 생성하고 다음과 같이 작성합니다.

from celery import shared_task
import time

@shared_task
def sleep_task(seconds):
    time.sleep(seconds)
    return f"Slept for {seconds} seconds!"

2.7 Django 뷰와 연결하기

이제 비동기 작업을 호출할 Django 뷰를 생성합니다. `views.py` 파일을 열고 다음과 같이 작성합니다.

from django.http import JsonResponse
from .tasks import sleep_task

def trigger_sleep_task(request, seconds):
    sleep_task.delay(seconds)  # 비동기적으로 작업 호출
    return JsonResponse({"status": "Task has been started!"})

2.8 URL 설정

마지막으로, 생성한 뷰를 URL에 연결해야 합니다. `urls.py` 파일을 다음과 같이 수정합니다.

from django.urls import path
from .views import trigger_sleep_task

urlpatterns = [
    path('sleep//', trigger_sleep_task, name='trigger_sleep_task'),
]

3. Celery 작업 실행하기

모든 설정이 완료되었으므로, 이제 서버를 실행하고 Celery 작업을 실행할 수 있습니다. 먼저 Django 서버를 실행합니다.

python manage.py runserver

그 다음, 새로운 터미널에서 Celery worker를 실행합니다:

celery -A myproject worker --loglevel=info

이제 브라우저를 열고 `http://localhost:8000/sleep/10/`에 접속하면, 10초 동안 대기하는 비동기 작업이 시작됩니다. 작업이 완료되면 로그에서 결과를 확인할 수 있습니다.

4. 비동기 작업의 응답 처리

Celery는 비동기 작업이 완료되었을 때 작업 결과를 처리할 수 있는 여러 방법을 제공합니다. 예를 들어, 작업 ID를 통해 결과를 조회할 수 있습니다. 이를 위해 Django에서 작업 ID를 반환하도록 뷰를 수정할 수 있습니다.

from django.http import JsonResponse
from .tasks import sleep_task

def trigger_sleep_task(request, seconds):
    task = sleep_task.delay(seconds)  # 비동기적으로 작업 호출
    return JsonResponse({"status": "Task has been started!", "task_id": task.id})

4.1 작업 ID를 통한 상태 확인

작업 ID를 가진 결과를 확인하기 위해 다음과 같은 뷰를 작성할 수 있습니다.

from celery.result import AsyncResult

def check_task_status(request, task_id):
    result = AsyncResult(task_id)
    return JsonResponse({"task_id": task_id, "status": result.status, "result": result.result})

4.2 URL 추가

이제 작업 상태를 조회할 수 있도록 URL을 추가합니다.

urlpatterns = [
    path('sleep//', trigger_sleep_task, name='trigger_sleep_task'),
    path('check_task//', check_task_status, name='check_task_status'),
]

5. Celery Beat: 주기적인 작업 수행

Celery는 주기적으로 작업을 수행할 수 있는 스케줄러 기능인 Celery Beat를 제공합니. 이를 통해 특정 시간 간격으로 지속적으로 작업을 실행할 수 있습니다. 예를 들어, 매 10초마다 특정 함수를 호출하고 싶다면 아래와 같이 설정합니다.

from celery import shared_task
from celery.schedules import crontab
from celery import Celery

app = Celery('myproject')

@app.on_after_configure.connect
def setup_periodic_tasks(sender, **kwargs):
    sender.add_periodic_task(10.0, my_periodic_task.s(), name='Add every 10 seconds')

@shared_task
def my_periodic_task():
    print("This task runs every 10 seconds.")

5.1 기동하기

Celery Beat를 실행하려면 다음 명령어를 사용합니다:

celery -A myproject beat

5.2 주기적인 작업 확인

작업의 로깅을 통해 주기적으로 실행되고 있는 작업들을 확인할 수 있습니다.

6. 결론

이번 포스트에서는 Django와 Celery를 통합하여 비동기 작업 처리 시스템을 구축하는 방법에 대해 살펴보았습니다. 비동기 처리 및 분산 시스템을 통해 웹 애플리케이션의 성능을 극대화할 수 있으며, 주기적인 작업을 통해 자동화된 시스템 구축 또한 가능해집니다. Celery는 많은 Python 프로젝트에서 널리 사용되고 있으며, 이를 통해 더 나은 사용자 경험과 효율적인 시스템 운영이 가능합니다.

이제 여러분은 Django에서 Celery를 설정하고 활용하는 방법을 알게 되었습니다. 비즈니스 요구에 따라 Celery를 적극적으로 사용해보시길 바랍니다!

작성자: 여러분 이름

날짜: YYYY-MM-DD

DJango 서버개발, RESTful API 구축 및 시리얼라이저 사용법

Django는 파이썬으로 작성된 웹 프레임워크로, 빠른 개발과 간편한 유지 보수를 제공합니다. Django는 내장된 관리 시스템, ORM(Object-Relational Mapping), 사용자 인증 시스템, 다양한 미들웨어 등을 제공하여 개발자가 보다 효율적으로 웹 애플리케이션을 구축할 수 있도록 도와줍니다. 본 글에서는 Django를 이용해 RESTful API를 구축하고, 시리얼라이저를 활용하는 방법에 대해 자세히 설명하겠습니다.

1. Django 프로젝트 시작하기

먼저, Django 프로젝트를 시작하기 위해 필요한 패키지를 설치해야 합니다. 아래의 커맨드를 통해 Django와 Django REST Framework를 설치할 수 있습니다.

pip install django djangorestframework

다음으로, Django 프로젝트를 생성합니다. 아래의 명령어를 터미널에 입력하여 새로운 Django 프로젝트를 생성하고, 해당 프로젝트 디렉토리로 이동합니다.

django-admin startproject myproject
cd myproject

프로젝트가 생성되면, 기본적인 Django 애플리케이션을 하나 생성해 보겠습니다. 아래의 명령어를 입력하여 `myapp`이라는 앱을 생성합니다.

python manage.py startapp myapp

2. Django REST Framework 설정하기

생성한 `myapp` 디렉토리의 `settings.py` 파일을 열어, INSTALLED_APPS 목록에 `rest_framework`와 `myapp`을 추가합니다.

# myproject/settings.py
INSTALLED_APPS = [
    ...
    'rest_framework',
    'myapp',
]

3. 데이터베이스 모델 생성하기

이제 RESTful API에서 사용할 데이터베이스 모델을 생성합니다. `myapp/models.py` 파일을 열어 아래의 코드를 추가하세요.

from django.db import models

class Article(models.Model):
    title = models.CharField(max_length=100)
    content = models.TextField()
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.title

위의 모델에서는 제목, 내용, 생성 날짜를 포함하는 `Article` 모델을 정의했습니다. 다음으로, 데이터베이스에 반영하기 위해 마이그레이션을 진행합니다.

python manage.py makemigrations
python manage.py migrate

4. 시리얼라이저(Serializer) 생성하기

Django REST Framework에서는 API를 통해 데이터를 주고받기 위해서 시리얼라이저를 사용합니다. 시리얼라이저는 복잡한 데이터 타입을 JSON과 같은 기본 데이터 타입으로 변환하는 도구입니다. `myapp/serializers.py` 파일을 생성한 후 아래의 코드를 추가합니다.

from rest_framework import serializers
from .models import Article

class ArticleSerializer(serializers.ModelSerializer):
    class Meta:
        model = Article
        fields = '__all__'

위 코드에서 `ArticleSerializer`는 `Article` 모델을 위한 시리얼라이저입니다. `fields`는 변환할 모델의 필드를 지정합니다. `__all__`을 사용하면 모든 필드를 포함합니다.

5. RESTful API 뷰(View) 생성하기

이제 시리얼라이저를 활용하여 API 뷰를 구현할 차례입니다. `myapp/views.py` 파일을 열어 아래의 코드를 추가합니다.

from rest_framework import generics
from .models import Article
from .serializers import ArticleSerializer

class ArticleListCreate(generics.ListCreateAPIView):
    queryset = Article.objects.all()
    serializer_class = ArticleSerializer

class ArticleDetail(generics.RetrieveUpdateDestroyAPIView):
    queryset = Article.objects.all()
    serializer_class = ArticleSerializer

위에서 `ArticleListCreate` 클래스는 GET 요청 시 모든 기사를 조회하고, POST 요청 시 새로운 기사를 생성하는 API 뷰를 제공합니다. `ArticleDetail` 클래스는 특정 기사를 조회(GET), 업데이트(PUT), 삭제(DELETE)하는 API 뷰입니다.

6. URL 라우팅 설정하기

이제 생성한 API 뷰를 사용할 수 있도록 URL을 설정해야 합니다. `myapp/urls.py` 파일을 생성하고 아래의 코드를 추가합니다.

from django.urls import path
from .views import ArticleListCreate, ArticleDetail

urlpatterns = [
    path('articles/', ArticleListCreate.as_view(), name='article-list-create'),
    path('articles//', ArticleDetail.as_view(), name='article-detail'),
]

프로젝트의 메인 URL 설정 파일인 `myproject/urls.py` 파일에 다음과 같이 `myapp`의 URL 모듈을 포함시킵니다.

from django.contrib import admin
from django.urls import path, include

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

7. API 테스트하기

이제 모든 설정이 완료되었습니다. Django 서버를 실행해 보겠습니다.

python manage.py runserver

서버가 실행되면, 브라우저나 Postman과 같은 API 클라이언트를 통해 아래의 URL로 요청을 보내 API를 테스트할 수 있습니다.

  • GET 요청: http://127.0.0.1:8000/api/articles/ (모든 기사 조회)
  • POST 요청: http://127.0.0.1:8000/api/articles/ (새로운 기사 생성)
  • GET 요청: http://127.0.0.1:8000/api/articles/1/ (ID가 1인 기사 조회)
  • PUT 요청: http://127.0.0.1:8000/api/articles/1/ (ID가 1인 기사 업데이트)
  • DELETE 요청: http://127.0.0.1:8000/api/articles/1/ (ID가 1인 기사 삭제)

8. 인증 및 권한 설정

Django REST Framework는 기본적으로 인증 및 권한 관리를 지원합니다. `settings.py` 파일에서 기본 인증 클래스를 설정할 수 있습니다.

# myproject/settings.py
REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework.authentication.BasicAuthentication',
    ],
    'DEFAULT_PERMISSION_CLASSES': [
        'rest_framework.permissions.AllowAny',
    ]
}

위의 설정은 기본 인증을 사용하고, 모든 사용자에게 API 접근을 허용합니다. 필요에 따라 더 세부적인 권한 설정을 할 수 있습니다.

9. 결론

이제 Django를 이용한 RESTful API 구축과 시리얼라이저 사용법에 대한 기본적인 이해를 돕기 위한 설명을 마치겠습니다. Django REST Framework는 RESTful API를 구축하는 데 매우 유용한 도구이며, 이를 통해 데이터 처리를 간편하게 할 수 있습니다. 이후에는 인증, 필터링, pagination 등의 기능을 추가하여 더욱 완성도 높은 API를 구축해 보시면 좋겠습니다.

이 글이 Django를 활용한 백엔드 개발에 도움이 되었기를 바라며, 더 궁금한 사항이 있다면 언제든지 질문해 주세요!

참고 자료

DJango 서버개발, Django ORM(Object-Relational Mapping) 소개

Django는 파이썬으로 작성된 고급 웹 프레임워크로, 빠른 개발과 깔끔하고 실용적인 디자인을 목표로 합니다. Django의 핵심적인 기능 중 하나는 ORM(Object-Relational Mapping)입니다. ORM은 객체 지향 프로그래밍 언어와 관계형 데이터베이스 간의 데이터를 전환하는 기법으로, 데이터베이스 작업을 훨씬 간편하고 효율적으로 만들어 줍니다. 이 글에서는 Django ORM의 기본 개념, 사용 방법, 그리고 다양한 예제 코드를 통해 Django ORM의 강력한 기능을 탐구하겠습니다.

1. ORM이란?

ORM(Object-Relational Mapping)은 객체와 데이터베이스 레코드 간의 관계를 매핑하는 방법입니다. 이는 데이터베이스의 테이블을 객체로 표현하고, SQL 쿼리를 작성하는 대신 프로그래밍 언어의 일반적인 객체 지향 방식으로 데이터베이스와 상호작용할 수 있도록 해줍니다. Django에서는 이 과정이 매우 간단해지며, 이는 개발자에게 다음과 같은 이점을 제공합니다:

  • SQL 쿼리를 작성할 필요가 없어져 코드가 더 간결해집니다.
  • 데이터베이스 독립성으로 인해 여러 종류의 데이터베이스를 쉽게 전환할 수 있습니다.
  • 코드의 가독성이 향상되고 유지 보수가 용이해집니다.

2. Django ORM 구성요소

Django ORM의 주요 구성 요소는 다음과 같습니다:

  • 모델(Model): 데이터베이스 테이블을 정의하는 클래스입니다. 각 모델은 데이터베이스 레코드 하나와 매핑됩니다.
  • 쿼리셋(QuerySet): 데이터베이스에서 데이터를 조회하기 위한 API입니다. 쿼리셋은 객체 리스트를 반환합니다.
  • 마이그레이션(Migration): 모델의 변경 사항을 데이터베이스에 적용하는 방법입니다. Django는 자동으로 마이그레이션 파일을 생성합니다.

3. Django 모델 만들기

먼저 Django 프로젝트를 생성하고 앱을 추가한 후, 모델을 정의하는 방법을 살펴보겠습니다.

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

이제 myapp/models.py 파일을 열어 기본 모델을 정의해봅시다.

python
from django.db import models

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

    def __str__(self):
        return self.name

class Book(models.Model):
    title = models.CharField(max_length=200)
    author = models.ForeignKey(Author, on_delete=models.CASCADE)
    published_date = models.DateField()

    def __str__(self):
        return self.title

위의 코드에서 AuthorBook 모델을 정의했습니다. 각 모델은 models.Model을 상속받아야 하며, 각 속성은 데이터베이스 필드를 나타냅니다. ForeignKey를 사용하여 두 모델 간의 관계를 정의했습니다.

4. 마이그레이션 적용하기

모델을 정의한 후, Django는 모델을 데이터베이스에 반영하는 마이그레이션 파일을 생성할 수 있습니다. 이를 위해 다음 명령어를 사용합니다:

python
python manage.py makemigrations
python manage.py migrate

이 명령어는 모델의 변경 사항을 감지하고 관련 마이그레이션 파일을 생성하여 데이터베이스에 적용합니다.

5. 데이터베이스와의 상호작용

Django ORM을 사용하여 데이터베이스와 상호작용하는 다양한 방법을 살펴보겠습니다. 일부 기본적인 CRUD(Create, Read, Update, Delete) 작업을 통해 이를 이해할 수 있습니다.

5.1. 데이터 생성(Create)

python
# 새로운 저자 데이터 추가
author = Author(name="J.K. Rowling", birth_date="1965-07-31")
author.save()

# 새로운 책 데이터 추가
book = Book(title="Harry Potter and the Philosopher's Stone", author=author, published_date="1997-06-26")
book.save()

5.2. 데이터 조회(Read)

데이터를 조회하려면 쿼리셋을 사용합니다. 다음은 데이터베이스에서 모든 저자와 책을 조회하는 방법입니다:

python
# 모든 저자 조회
authors = Author.objects.all()
for author in authors:
    print(author.name)

# 특정 저자의 책 조회
books_by_author = Book.objects.filter(author=author)
for book in books_by_author:
    print(book.title)

5.3. 데이터 업데이트(Update)

데이터를 업데이트하려면 먼저 원하는 객체를 가져온 후, 속성을 수정하고 저장하면 됩니다:

python
# 저자의 이름 변경
author = Author.objects.get(id=1)
author.name = "Joanne Rowling"
author.save()

5.4. 데이터 삭제(Delete)

데이터를 삭제하는 방법은 다음과 같습니다:

python
# 특정 책 삭제
book_to_delete = Book.objects.get(id=1)
book_to_delete.delete()

6. Django Admin에서 ORM 사용하기

Django는 기본적으로 강력한 관리자 인터페이스를 제공합니다. 이 인터페이스를 통해 데이터베이스 모델을 쉽게 관리할 수 있습니다. 이를 위해 myapp/admin.py 파일에 모델을 등록해야 합니다:

python
from django.contrib import admin
from .models import Author, Book

admin.site.register(Author)
admin.site.register(Book)

이제 Django 서버를 실행하고 http://127.0.0.1:8000/admin에 접속하면 관리 페이지에서 Authors와 Books를 쉽게 관리할 수 있습니다. 기본 사용자(admin)을 만들어야 하며, 다음 명령어를 사용하여 생성할 수 있습니다:

python
python manage.py createsuperuser

7. Django ORM의 고급 기능

Django ORM은 간단한 CRUD 작업 외에도 고급 쿼리 기능을 제공합니다. 예를 들어, annotate, aggregate, 및 select_related 메서드를 사용하여 데이터를 더 효과적으로 사용할 수 있습니다.

7.1. annotate와 aggregate

이 메서드들은 데이터를 집계하여 계산된 필드를 추가하는 데 사용됩니다.

python
from django.db.models import Count

# 저자별 책 수 조회
author_book_count = Author.objects.annotate(num_books=Count('book'))
for author in author_book_count:
    print(f'{author.name} has written {author.num_books} books.')

7.2. select_related

이 메서드는 ForeignKey 관계를 가진 개체를 효율적으로 미리 로드할 수 있게 해줍니다. 이를 사용하면 쿼리 수를 줄이고 성능을 높일 수 있습니다.

python
# 책과 저자를 함께 조회
books_with_authors = Book.objects.select_related('author').all()
for book in books_with_authors:
    print(f'{book.title} by {book.author.name}')

8. Django ORM과 데이터베이스

Django는 다양한 데이터베이스를 지원합니다. SQLite, PostgreSQL, MySQL, Oracle 및 NoSQL 데이터베이스와도 호환됩니다. 이는 Django의 장점 중 하나로, 프로젝트에 적합한 데이터베이스를 선택할 수 있습니다. 각 데이터베이스에 필요한 설정을 settings.py 파일에서 확인하고 수정할 수 있습니다.

python
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',  # PostgreSQL 사용 설정
        'NAME': 'mydatabase',
        'USER': 'mydatabaseuser',
        'PASSWORD': 'mypassword',
        'HOST': 'localhost',
        'PORT': '5432',
    }
}

9. 결론

Django ORM은 Django 프레임워크의 중요한 구성 요소로, 데이터베이스와 상호작용하는 것을 매우 효율적이고 간편하게 만들어줍니다. 우리는 ORM을 사용하여 모델을 정의하고, CRUD 작업을 수행하며, 복잡한 쿼리를 생성하는 방법을 배웠습니다. Django ORM은 뿐만 아니라 유지 보수를 용이하게 하고, 데이터베이스 독립성을 제공하여 다양한 데이터베이스와 쉽게 통합할 수 있게 해줍니다.

이 글을 통해 Django ORM의 기초를 배우고, 적절한 사용 예제를 통해 실습할 수 있기를 바랍니다. Django를 통한 웹 개발의 제약에서 벗어나 흥미로운 프로젝트를 개발해 보세요!

다음 글에서는 Django REST Framework를 사용하여 데이터베이스와의 상호작용을 API 형태로 제공하는 방법에 대해 알아볼 것입니다.

DJango 서버개발, API 인증 및 권한 관리 구현하기

Django는 파이썬으로 작성된 웹 프레임워크로, 빠르고 효율적으로 웹 애플리케이션을 개발할 수 있는 다양한 도구와 라이브러리를 제공합니다. 이 글에서는 Django를 이용하여 RESTful API 서버를 구축하고, API 인증 및 권한 관리를 구현하는 방법에 대해 자세히 설명하겠습니다.

1. Django 프로젝트 설정하기

먼저 Django 프로젝트를 설정해 보겠습니다. Django 프레임워크와 Django REST Framework(DRF)를 설치합니다.

pip install django djangorestframework

이제 새로운 Django 프로젝트를 생성합니다.

django-admin startproject myproject

이후 생성된 프로젝트 디렉토리로 이동합니다.

cd myproject

이제 Django 애플리케이션을 생성합니다.

python manage.py startapp myapp

프로젝트의 settings.py 파일에 myapprest_framework를 INSTALLED_APPS에 추가합니다.

INSTALLED_APPS = [
        ...
        'rest_framework',
        'myapp',
    ]

2. 모델 생성하기

이제 API에서 사용할 모델을 생성해봅시다. models.py 파일을 열어 다음과 같이 작성합니다.

from django.db import models

class User(models.Model):
    username = models.CharField(max_length=150, unique=True)
    password = models.CharField(max_length=128)
    email = models.EmailField(unique=True)

    def __str__(self):
        return self.username

모델을 만들었으면 이제 마이그레이션을 실행하여 데이터베이스에 반영합니다.

python manage.py makemigrations
python manage.py migrate

3. Serializer 생성하기

모델을 JSON 형식으로 변환하기 위해 serializer를 생성합니다. serializers.py 파일을 생성하고 다음과 같이 작성합니다.

from rest_framework import serializers
from .models import User

class UserSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ('id', 'username', 'email')

4. 뷰 생성하기

이제 API의 엔드포인트를 만들기 위해 뷰를 생성합니다. views.py 파일을 열고 다음과 같이 작성합니다.

from rest_framework import viewsets
from .models import User
from .serializers import UserSerializer

class UserViewSet(viewsets.ModelViewSet):
    queryset = User.objects.all()
    serializer_class = UserSerializer

5. URL 라우팅 설정하기

API의 URL을 설정하기 위해 urls.py 파일을 생성하고 다음과 같이 작성합니다.

from django.urls import path, include
from rest_framework.routers import DefaultRouter
from .views import UserViewSet

router = DefaultRouter()
router.register(r'users', UserViewSet)

urlpatterns = [
    path('', include(router.urls)),
]

6. 인증 및 권한 관리 구현하기

Django REST Framework에서는 다양한 인증 및 권한 관리 기능을 지원합니다. 여기에서는 기본 인증과 토큰 인증을 사용하여 API 인증을 구현합니다.

6.1. Django REST Framework의 토큰 인증 활성화

우선, settings.py 파일에서 OAuth2를 위한 앱을 설치하고 등록합니다.

INSTALLED_APPS = [
        ...
        'rest_framework.authtoken',
    ]

또한, DRF의 인증 클래스를 설정해줍니다.

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

6.2. 사용자에게 토큰 생성하기

사용자가 로그인 할 때마다 토큰을 생성하므로, 로그인 뷰를 추가합니다.

from django.contrib.auth import authenticate
from rest_framework.authtoken.models import Token
from rest_framework.response import Response
from rest_framework.views import APIView
from rest_framework import status

class LoginView(APIView):
    def post(self, request):
        username = request.data.get('username')
        password = request.data.get('password')
        user = authenticate(username=username, password=password)
        if user:
            token, created = Token.objects.get_or_create(user=user)
            return Response({'token': token.key}, status=status.HTTP_200_OK)
        return Response({'error': 'Invalid Credentials'}, status=status.HTTP_400_BAD_REQUEST)

로그인 뷰를 URL에 추가합니다.

urlpatterns = [
        ...
        path('login/', LoginView.as_view(), name='login'),
    ]

7. API 테스트하기

이제 모든 설정이 완료되었습니다. Django 서버를 실행하고 API를 테스트합니다.

python manage.py runserver

Postman 또는 Curl을 사용하여 API를 테스트할 수 있습니다. 사용자를 등록한 후에 로그인 엔드포인트에 POST 요청을 보내서 토큰을 받아옵니다.

7. 결론

Django와 Django REST Framework를 이용하면 빠르게 API 서버를 구축할 수 있고, 인증 및 권한 관리를 손쉽게 구현할 수 있습니다. 본 글에서 다룬 내용을 바탕으로 더 다양한 기능을 추가하여 API를 확장할 수 있습니다.

여기까지가 Django 서버 개발 및 API 인증과 권한 관리에 대한 강좌였습니다. 향후에는 OAuth2와 JWT(JSON Web Token) 인증 방식에 대해서도 살펴보는 글을 작성할 예정입니다.

8. 참고 자료

DJango 서버개발, 서드파티 패키지 활용 및 직접 패키지 개발하기

Django는 웹 개발을 위한 강력하고 유연한 프레임워크로, 웹 애플리케이션을 빠르고 쉽게 개발할 수 있도록 도와줍니다. 다양한 내장 기능을 제공하며, 서드파티 패키지를 활용하여 기능을 확장할 수 있습니다. 또한, 자신만의 패키지를 개발하여 프로젝트의 요구에 맞춘 솔루션을 제공하는 것도 가능합니다. 이번 글에서는 Django 서버 개발 과정, 서드파티 패키지 활용법, 그리고 직접 패키지를 개발하는 방법에 대해 상세히 설명하겠습니다.

Django 설치 및 기본 설정

Django를 사용하기 위해서는 먼저 Django를 설치해야 합니다. 파이썬의 패키지 관리 시스템인 pip를 이용해 설치할 수 있습니다. 커맨드라인에서 다음 명령어를 입력하세요.

pip install django

설치가 완료되면, 새로운 Django 프로젝트를 생성할 수 있습니다. 다음 명령어를 실행하여 ‘myproject’라는 이름의 새로운 프로젝트를 생성합니다.

django-admin startproject myproject

생성된 프로젝트 디렉토리로 이동한 후, 서버를 실행하여 정상적으로 설치되었는지 확인할 수 있습니다.

cd myproject
python manage.py runserver

브라우저에서 http://127.0.0.1:8000에 접속하면 Django 환영 페이지를 볼 수 있습니다.

Django 앱 생성

프로젝트 내에 Django 앱을 생성하여 개별 기능을 모듈화합니다. 다음 명령어로 ‘myapp’이라는 앱을 생성할 수 있습니다.

python manage.py startapp myapp

앱을 생성한 후, 프로젝트 설정 파일인 settings.py에 앱을 등록해야 합니다. INSTALLED_APPS 항목에 ‘myapp’을 추가합니다.

INSTALLED_APPS = [
        ...,
        'myapp',
    ]

서드파티 패키지 활용하기

Django는 다양한 서드파티 패키지를 통해 기능을 강화할 수 있습니다. 여기서는 가장 많이 사용되는 서드파티 패키지인 Django Rest Framework (DRF)와 Django Allauth를 예로 들어보겠습니다.

Django Rest Framework (DRF) 설치 및 설정

RESTful API를 쉽게 구축할 수 있게 도와주는 DRF를 설치해보겠습니다.

pip install djangorestframework

설치가 완료되면, settings.py 파일에 DRF를 추가합니다.

INSTALLED_APPS = [
        ...,
        'rest_framework',
    ]

간단한 API 엔드포인트를 만들어보겠습니다. myapp/views.py에 다음 코드를 추가합니다.

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status

class HelloWorld(APIView):
    def get(self, request):
        return Response({"message": "안녕하세요, Django!"}, status=status.HTTP_200_OK)

이제 라우팅 설정을 위해 myapp/urls.py 파일을 생성하고 다음 코드를 추가합니다.

from django.urls import path
from .views import HelloWorld

urlpatterns = [
    path('hello/', HelloWorld.as_view(), name='hello_world'),
]

그리고 프로젝트의 메인 urls.py에 이 앱의 URL을 포함시킵니다.

from django.urls import path, include

urlpatterns = [
    path('api/', include('myapp.urls')),
]

이제 http://127.0.0.1:8000/api/hello/에 접속하면 JSON 데이터가 반환되는 것을 확인할 수 있습니다.

Django Allauth 설치 및 설정

소셜 로그인과 사용자 인증을 쉽게 구현할 수 있게 도와주는 Django Allauth 패키지를 설치해보겠습니다.

pip install django-allauth

설치가 완료되면, settings.py에 관련 설정을 추가합니다.

INSTALLED_APPS = [
        ...,
        'django.contrib.sites',
        'allauth',
        'allauth.account',
        'allauth.socialaccount',
    ]

SITE_ID = 1

AUTHENTICATION_BACKENDS = (
    ...
    'allauth.account.auth_backends.AuthenticationBackend',
)

ACCOUNT_EMAIL_REQUIRED = True
ACCOUNT_EMAIL_VERIFICATION = 'mandatory'

이제 URL을 설정하겠습니다. urls.py 파일에 Django Allauth의 URL 패턴을 추가합니다.

urlpatterns = [
        ...,
        path('accounts/', include('allauth.urls')),
]

이제 사용자가 로그인하고 회원가입할 수 있는 기능이 활성화되었습니다. 기본적으로 제공되는 템플릿을 사용하여 로그인, 회원가입 등을 구현할 수 있습니다.

직접 패키지 개발하기

이제 Django의 강력한 기능 중 하나인 자기 자신만의 패키지를 개발해보겠습니다. Django 패키지를 만들기 위해서는 다음 단계를 따릅니다.

1. 패키지 디렉토리 구조 설정

패키지를 위한 새로운 디렉토리를 생성합니다. 예를 들어, ‘mypackage’라는 폴더를 생성하고 다음과 같은 구조를 가집니다.

mypackage/
    ├── mypackage/
    │   ├── __init__.py
    │   ├── models.py
    │   ├── views.py
    │   └── urls.py
    ├── setup.py
    └── README.md

2. 패키지 코드 작성

models.py에 간단한 모델 클래스를 추가합니다.

from django.db import models

class Product(models.Model):
    name = models.CharField(max_length=100)
    price = models.DecimalField(max_digits=10, decimal_places=2)

    def __str__(self):
        return self.name

views.py에 간단한 뷰도 추가해보겠습니다.

from django.shortcuts import render
from .models import Product

def product_list(request):
    products = Product.objects.all()
    return render(request, 'product_list.html', {'products': products})

3. URL 설정

urls.py를 다음과 같이 설정합니다.

from django.urls import path
from .views import product_list

urlpatterns = [
    path('products/', product_list, name='product_list'),
]

4. 패키지 배포를 위한 설정

setup.py 파일을 생성하여 패키지를 배포할 수 있습니다.

from setuptools import setup, find_packages

setup(
    name='mypackage',
    version='0.1',
    packages=find_packages(),
    install_requires=[
        'Django>=3.0',
    ],
    author='Your Name',
    author_email='your_email@example.com',
    description='A simple Django package example.',
 )

5. 패키지 배포

이제 패키지를 배포할 준비가 되었습니다. PyPI에 배포하기 위해서는 twine을 사용할 수 있습니다.

pip install twine

패키지를 빌드한 후 다음 명령어로 배포할 수 있습니다.

python setup.py sdist
twine upload dist/*

결론

Django는 웹 개발을 위한 강력한 도구이며, 서드파티 패키지와 맞춤형 패키지를 활용하여 프로젝트를 강화할 수 있습니다. Django Rest Framework를 통해 API 개발을 쉽게 할 수 있으며, Django Allauth를 사용하여 사용자 인증을 간편하게 구현할 수 있습니다. 또한, 자신만의 패키지를 개발함으로써 재사용 가능한 코드를 작성하고 배포할 수 있습니다.

이제 여러분도 Django의 다양한 기능을 활용하여 멋진 웹 애플리케이션을 개발할 수 있습니다. 실습을 통해 Django의 매력을 깊이 느껴보세요!