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 서버개발, 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의 매력을 깊이 느껴보세요!

DJango 서버개발, Postman을 사용한 API 테스트 및 문서화

저자: 당신의 이름

작성일: 2023년 10월

1. 서론

Django는 파이썬으로 작성된 고급 웹 프레임워크로, 웹 애플리케이션을 빠르게 개발할 수 있는 강력한 도구입니다. 본 강좌에서는 Django를 이용해 간단한 RESTful API를 만들고, Postman을 사용해 이 API를 테스트 및 문서화하는 방법을 다룹니다.

2. Django 환경 설정

시스템에 Django를 설치하려면 아래 명령어를 터미널에 입력하세요:

pip install django

새로운 Django 프로젝트를 생성하고 실행해 봅시다:

django-admin startproject myproject
cd myproject
python manage.py runserver

위 명령어를 통해 웹 서버가 실행됩니다. 기본적으로 http://127.0.0.1:8000에서 접근할 수 있습니다.

3. Django REST Framework 설치

RESTful API를 쉽게 구축하기 위해 Django REST Framework를 설치합니다:

pip install djangorestframework

설치 후, 프로젝트의 설정 파일인 settings.py에 Django REST Framework를 추가해야 합니다:

INSTALLED_APPS = [
    ...
    'rest_framework',
]

4. Django 모델 생성

이제 간단한 데이터를 저장할 모델을 생성해 보겠습니다. app이라는 새 Django 애플리케이션을 생성합니다:

python manage.py startapp app

그 후, models.py 파일에 내용을 추가하여 모델을 정의합니다:

from django.db import models

class Post(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

위 코드는 포스트(title, content, created_at 속성을 가지는)을 정의합니다.

5. 데이터베이스 설정 및 마이그레이션

이제 Django의 설정 파일에서 데이터베이스를 설정합니다. 기본적으로 Django는 SQLite를 사용합니다. 다음 명령어를 통해 마이그레이션을 실행하여 모델에 맞는 테이블을 생성합니다:

python manage.py makemigrations
python manage.py migrate

6. Django 뷰 및 직렬화기 설정

다음으로 API를 통해 데이터에 접근할 수 있도록 뷰와 직렬화기를 설정합니다. app/serializers.py 파일을 생성하고 아래와 같은 내용을 추가합니다:

from rest_framework import serializers
from .models import Post

class PostSerializer(serializers.ModelSerializer):
    class Meta:
        model = Post
        fields = '__all__'

그 후, views.py 파일을 수정하여 API 엔드포인트를 추가합니다:

from rest_framework import viewsets
from .models import Post
from .serializers import PostSerializer

class PostViewSet(viewsets.ModelViewSet):
    queryset = Post.objects.all()
    serializer_class = PostSerializer

7. URL 라우팅 설정

이제 API가 요청을 받을 수 있도록 URL을 설정해야 합니다. 프로젝트의 urls.py 파일을 수정하여 다음과 같이 내용을 추가합니다:

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

router = DefaultRouter()
router.register(r'posts', PostViewSet)

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

이제 GET, POST, PUT, DELETE 요청을 통해 포스트에 접근할 수 있습니다.

8. 서버 실행 및 API 접근

서버를 다시 실행합니다:

python manage.py runserver

이제 http://127.0.0.1:8000/posts/에 접속하여 API를 사용할 수 있습니다.

9. Postman을 이용한 API 테스트

Postman을 설치하고 실행한 후, 아래 단계를 통해 API를 테스트합니다:

  • GET 요청: 새로 생성한 API 엔드포인트인 /posts/로 GET 요청을 보내어 데이터 목록을 확인합니다.
  • POST 요청: 새 포스트를 생성하기 위해 /posts/로 POST 요청을 보내며, 요청 본문에 JSON 형식으로 데이터를 포함합니다.
  • {
        "title": "새 포스트",
        "content": "포스트 내용입니다."
    }
  • PUT 요청: 특정 포스트를 수정하려면 /posts/{id}/로 PUT 요청을 보내며, 수정할 데이터를 JSON 형식으로 포함합니다.
  • DELETE 요청: 특정 포스트를 삭제하려면 /posts/{id}/로 DELETE 요청을 보냅니다.

10. Postman을 사용한 문서화

Postman에서는 API를 문서화하는 기능을 제공합니다. 아래 단계에 따라 API 문서를 만들 수 있습니다:

  1. Postman에서 요청을 생성하고, 요청 이름 및 설명을 추가합니다.
  2. 테스트를 위해 제공한 요청 본문의 예시 및 응답 예시를 추가합니다.
  3. 모든 요청을 그룹화하고, 각 요청에 대한 설명을 추가하여 API를 명확하게 문서화합니다.
  4. 최종적으로 Postman Workspaces 기능을 이용해 팀원들과 공유 가능하며, 이를 통해 API를 일관되게 사용할 수 있도록 합니다.

11. 마무리

이번 강좌를 통해 Django를 사용하여 API를 구축하고, Postman을 통해 이 API를 테스트 및 문서화하는 방법을 학습했습니다. Django와 Postman의 결합은 웹 애플리케이션 개발 시 매우 유용하며, 효율적인 작업을 가능하게 합니다.

감사합니다. 추가적인 질문이 있으시면 댓글로 남겨주세요.

DJango 서버개발, 전자상거래 사이트 구축하기

1. 서론

Django는 파이썬으로 작성된 고급 웹 프레임워크로, 웹 애플리케이션을 신속하게 개발할 수 있도록 설계되었습니다. 본 강좌에서는 Django를 이용해 전자상거래 사이트를 구축하는 방법을 상세하게 설명하겠습니다. 기본적인 Django 설정부터 시작하여, 상품 관리, 장바구니, 결제 시스템까지 구현할 것입니다.

2. 개발 환경 설정

Django 개발을 위해 다음과 같은 도구가 필요합니다:

  • Python 3.x
  • Django 3.x 이상
  • 가상 환경 관리 도구 (venv, virtualenv)
  • SQLite 또는 PostgreSQL 데이터베이스

2.1. 가상 환경 설정하기

가상 환경을 설정해 프로젝트의 종속성을 관리합니다. 터미널에서 다음 명령어를 입력하세요:

python -m venv venv
source venv/bin/activate  # Mac/Linux
venv\Scripts\activate     # Windows

2.2. Django 설치하기

가상 환경이 활성화된 상태에서 Django를 설치합니다.

pip install django

3. Django 프로젝트 생성

Django 프로젝트를 생성하고, 전자상거래 사이트를 위한 앱을 만듭니다. 아래 명령어를 실행하세요:

django-admin startproject ecommerce_site
cd ecommerce_site
python manage.py startapp shop

3.1. settings.py 수정하기

‘shop’ 앱을 설치된 앱 목록에 추가하려면 Ecommerce/settings.py 파일을 열고, INSTALLED_APPS 리스트에 ‘shop’을 추가합니다.

INSTALLED_APPS = [
    ...
    'shop',
]

4. 데이터베이스 모델 정의하기

상품을 관리하기 위해 모델을 정의합니다. shop/models.py 파일에 아래와 같이 작성합니다:

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)
    stock = models.IntegerField()
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.name

4.1. 데이터베이스 마이그레이션

모델을 생성한 후, 데이터베이스에 반영하기 위해 마이그레이션을 실행합니다.

python manage.py makemigrations
python manage.py migrate

5. 관리자 패널 설정

Django의 내장 관리자 패널을 통해 상품을 쉽게 관리할 수 있습니다. shop/admin.py 파일을 수정하여 모델을 등록합니다.

from django.contrib import admin
from .models import Product

admin.site.register(Product)

5.1. 관리 사용자 생성하기

관리 패널에 접근하기 위해 슈퍼유저를 생성합니다.

python manage.py createsuperuser

6. 상품 목록 보기

상품 목록을 보여주는 뷰와 템플릿을 생성합니다. shop/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})

6.1. URL 설정하기

URLs를 설정하여 뷰에 접근할 수 있게 합니다. shop/urls.py를 생성하고 다음과 같이 작성합니다:

from django.urls import path
from .views import product_list

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

메인 URLconf에 shop.urls를 포함하여 라우팅 설정을 완료합니다. ecommerce_site/urls.py를 다음과 같이 수정합니다:

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

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

6.2. 템플릿 작성하기

상품 목록을 보여주는 템플릿 파일을 생성합니다. shop/templates/product_list.html 파일에 다음과 같이 작성합니다:

<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <title>상품 목록</title>
</head>
<body>
    <h1>상품 목록</h1>
    <ul>
    {% for product in products %}
        <li>{{ product.name }} - {{ product.price }}</li>
    {% endfor %}
    </ul>
</body>
</html>

7. 장바구니 기능 구현하기

장바구니 기능을 구현하기 위해 사용자가 선택한 상품을 저장하고 관리하는 방법을 설명하겠습니다.

7.1. 장바구니 모델 추가

shop/models.py에 장바구니 모델을 추가합니다:

class Cart(models.Model):
    products = models.ManyToManyField(Product)
    total_price = models.DecimalField(max_digits=10, decimal_places=2, default=0)

    def calculate_total(self):
        self.total_price = sum(product.price for product in self.products.all())
        self.save()

7.2. 장바구니를 위한 뷰와 URL 설정

장바구니에 상품을 추가하고 목록을 볼 수 있는 뷰를 생성합니다:

from django.shortcuts import redirect

def add_to_cart(request, product_id):
    product = Product.objects.get(id=product_id)
    cart, created = Cart.objects.get_or_create(id=1)  # 단일 카트를 사용한다고 가정
    cart.products.add(product)
    cart.calculate_total()
    return redirect('product_list')

URL 설정도 추가해야 합니다:

path('add_to_cart//', add_to_cart, name='add_to_cart'),

7.3. 장바구니 템플릿 작성

장바구니에 담긴 상품들을 보여주는 템플릿을 작성합니다:

<h2>장바구니</h2>
<ul>
{% for product in cart.products.all %}
    <li>{{ product.name }} - {{ product.price }}</li>
{% endfor %}
</ul>
총합: {{ cart.total_price }}

8. 결제 기능 구현하기

결제 기능을 구현하는 것은 전자상거래 사이트에서 가장 중요한 부분 중 하나입니다. 결제 시스템은 외부 결제 게이트웨이를 통해 통합할 수 있습니다. 여기서는 Stripe API를 예로 들어 설명하겠습니다.

8.1. Stripe 설정

Stripe 계정을 생성하고 API 키를 얻습니다. Django 프로젝트에 Stripe를 설치합니다:

pip install stripe

8.2. 결제 뷰 생성

결제를 처리할 뷰를 생성합니다:

import stripe

stripe.api_key = 'YOUR_SECRET_KEY'

def checkout(request):
    cart = Cart.objects.get(id=1)  # 단일 카트를 사용한다고 가정
    if request.method == 'POST':
        # Stripe 결제 처리
        token = request.POST.get('stripeToken')
        charge = stripe.Charge.create(
            amount=int(cart.total_price * 100),  # cents로 변환
            currency='usd',
            description='Cart purchase',
            source=token,
        )
        # 결제 후 장바구니 비우기 및 처리
        cart.products.clear()
        cart.total_price = 0
        cart.save()
        return redirect('confirmation')
    return render(request, 'checkout.html', {'cart': cart})

8.3. 결제 템플릿 작성하기

결제 폼을 보여주는 템플릿을 작성합니다:

<form action="" method="post">
    <script src="https://js.stripe.com/v3/"></script>
    <button type="submit">결제하기</button>
</form>

9. 결론

본 강좌에서는 Django 프레임워크를 사용하여 전자상거래 사이트를 구축하는 기본적인 방법을 설명했습니다. 기본적인 상품 관리부터 결제 시스템까지, Django를 활용한 전자상거래 사이트의 구조를 이해하는 데 도움이 되었기를 바랍니다. 앞으로 추가적인 기능, 사용자 인증, 다양한 결제 옵션 등을 도입하여 사이트를 더욱 발전시켜 나갈 수 있습니다.

10. 추가 자료

Django 공식 문서
Stripe 개발자 문서