DJango 서버개발, 간단한 블로그 애플리케이션 만들기

Django는 파이썬으로 작성된 고급 웹 프레임워크로, 신속한 웹 개발을 가능하게 해줍니다. 본 강좌에서는 Django를 사용하여 간단한 블로그 애플리케이션을 만드는 과정을 단계별로 설명하겠습니다. 웹 애플리케이션의 기초부터 시작하여, 데이터베이스 설정, 모델 설계, 뷰 및 템플릿 작성까지 이루어질 것입니다. 마지막으로, 간단한 게시물 추가 및 삭제 기능을 구현하여 완전한 블로그 애플리케이션을 완성하겠습니다.

1. Django 설치하기

우선 Django를 설치해야 합니다. Python이 설치되어 있어야 하며, Python 패키지 관리자(pip)를 사용해 Django를 설치할 수 있습니다.

pip install django

2. Django 프로젝트 생성

Django를 설치한 후, 새로운 프로젝트를 생성할 수 있습니다. 아래 명령어를 통해 ‘myblog’라는 이름의 프로젝트를 만들겠습니다.

django-admin startproject myblog

프로젝트 디렉토리로 이동합니다.

cd myblog

3. 앱 생성

Django에서는 한 프로젝트 내에 여러 개의 앱을 생성하여 각각의 기능을 담당하도록 합니다. 이번 강좌에서는 ‘blog’라는 이름의 앱을 생성할 것입니다.

python manage.py startapp blog

4. 모델 설계

다음으로는 블로그 게시물을 저장하기 위한 모델을 설계하겠습니다. ‘blog/models.py’ 파일을 열어 아래와 같이 작성합니다.

from django.db import models

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

    def __str__(self):
        return self.title

위의 코드는 제목(title), 내용(content), 생성일(created_at) 필드를 가진 ‘Post’ 모델을 정의합니다. ‘created_at’ 필드는 자동으로 현재 시간이 저장됩니다.

5. 모델을 데이터베이스에 반영

모델을 정의한 후에는 이를 데이터베이스에 생성해야 합니다. 아래 명령어를 사용하여 데이터베이스 마이그레이션을 수행합니다.

python manage.py makemigrations
python manage.py migrate

6. 관리자 페이지 설정

게시물을 관리할 수 있는 관리자 페이지를 설정합니다. ‘blog/admin.py’ 파일을 열어 다음과 같이 작성합니다.

from django.contrib import admin
from .models import Post

admin.site.register(Post)

이제 관리자 페이지에서 게시물을 추가하고 수정할 수 있습니다. 관리자 계정을 생성하려면 아래 명령어를 실행합니다.

python manage.py createsuperuser

계정을 생성한 후, 서버를 실행하여 관리자 페이지에 접근할 수 있습니다.

python manage.py runserver

7. 뷰 작성

이제 게시물 목록을 보여줄 뷰를 작성하겠습니다. ‘blog/views.py’ 파일에서 아래와 같이 작성합니다.

from django.shortcuts import render
from .models import Post

def post_list(request):
    posts = Post.objects.all()
    return render(request, 'blog/post_list.html', {'posts': posts})

위 코드는 모든 게시물을 가져와 ‘post_list.html’ 템플릿에 전달합니다. 이제 템플릿을 작성해야 합니다.

8. 템플릿 작성

‘blog’ 디렉토리 내에 ‘templates’ 폴더를 만들고 그 안에 ‘blog’라는 또 다른 폴더를 생성한 후, ‘post_list.html’ 파일을 생성합니다.

<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <title>블로그 게시물</title>
</head>
<body>
    <h1>블로그 게시물</h1>
    <ul>
    {% for post in posts %}
        <li>{{ post.title }} - {{ post.created_at }}</li>
    {% empty %}
        <li>게시물이 없습니다.</li>
    {% endfor %}
    </ul>
</body>
</html>

9. URL 설정

Django는 URL 패턴과 뷰를 연결하여 요청을 처리합니다. ‘blog/urls.py’ 파일을 생성하고 다음과 같이 작성합니다.

from django.urls import path
from .views import post_list

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

이제 프로젝트의 URL 설정 파일인 ‘myblog/urls.py’ 파일을 수정하여 블로그 앱의 URL을 포함시킵니다.

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

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

10. 실행 및 테스트

모든 설정이 완료되었습니다. 서버를 다시 실행하고 브라우저에서 http://127.0.0.1:8000/에 접속하여 게시물 목록을 확인하세요. 관리자 페이지에서는 http://127.0.0.1:8000/admin를 통해 게시물을 추가할 수 있습니다.

11. 게시물 생성 및 삭제 기능 추가

게시물을 생성하고 삭제하는 기능을 추가하겠습니다. ‘blog/views.py’에 아래의 뷰를 추가합니다.

from django.shortcuts import redirect, get_object_or_404
from django.http import HttpResponseRedirect
from django.urls import reverse

def post_create(request):
    if request.method == 'POST':
        title = request.POST['title']
        content = request.POST['content']
        post = Post(title=title, content=content)
        post.save()
        return redirect('post_list')
    return render(request, 'blog/post_create.html')

def post_delete(request, pk):
    post = get_object_or_404(Post, pk=pk)
    post.delete()
    return redirect('post_list')

위 코드에서 post_create 함수는 POST 요청을 통해 새로운 게시물을 생성합니다. post_delete 함수는 주어진 게시물의 기본키를 사용하여 해당 게시물을 삭제합니다.

12. URL 추가

새로운 뷰를 URL에 추가하려면 ‘blog/urls.py’를 수정합니다.

from django.urls import path
from .views import post_list, post_create, post_delete

urlpatterns = [
    path('', post_list, name='post_list'),
    path('create/', post_create, name='post_create'),
    path('delete//', post_delete, name='post_delete'),
]

13. 템플릿 추가

게시물을 생성하기 위한 템플릿도 추가해야 합니다. ‘blog/templates/blog/post_create.html’ 파일을 생성하고 아래와 같이 작성합니다.

<!DOCTYPE html>
<html lang="ko">
<head>
    <meta charset="UTF-8">
    <title>게시물 작성</title>
</head>
<body>
    <h1>게시물 작성</h1>
    <form method="POST">
        {% csrf_token %}
        <input type="text" name="title" placeholder="제목" required><br>
        <textarea name="content" placeholder="내용" required></textarea><br>
        <button type="submit">작성하기</button>
    </form>
    <a href="{% url 'post_list' %}">뒤로가기</a>
</body>
</html>

14. 결론

이로써 간단한 Django 블로그 애플리케이션을 완성했습니다. 이 강좌를 통해 Django의 기본적인 구조와 흐름을 이해할 수 있었기를 바랍니다. Django는 강력하고 확장성이 뛰어난 웹 프레임워크이므로, 더 많은 기능을 추가하며 심화 학습을 진행해보세요. 예를 들어, 댓글 기능, 카테고리별 게시물 필터링, 사용자 인증 및 권한 관리 등의 기능을 추가함으로써 더욱 강력한 블로그를 만들 수 있습니다.

15. 참고 자료

DJango 서버개발, 사용자 입력에 대한 유효성 검사 및 에러 메시지 표시하기

Django는 강력한 웹 프레임워크로, 사용자에게 제공되는 데이터를 효율적으로 처리하고 검증하는 다양한 방법을 제공합니다. 이 글에서는 Django에서 사용자 입력에 대한 유효성 검사를 구현하고, 에러 발생 시 오류 메시지를 표시하는 방법에 대해 자세히 알아보겠습니다.

1. 유효성 검사의 중요성

웹 애플리케이션에서 사용자 입력 데이터를 받는 것은 일반적입니다. 그러나 입력된 데이터가 유효하지 않을 경우 애플리케이션의 안전성이나 기능에 문제가 발생할 수 있습니다. 따라서 우리는 사용자에게 친절한 에러 메시지를 제공하고, 올바른 데이터를 입력하도록 유도해야 합니다.

2. Django Forms 모듈 소개

Django는 사용자 입력을 처리하기 위해 Forms 모듈을 제공합니다. 이 모듈은 데이터 검증, 유효성 검사 및 사용자 친화적인 오류 메시지 표시를 쉽게 할 수 있게 도와줍니다.

Forms 모듈은 두 가지 주요 클래스를 제공합니다:

  • Form: 일반적인 폼 데이터 처리
  • ModelForm: Django 모델과 관련된 폼 처리

3. 간단한 사용자 등록 폼 만들기

이번 예제에서는 사용자 등록을 위한 간단한 폼을 만들어보겠습니다. 사용자에게 이메일과 비밀번호를 입력받고, 유효성 검사 및 에러 메시지 표시 기능을 구현합니다.

3.1. Django 프로젝트 설정

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

3.2. 모델 정의

먼저 모델을 정의하여 사용자의 데이터를 저장할 수 있도록 합니다. accounts/models.py 파일에 다음과 같이 작성합니다:

from django.db import models

class User(models.Model):
    email = models.EmailField(unique=True)
    password = models.CharField(max_length=128)
    
    def __str__(self):
        return self.email

3.3. 폼 정의

이제 사용자 데이터를 검증할 폼을 생성합니다. accounts/forms.py 파일에 다음과 같이 작성합니다:

from django import forms
from .models import User

class UserRegistrationForm(forms.ModelForm):
    class Meta:
        model = User
        fields = ['email', 'password']
    
    def clean_password(self):
        password = self.cleaned_data.get('password')
        if len(password) < 8:
            raise forms.ValidationError('비밀번호는 최소 8자 이상이어야 합니다.')
        return password

3.4. 뷰 정의

사용자 입력을 처리할 뷰를 만듭니다. accounts/views.py 파일에서 다음과 같이 작성합니다:

from django.shortcuts import render, redirect
from .forms import UserRegistrationForm

def register(request):
    if request.method == 'POST':
        form = UserRegistrationForm(request.POST)
        if form.is_valid():
            form.save()
            return redirect('success')
    else:
        form = UserRegistrationForm()
    
    return render(request, 'accounts/register.html', {'form': form})

3.5. 템플릿 생성

사용자가 입력할 정보를 표시할 HTML 템플릿을 생성합니다. accounts/templates/accounts/register.html 파일에 다음과 같이 작성합니다:

<h1>회원 가입</h1>

<form method="post">
    {% csrf_token %}
    {{ form.as_p }}
    <button type="submit">가입하기</button>
</form>

{% if form.errors %}
    <ul>
        {% for field in form %}
            {% for error in field.errors %}
                <li>{{ error }}</li>
            {% endfor %}
        {% endfor %}
        {% for error in form.non_field_errors %}
            <li>{{ error }}</li>
        {% endfor %}
    </ul>
{% endif %}<p>이메일과 비밀번호는 필수 입력 항목입니다.</p>

3.6. URL 설정

URL을 연결하여 작성한 뷰를 사용할 수 있도록 설정합니다. accounts/urls.py 파일에 다음을 추가합니다:

from django.urls import path
from .views import register

urlpatterns = [
    path('register/', register, name='register'),
]

4. 서버 실행 및 테스트

위의 설정이 완료되면 Django 서버를 실행하여 폼의 동작을 확인합니다.

python manage.py runserver

웹 브라우저에서 http://127.0.0.1:8000/register/로 이동하여 사용자 입력을 테스트합니다. 유효하지 않은 입력을 할 경우 에러 메시지가 표시되는 것을 확인할 수 있습니다.

5. 추가적인 유효성 검사

위의 예제는 기본적인 이메일과 비밀번호의 유효성 검사만 수행하고 있습니다. 더 복잡한 검사를 추가하여 사용자 경험을 향상시킬 수 있습니다. 예를 들어, 비밀번호의 복잡성을 검사하거나, 이메일의 형식을 더 엄격하게 검사할 수 있습니다.

def clean_email(self):
    email = self.cleaned_data.get('email')
    if not email.endswith('@example.com'):
        raise forms.ValidationError('이메일은 example.com 도메인을 사용해야 합니다.')
    return email

이 검사를 통해 비밀번호 및 이메일에 대한 보다 정밀한 유효성 검사를 추가할 수 있습니다.

6. 결론

Django의 Forms 모듈을 사용하여 사용자 입력에 대한 유효성 검사를 쉽게 구현할 수 있습니다. 에러 메시지를 친절하게 표시함으로써 사용자가 입력을 올바르게 입력하도록 안내할 수 있습니다. 본 글에서는 간단한 사용자 등록 폼을 예로 들어 유효성 검사 및 에러 메시지 표시 기능을 구현하는 방법을 살펴보았습니다.

이 외에도 Django의 다양한 기능을 활용하여 더 나은 사용자 경험을 제공할 수 있으니, 직접 테스트해보며 익숙해지는 것이 좋습니다.

DJango 서버개발, 커스텀 유효성 검사기 작성하기

Django는 파이썬으로 만들어진 강력한 웹 프레임워크로, 웹 애플리케이션을 빠르고 쉽게 개발할 수 있는 다양한 기능을 제공합니다. 그중 하나가 데이터 유효성 검사기입니다. Django는 기본 제공 유효성 검사기를 통해 다양한 데이터 형식과 요구 사항을 처리할 수 있지만, 때로는 특정 비즈니스 로직이나 데이터 요구 사항에 맞게 커스텀 유효성 검사기를 작성해야 할 필요가 있습니다. 이 글에서는 Django에서 커스텀 유효성 검사기를 작성하는 방법을 상세히 알아보겠습니다.

1. 커스텀 유효성 검사기의 필요성

웹 애플리케이션에서는 입력 데이터가 유효한지 확인하는 것이 매우 중요합니다. 기본 제공되는 유효성 검사기들은 일반적인 경우에 잘 작동하지만, 특정 비즈니스 요구사항이나 데이터 구조에 따라서는 커스텀 유효성 검사기가 필요할 수 있습니다. 예를 들어, 다음과 같은 경우를 생각해 볼 수 있습니다.

  • 특정 형식의 문자열 검사
  • 이메일 주소의 도메인 확인
  • 비밀번호 강도 체크
  • 사용자의 고유한 필드 검사 (예: 사용자 이름의 유일성)

2. Django에 커스텀 유효성 검사기 작성하기

이제 Django에서 커스텀 유효성 검사기를 작성하는 방법을 살펴보겠습니다. 기본 구조는 아주 간단하며, 주로 validators.py 파일에 커스텀 유효성 검사기를 정의합니다.

2.1. 프로젝트 및 앱 설정하기

우선 Django 프로젝트와 앱을 설정해야 합니다. 다음과 같은 명령어로 새로운 프로젝트와 앱을 생성할 수 있습니다.

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

그리고 settings.py 파일에 새로 만든 앱을 추가합니다:

INSTALLED_APPS = [
    ...
    'myapp',
]

2.2. 기본 유효성 검사기 작성하기

이제 myapp 디렉토리 내에 validators.py 파일을 생성하고 커스텀 유효성 검사기를 작성합니다. 예를 들어, 비밀번호 강도를 검사하는 유효성 검사기를 작성해보겠습니다.

from django.core.exceptions import ValidationError
import re

def validate_strong_password(value):
    if len(value) < 8:
        raise ValidationError(
            '비밀번호는 8자 이상이어야 합니다.'
        )
    if not re.search(r'\d', value):
        raise ValidationError(
            '비밀번호에는 숫자가 포함되어야 합니다.'
        )
    if not re.search(r'[A-Z]', value):
        raise ValidationError(
            '비밀번호에는 대문자가 포함되어야 합니다.'
        )
    if not re.search(r'[a-z]', value):
        raise ValidationError(
            '비밀번호에는 소문자가 포함되어야 합니다.'
        )
    if not re.search(r'[!@#$%^&*(),.?":{}|<>]', value):
        raise ValidationError(
            '비밀번호에는 특수문자가 포함되어야 합니다.'
        )

위의 코드에서 validate_strong_password 함수는 입력된 비밀번호가 특정 조건을 만족하는지 확인하고, 만족하지 않을 경우 ValidationError를 발생시킵니다.

2.3. 유효성 검사기 사용하기

커스텀 유효성 검사기를 정의한 후에는 모델의 필드에 적용할 수 있습니다. 예를 들어, 사용자가 등록할 때 비밀번호를 입력하는 필드에 해당 유효성 검사기를 적용해보겠습니다.

from django.db import models
from .validators import validate_strong_password

class User(models.Model):
    username = models.CharField(max_length=150, unique=True)
    password = models.CharField(max_length=128, validators=[validate_strong_password])

위의 코드에서 password 필드는 커스텀 유효성 검사기인 validate_strong_password를 사용하여 비밀번호의 유효성을 검사합니다.

3. 유효성 검사기 테스트하기

모델과 유효성 검사기를 작성한 후에는 이를 테스트하여 올바르게 작동하는지 확인해야 합니다. Django의 테스트 프레임워크를 사용하여 간단한 테스트 케이스를 작성해 보겠습니다.

from django.test import TestCase
from .models import User
from django.core.exceptions import ValidationError

class UserModelTest(TestCase):
    def test_strong_password(self):
        user = User(username='testuser')
        user.password = 'weak'
        with self.assertRaises(ValidationError):
            user.full_clean()

        user.password = 'StrongPass1!'
        try:
            user.full_clean()  # should not raise
        except ValidationError:
            self.fail('ValidationError raised unexpectedly!') 

위의 코드는 비밀번호가 유효하지 않을 경우 ValidationError가 발생하는지를 검증하는 테스트 케이스입니다. 약한 비밀번호를 입력하면 `full_clean()` 메서드는 예외를 발생시키고, 강력한 비밀번호를 입력하면 예외가 발생하지 않아야 합니다.

4. 여러 유효성 검사기 사용하기

하나의 필드에서 여러 개의 유효성 검사기를 사용할 수도 있습니다. 이 경우, validators 목록에 여러 유효성 검사기를 추가하면 됩니다.

from django.core.validators import RegexValidator

class User(models.Model):
    username = models.CharField(max_length=150, unique=True)
    password = models.CharField(
        max_length=128,
        validators=[
            validate_strong_password,
            RegexValidator(
                regex=r'^[a-zA-Z0-9!@#$%^&*()]+$',
                message='비밀번호에는 알파벳, 숫자 또는 특수문자만 포함되어야 합니다.',
            ),
        ]
    )

위의 코드는 비밀번호가 강력하면서도 특정 정규 표현식에 맞도록 요구하는 경우를 보여줍니다. 여러 유효성 검사기를 조합하여 더 정교한 검증 로직을 수행할 수 있습니다.

5. 관리자 페이지에서 유효성 검사기 사용하기

Django의 관리자 페이지에서도 커스텀 유효성 검사기를 적용할 수 있습니다. 관리자 페이지에서 사용자의 비밀번호를 입력할 때도 동일한 유효성 검사가 적용됩니다. 관리자 페이지의 모델 클래스를 등록하기 위해 admin.py 파일을 수정합니다.

from django.contrib import admin
from .models import User

@admin.register(User)
class UserAdmin(admin.ModelAdmin):
    list_display = ('username',)
    search_fields = ('username',)

이제 Django의 관리자 페이지에서 사용자 등록 시 비밀번호 유효성 검사가 적용됩니다.

6. 결론

이번 글에서는 Django에서 커스텀 유효성 검사기를 작성하는 방법에 대해 알아보았습니다. 기본 제공 유효성 검사기로는 부족한 경우, 상황에 맞게 커스텀 유효성 검사기를 작성하여 데이터 유효성을 보장하고 사용자 경험을 향상시킬 수 있습니다. 이를 통해 더 안전하고 신뢰할 수 있는 웹 애플리케이션을 구축할 수 있습니다. Django의 강력한 기능을 활용하여 다양한 비즈니스 요구사항을 충족하는 유효성 검사기를 작성해보시기 바랍니다.

앞으로도 Django의 다양한 기능 소개와 실습을 통해 개발자로서의 역량을 키우실 수 있도록 다양한 주제를 다룰 예정입니다. 다음 강좌에서는 Django에서의 API 개발에 대해 깊이 있게 다룰 예정이니 많은 관심 부탁드립니다.

DJango 서버개발, AWS S3와 같은 클라우드 스토리지 연동하기

웹 애플리케이션 개발에서 파일 저장은 중요한 요소입니다. 로컬 서버에 파일을 저장하는 전통적인 방법은 한계가 있을 수 있으며, AWS S3와 같은 클라우드 스토리지를 사용하면 이러한 문제를 해결할 수 있습니다. 본 문서에서는 Django를 사용하여 AWS S3와 연동하는 방법을 단계별로 안내합니다.

1. AWS S3 개요

AWS S3(Amazon Simple Storage Service)는 안전하고 확장 가능한 객체 스토리지 서비스입니다. S3는 데이터를 저장하고 검색하는 데 최적화된 서비스로, 웹사이트 호스팅, 백업, 대용량 데이터 저장 및 복원 등 다양한 용도로 사용됩니다. AWS S3를 사용함으로써 사용자는 데이터의 내구성과 가용성을 높일 수 있습니다.

1.1 AWS S3의 주요 특징

  • 내구성: AWS S3는 99.999999999%의 내구성을 제공하여, 데이터 손실 염려가 적습니다.
  • 가용성: S3는 높은 가용성을 제공하여 언제 어디서든 데이터를 접근할 수 있습니다.
  • 보안: IAM을 통해 역할 기반 접근 제어를 구현할 수 있습니다.
  • 비용 효율성: 사용한 만큼만 비용을 지불하며, 데이터 저장 및 전송 비용이 유연하게 관리됩니다.

2. Django 프로젝트 설정

이제 Django 프로젝트를 설정하고, AWS S3와 연동할 준비를 하겠습니다.

2.1 Django 프로젝트 생성

django-admin startproject myproject

2.2 의존성 설치

AWS SDK와 Django의 S3 연동을 위해 다음 패키지를 설치해야 합니다.

pip install boto3 django-storages

2.3 Django 설정 수정

settings.py 파일에 AWS S3 설정을 추가합니다.


import os

# AWS S3 설정
AWS_ACCESS_KEY_ID = os.getenv('AWS_ACCESS_KEY_ID')
AWS_SECRET_ACCESS_KEY = os.getenv('AWS_SECRET_ACCESS_KEY')
AWS_STORAGE_BUCKET_NAME = 'your-bucket-name'
AWS_S3_REGION_NAME = 'your-region'  # 예: 'us-east-1'

# 정적 파일 및 미디어 파일 설정
AWS_S3_CUSTOM_DOMAIN = f'{AWS_STORAGE_BUCKET_NAME}.s3.amazonaws.com'
STATIC_URL = f'https://{AWS_S3_CUSTOM_DOMAIN}/static/'
MEDIA_URL = f'https://{AWS_S3_CUSTOM_DOMAIN}/media/'

DEFAULT_FILE_STORAGE = 'storages.backends.s3.S3Boto3Storage'
STATICFILES_STORAGE = 'storages.backends.s3.S3StaticStorage'
    

3. AWS IAM 역할 설정

AWS S3에 접근하기 위해서는 IAM을 통해 적절한 권한을 가진 사용자 또는 역할을 설정해야 합니다.

3.1 IAM 사용자 생성

  1. AWS 관리 콘솔에 로그인합니다.
  2. IAM 대시보드로 이동 후 ‘사용자’를 선택하고 ‘사용자 추가’ 버튼을 클릭합니다.
  3. 사용자 이름을 입력하고, AWS Management Console을 선택합니다.

3.2 권한 부여

  1. ‘권한 단계’에서 ‘정책 직접 연결’을 선택합니다.
  2. ‘AmazonS3FullAccess’ 정책을 선택하여 모든 S3 리소스에 대한 접근 권한을 부여합니다.
  3. 마지막으로 ‘사용자 만들기’를 클릭하여 사용자를 생성합니다.

3.3 AWS Access Key 확보

생성된 사용자의 Access Key ID와 Secret Access Key를 복사하여 .env 파일이나 환경 변수에 저장합니다.

4. 파일 업로드 기능 구현

Django에서 파일 업로드 기능을 구현합니다. 사용자가 파일을 업로드하면 S3에 저장되도록 합니다.

4.1 모델 생성


from django.db import models

class Document(models.Model):
    title = models.CharField(max_length=100)
    file = models.FileField(upload_to='documents/')

    def __str__(self):
        return self.title
    

4.2 관리 폼 생성


from django import forms
from .models import Document

class DocumentForm(forms.ModelForm):
    class Meta:
        model = Document
        fields = ('title', 'file')
    

4.3 뷰 생성


from django.shortcuts import render, redirect
from .forms import DocumentForm

def upload_file(request):
    if request.method == 'POST':
        form = DocumentForm(request.POST, request.FILES)
        if form.is_valid():
            form.save()
            return redirect('upload_success')
    else:
        form = DocumentForm()
    return render(request, 'upload.html', {'form': form})
    

4.4 URL 설정


from django.urls import path
from . import views

urlpatterns = [
    path('upload/', views.upload_file, name='upload_file'),
    path('upload_success/', TemplateView.as_view(template_name='upload_success.html'), name='upload_success'),
]
    

4.5 업로드 템플릿 생성






    
    파일 업로드


    

파일 업로드

{% csrf_token %} {{ form.as_p }}

5. 파일 보기 및 삭제 기능

업로드된 파일을 보여주고 삭제할 수 있는 기능을 구현합니다.

5.1 파일 리스트 뷰


def file_list(request):
    documents = Document.objects.all()
    return render(request, 'file_list.html', {'documents': documents})
    

5.2 삭제 기능 구현


def delete_file(request, pk):
    document = Document.objects.get(pk=pk)
    document.delete()
    return redirect('file_list')
    

5.3 URL 등록


urlpatterns += [
    path('files/', views.file_list, name='file_list'),
    path('files/delete//', views.delete_file, name='delete_file'),
]
    

5.4 파일 리스트 템플릿






    
    파일 리스트


    

업로드된 파일 목록

6. 마무리 및 추가 고려 사항

이제 Django 애플리케이션에서 AWS S3에 파일을 업로드하고 관리하는 방법을 구현했습니다. 다음은 고려해야 할 몇 가지 추가 사항입니다.

6.1 보안 고려사항

공개적으로 데이터를 저장하는 경우, S3 버킷의 퍼미션을 철저히 관리해야 합니다. 파일에 대한 액세스 권한을 설정하고, 불필요한 권한을 부여하지 않도록 주의해야 합니다.

6.2 비용 관리

AWS S3는 사용량에 따라 요금이 청구되므로, 비용을 관리하기 위해 데이터 사용량을 주기적으로 모니터링해야 합니다.

6.3 파일 형식 제한

특정 파일 형식만 업로드할 수 있도록 제한하려면 Django 폼에서 검증 로직을 추가하는 것이 좋습니다.

결론

Django를 AWS S3와 연동함으로써 파일 저장 및 관리를 보다 효율적으로 수행할 수 있습니다. 이 강좌를 통해 클라우드 스토리지의 장점을 이해하고, 실무에 적용할 수 있는 기반 지식을 쌓으셨기를 바랍니다.

DJango 서버개발, Django의 기본 인증 시스템 이해하기

Django는 강력하고 편리한 웹 프레임워크로, 복잡한 웹 애플리케이션을 신속하게 개발할 수 있도록 돕습니다. 그중에서도 Django의 기본 인증 시스템은 사용자 인증과 권한 관리를 쉽게 처리할 수 있는 기능을 제공합니다. 이번 글에서는 Django의 기본 인증 시스템을 자세히 이해하고, 이를 활용하여 간단한 웹 애플리케이션을 개발하는 방법을 설명하겠습니다.

1. Django의 기본 인증 시스템 소개

Django의 기본 인증 시스템은 사용자 계정 생성, 로그인, 로그아웃 및 비밀번호 변경과 같은 기능을 제공합니다. 이 시스템은 django.contrib.auth 패키지를 기반으로 하며, Django 프로젝트에서 쉽게 활용할 수 있습니다. 기본적으로 다음과 같은 기능을 포함하고 있습니다.

  • 사용자 등록
  • 로그인 및 로그아웃
  • 비밀번호 변경 및 초기화
  • 권한 관리자

2. Django 프로젝트 설정

시작하기에 앞서 Django 프로젝트를 설정해야 합니다. 아래의 명령어를 통해 새로운 Django 프로젝트를 생성해 보겠습니다.

        django-admin startproject myproject
        

프로젝트 디렉토리로 이동한 후, 다음 명령어를 실행하여 Django의 기본 인증 시스템을 포함하는 앱을 생성합니다.

        python manage.py startapp accounts
        

3. settings.py 파일 수정하기

생성한 accounts 앱을 프로젝트 설정에 추가합니다. myproject/settings.py 파일을 열고, INSTALLED_APPS 리스트에 accounts를 추가합니다.

        
        INSTALLED_APPS = [
            ...
            'django.contrib.auth',
            'django.contrib.contenttypes',
            'accounts',
            ...
        ]
        
        

4. 사용자 모델 정의

Django의 기본 사용자 모델을 사용할 수도 있지만, 필요에 따라 사용자 모델을 확장할 수도 있습니다. 아래와 같이 사용자 모델을 정의하겠습니다.

        from django.contrib.auth.models import AbstractUser
from django.db import models


class CustomUser(AbstractUser):
    bio = models.TextField(blank=True, null=True)  # 사용자 설명 추가
        
        

5. 사용자 등록 양식 만들기

이제 사용자가 회원가입할 수 있도록 사용자 등록 양식을 만들어 보겠습니다. 이를 위해 Django의 forms 모듈을 사용할 것입니다.

        from django import forms
from django.contrib.auth.forms import UserCreationForm
from .models import CustomUser


class CustomUserCreationForm(UserCreationForm):
    class Meta:
        model = CustomUser
        fields = ('username', 'email', 'password1', 'password2', 'bio')
        
        

6. 사용자 등록 뷰 만들기

사용자 등록 양식을 처리할 뷰를 만들겠습니다. 아래의 코드를 accounts/views.py에 추가합니다.

        from django.shortcuts import render, redirect
from .forms import CustomUserCreationForm


def register(request):
    if request.method == 'POST':
        form = CustomUserCreationForm(request.POST)
        if form.is_valid():
            form.save()
            return redirect('login')
    else:
        form = CustomUserCreationForm()
    return render(request, 'accounts/register.html', {'form': form})
        
        

7. 사용자 로그인 및 로그아웃 기능 구현하기

다음으로, 사용자 로그인 및 로그아웃 기능을 구현하겠습니다. Django는 기본적으로 로그인과 로그아웃을 처리하는 뷰를 제공합니다.

로그인 뷰를 다음과 같이 설정합니다.

        from django.contrib.auth import login
from django.contrib.auth.forms import AuthenticationForm


def user_login(request):
    if request.method == 'POST':
        form = AuthenticationForm(data=request.POST)
        if form.is_valid():
            user = form.get_user()
            login(request, user)
            return redirect('home')
    else:
        form = AuthenticationForm()
    return render(request, 'accounts/login.html', {'form': form})
        
        

8. 템플릿 만들기

이제 사용자 등록과 로그인 소스를 위한 템플릿을 만들어야 합니다. accounts/templates/accounts/register.html 파일을 아래와 같이 작성합니다.

        <h1>회원가입</h1>
<form method="post">
    {% csrf_token %}
    {{ form.as_p }}
    <button type="submit">가입하기</button>
</form>
        
        

9. URL 설정하기

이제 만들어둔 뷰와 템플릿을 연결하기 위해 URL 패턴을 설정합니다. accounts/urls.py 파일을 생성하고 다음과 같은 내용을 추가합니다.

        from django.urls import path
from .views import register, user_login

urlpatterns = [
    path('register/', register, name='register'),
    path('login/', user_login, name='login'),
]
        
        

그리고 myproject/urls.py 파일에 accounts.urls를 포함시킵니다.

        from django.urls import include, path

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

10. 애플리케이션 실행하기

모든 설정이 완료되었습니다. 이제 애플리케이션을 실행해 보겠습니다. 아래의 명령어를 실행하여 서버를 시작합니다.

        python manage.py runserver
        

11. 결과 확인

웹 브라우저를 열고 http://127.0.0.1:8000/accounts/register/로 이동하여 회원가입을 시도해 보세요. 회원가입 후에 로그인 화면으로 이동할 수 있어야 합니다. 이처럼 Django의 기본 인증 시스템을 통해 사용자 인증 기능을 간편하게 구현할 수 있습니다.

12. 결론

Django의 기본 인증 시스템은 사용자 인증 기능을 쉽게 구현할 수 있는 강력한 도구입니다. 이제 기본적인 사용자 등록과 로그인 기능을 구현하는 방법을 배웠습니다. 이 기능들을 바탕으로 실제 애플리케이션에 맞는 다양한 인증 및 권한 관리 로직을 추가할 수 있습니다.

보다 복잡한 인증 시스템이 필요한 경우, Django의 django-allauth와 같은 외부 패키지를 도입하여 소셜 로그인과 같은 기능을 추가할 수 있습니다. Django의 강력한 생태계를 활용하여 여러분의 웹 애플리케이션을 더욱 발전시켜 보세요.