DJango 서버개발, 사용자 로그인, 회원가입, 비밀번호 재설정 기능 구현하기

Django는 강력하고 유연한 웹 프레임워크로, Python으로 작성된 웹 애플리케이션을 신속하게 개발할 수 있게 도와줍니다. 본 글에서는 Django를 사용하여 사용자 인증 시스템을 구축하는 방법, 즉 회원가입, 로그인, 비밀번호 재설정 기능을 구현하는 방법을 자세히 설명합니다.

1. Django 프로젝트 설정

먼저 Django 프로젝트를 생성하고 기본적인 설정을 진행해야 합니다.

1.1. Django 설치

시스템에 Django를 설치하려면 다음 명령어를 사용합니다:

pip install django

1.2. 프로젝트 생성

Django 프로젝트를 생성하는 방법은 다음과 같습니다. 명령어를 실행하여 새로운 프로젝트를 생성합니다:

django-admin startproject myproject

그리고 생성된 프로젝트 디렉터리로 이동합니다:

cd myproject

2. 사용자 인증 기능 구현

Django는 기본적으로 사용자 인증을 위한 다양한 기능을 제공합니다. 이러한 기능을 사용하여 회원가입, 로그인, 비밀번호 재설정을 구현할 수 있습니다.

2.1. 앱 생성

우선 사용자 인증을 처리할 앱을 생성해 보겠습니다. 다음 명령어를 통해 “accounts”라는 이름의 앱을 생성합니다:

python manage.py startapp accounts

생성한 앱을 settings.py 파일의 INSTALLED_APPS 리스트에 추가합니다:

INSTALLED_APPS = [
        ...
        'accounts',
    ]

2.2. 모델 정의

우리는 기본 Django 사용자 모델을 사용할 것입니다. 하지만 필요에 따라 추가 필드를 추가할 수 있습니다. 아래 코드를 accounts/models.py에 추가합니다:

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

class CustomUser(AbstractUser):
    # 필요한 경우 추가 필드 정의
    pass

2.3. 사용자 관리 폼 만들기

회원가입 및 로그인 기능을 위한 양식을 정의합니다. forms.py 파일을 생성하고 다음과 같이 작성합니다:

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')

2.4. 회원가입 뷰 작성

회원가입 폼을 처리할 뷰를 작성합니다. 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})

2.5. URL 매핑

urls.py 파일을 생성하고 다음과 같이 작성하여 회원가입 URL을 매핑합니다:

from django.urls import path
from .views import register

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

3. 로그인 기능 구현

이제 로그인 기능을 추가하겠습니다. Django는 기본적으로 로그인 뷰를 제공합니다.

3.1. URL 매핑

다음과 같이 기존의 urls.py에 로그인 URL을 추가합니다:

from django.contrib.auth import views as auth_views

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

3.2. 로그인 템플릿 작성

로그인을 위한 템플릿을 작성합니다. accounts/templates/accounts/login.html를 생성하고 다음과 같이 작성합니다:

<h2>로그인</h2>
<form method="post">
    {% csrf_token %}
    {{ form.as_p }}
    <button type="submit">로그인</button>
</form>

4. 비밀번호 재설정 기능 구현

마지막으로 비밀번호 재설정 기능을 추가하겠습니다. Django는 이를 위한 다양한 내장 뷰를 제공합니다.

4.1. URL 매핑

다음과 같이 비밀번호 재설정 URL을 추가합니다:

urlpatterns = [
        ...
        path('password_reset/', auth_views.PasswordResetView.as_view(), name='password_reset'),
        path('password_reset/done/', auth_views.PasswordResetDoneView.as_view(), name='password_reset_done'),
        path('reset///', auth_views.PasswordResetConfirmView.as_view(), name='password_reset_confirm'),
        path('reset/done/', auth_views.PasswordResetCompleteView.as_view(), name='password_reset_complete'),
    ]

4.2. 비밀번호 재설정 템플릿

비밀번호 재설정을 위한 템플릿을 작성합니다:

<h2>비밀번호 재설정</h2>
<form method="post">
    {% csrf_token %}
    <label for="email">이메일 주소</label>
    <input type="email" name="email" required>
    <button type="submit">재설정 이메일 발송</button>
</form>

5. 전체 코드 구조

마지막으로, 지금까지 작성한 전체 코드 구조를 정리합니다.

5.1. 디렉토리 구조

myproject/
    ├── accounts/
    │   ├── migrations/
    │   ├── templates/
    │   │   └── accounts/
    │   │       ├── login.html
    │   │       └── register.html
    │   ├── \_\_init\_\_.py
    │   ├── admin.py
    │   ├── apps.py
    │   ├── forms.py
    │   ├── models.py
    │   ├── tests.py
    │   └── views.py
    ├── myproject/
    │   ├── \_\_init\_\_.py
    │   ├── settings.py
    │   ├── urls.py
    │   └── wsgi.py
    └── manage.py

결론

Django를 사용하여 간단한 사용자 인증 시스템을 구축하는 방법을 살펴보았습니다. 본 강좌에서는 사용자 회원가입, 로그인 및 비밀번호 재설정 기능을 구현했습니다. 이 기본적인 구조를 바탕으로 더 복잡한 기능을 확장해 나갈 수 있습니다.

이 글이 Django 서버 개발을 배우는 데 도움이 되길 바랍니다. 감사합니다!

DJango 서버개발, 커스텀 관리 명령어 만들기

Django는 강력한 웹 프레임워크로, 많은 기능을 제공하여 우리가 필요한 웹 애플리케이션을 쉽게 만들 수 있도록 도와줍니다. 그중에서도 관리 명령어(custom management commands)는 특정 작업을 자동화하거나 반복적으로 수행할 필요가 있을 때 유용하게 사용될 수 있습니다. 이 글에서는 Django에서 커스텀 관리 명령어를 만드는 방법에 대해 자세히 알아보겠습니다.

1. Django 관리 명령어란?

Django의 관리 명령어는 manage.py 파일을 통해 실행할 수 있는 Python 스크립트입니다. 일반적으로 데이터베이스 마이그레이션, 서버 실행, 테스트 실행 등의 작업을 수행할 수 있도록 해줍니다. 그러나 때때로 우리는 특정한 작업을 자동화하기 위해 자신만의 명령어를 만들어야 할 경우가 있습니다. 이러한 커스텀 관리 명령어를 통해 우리의 요구에 맞는 작업을 손쉽게 수행할 수 있습니다.

2. 커스텀 관리 명령어 만들기

커스텀 관리 명령어를 만들기 위해서는 먼저 Django 프로젝트 내에서 해당 명령어를 정의할 앱을 생성해야 합니다. 아래는 커스텀 관리 명령어를 생성하는 방법에 대한 단계별 가이드입니다.

2.1 앱 생성

먼저 프로젝트 내에서 새로운 앱을 생성합니다. 아래 명령어를 통해 새로운 앱을 만들 수 있습니다.

python manage.py startapp myapp

여기서는 myapp라는 이름의 앱을 생성한다고 가정합니다. 그 후, 앱 디렉토리 내에 management/commands라는 하위 디렉토리를 생성합니다.

mkdir -p myapp/management/commands

2.2 관리 명령어 파일 생성

위에서 생성한 commands 디렉토리 내에 새로운 Python 파일을 생성하여 커스텀 명령어를 정의합니다. 예를 들어, hello.py라는 파일을 생성하겠습니다.

touch myapp/management/commands/hello.py

2.3 커스텀 관리 명령어 구현

이제 hello.py 파일의 내용을 작성하여 실제 명령어를 구현합니다. 아래 예시는 간단하게 “Hello, Django!”를 출력하는 관리 명령어입니다.

from django.core.management.base import BaseCommand

class Command(BaseCommand):
    help = 'Prints Hello, Django!'

    def handle(self, *args, **kwargs):
        self.stdout.write(self.style.SUCCESS('Hello, Django!'))

위 코드에서 BaseCommand 클래스를 상속받아 새로운 커스텀 명령어를 구현했습니다. handle 메서드는 명령어의 주 작업을 처리하며, self.stdout.write를 사용하여 콘솔에 메시지를 출력합니다.

2.4 명령어 실행

이제 커스텀 관리 명령어를 실행해 볼 차례입니다. 아래와 같은 명령어를 사용하여 실행할 수 있습니다.

python manage.py hello

명령어를 실행하면 콘솔에 Hello, Django!라는 메시지가 출력되는 것을 확인할 수 있습니다.

3. 인자 받아오기

커스텀 관리 명령어는 인자를 받아 사용할 수도 있습니다. 아래 예제에서는 이름을 입력받아 인사하는 명령어를 만들어 보겠습니다.

3.1 파일 수정

이제 hello.py 파일을 수정하여 인자를 받을 수 있도록 변경하겠습니다.

from django.core.management.base import BaseCommand

class Command(BaseCommand):
    help = 'Greets a user by name'

    def add_arguments(self, parser):
        parser.add_argument('name', type=str, help='Name of the user')

    def handle(self, *args, **kwargs):
        name = kwargs['name']
        self.stdout.write(self.style.SUCCESS(f'Hello, {name}!'))

3.2 인자와 함께 명령어 실행하기

이제 수정한 명령어를 실행해 보겠습니다. 아래 명령어를 통해 인자를 전달할 수 있습니다.

python manage.py hello John

이 명령어를 실행하면 Hello, John!이라는 메시지가 출력됩니다.

4. 복잡한 작업 처리하기

커스텀 관리 명령어는 단순한 콘솔 출력 외에도 더 복잡한 작업을 수행할 수 있습니다. 예를 들어, 데이터베이스의 데이터를 가져오거나 특정 파일을 처리하는 등의 작업을 할 수 있습니다.

4.1 예제: 데이터베이스 조회

데이터베이스에서 특정 Model의 데이터를 조회하는 간단한 예를 들어보겠습니다. 예를 들어, Book이라는 모델이 있다고 가정해봅시다.

from django.core.management.base import BaseCommand
from myapp.models import Book

class Command(BaseCommand):
    help = 'Lists all books in the database'

    def handle(self, *args, **kwargs):
        books = Book.objects.all()
        if books:
            for book in books:
                self.stdout.write(f'{book.title} by {book.author}')
        else:
            self.stdout.write('No books found.')

위 코드는 데이터베이스에 있는 모든 Book 객체의 제목과 저자를 출력합니다. 이제 이를 실행해보면, 데이터베이스에 저장된 모든 책의 목록을 볼 수 있습니다.

4.2 데이터베이스에 데이터 추가하기

또한 관리 명령어를 사용하여 데이터를 데이터베이스에 추가할 수도 있습니다. 아래는 Book 모델에 새 책을 추가하는 예제입니다.

from django.core.management.base import BaseCommand
from myapp.models import Book

class Command(BaseCommand):
    help = 'Adds a new book to the database'

    def add_arguments(self, parser):
        parser.add_argument('title', type=str, help='Title of the book')
        parser.add_argument('author', type=str, help='Author of the book')

    def handle(self, *args, **kwargs):
        title = kwargs['title']
        author = kwargs['author']
        book = Book(title=title, author=author)
        book.save()
        self.stdout.write(self.style.SUCCESS(f'Added book: {title} by {author}'))

명령어를 실행할 때 제목과 저자를 인자로 넘겨주면 새로운 책이 데이터베이스에 추가되며, 성공 메시지가 출력됩니다.

5. 작업에 대한 로깅 추가하기

커스텀 관리 명령어를 만들 때 유용한 기능 중 하나는 작업에 대한 로깅 기능입니다. Django의 logging 모듈을 활용하여 명령어가 실행될 때의 상황을 기록할 수 있습니다.

5.1 로깅 설정

먼저 Django 프로젝트의 settings.py 파일에서 로깅을 설정해야 합니다. 아래와 같은 기본 설정을 추가합니다.

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'file': {
            'level': 'DEBUG',
            'class': 'logging.FileHandler',
            'filename': 'django_debug.log',
        },
    },
    'loggers': {
        'django': {
            'handlers': ['file'],
            'level': 'DEBUG',
            'propagate': True,
        },
    },
}

5.2 명령어에 로깅 추가

이제 이미 구현한 커스텀 관리 명령어에 로깅 기능을 추가하겠습니다.

import logging
from django.core.management.base import BaseCommand

logger = logging.getLogger(__name__)

class Command(BaseCommand):
    help = 'Adds a new book to the database with logging'

    def add_arguments(self, parser):
        parser.add_argument('title', type=str, help='Title of the book')
        parser.add_argument('author', type=str, help='Author of the book')

    def handle(self, *args, **kwargs):
        title = kwargs['title']
        author = kwargs['author']
        book = Book(title=title, author=author)
        book.save()
        logger.info(f'Added book: {title} by {author}')
        self.stdout.write(self.style.SUCCESS(f'Added book: {title} by {author}'))

이렇게 추가한 후, 명령어를 실행하면 django_debug.log 파일에 추가된 책에 대한 로그가 기록됩니다.

6. 결론

커스텀 관리 명령어는 Django의 강력한 기능 중 하나로, 반복적인 작업이나 데이터 관리 작업을 쉽게 수행할 수 있도록 도와줍니다. 본 문서에서 설명한 내용을 통해 커스텀 관리 명령어를 구현하는 방법과 인자 처리, 데이터 관리, 로깅 기능을 추가하는 방법에 대해 알아보았습니다. 이 외에도 커스텀 관리 명령어는 유용한 기능과 패턴을 통해 다양한 작업을 수행할 수 있으므로 필요에 따라 자유롭게 활용할 수 있습니다.

이제 여러분도 Django에서 커스텀 관리 명령어를 만들어 유용하게 활용해보시기 바랍니다!

DJango 서버개발, 필드 유형 및 관계 설정 (OneToOne, ForeignKey, ManyToMany)

Django는 파이썬으로 작성된 강력한 웹 프레임워크로, 데이터베이스를 모델링하는 매우 유연한 방법을 제공합니다. Django의 모델 클래스는 데이터베이스의 테이블을 정의하고, 각 필드는 데이터베이스의 열을 나타냅니다. 이번 강좌에서는 Django 모델에서 다양한 필드 유형과 데이터 간의 관계를 설정하는 방법에 대해 알아보겠습니다.

1. Django 모델 소개

Django의 모델은 django.db.models.Model를 상속받아 정의됩니다. 모델 설계를 통해 우리가 어떤 데이터를 저장하고 어떤 관계를 가질지를 설정할 수 있습니다. 모델 필드는 다음과 같은 다양한 데이터 유형을 지원합니다:

  • CharField
  • TextField
  • IntegerField
  • DateTimeField
  • EmailField
  • FileField, ImageField 등

2. 필드 유형

각 필드는 특정한 속성을 가지며, 이러한 속성을 통해 데이터의 유효성과 제약을 설정할 수 있습니다. 다음은 일반적으로 사용되는 필드 유형들입니다.

2.1 CharField

문자열 필드로, 주로 짧은 텍스트를 저장하는 데 사용됩니다. max_length 속성이 필수입니다.

from django.db import models

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

2.2 TextField

긴 텍스트를 저장할 수 있는 필드입니다. max_length 속성이 필요하지 않습니다.

class BlogPost(models.Model):
    title = models.CharField(max_length=100)
    content = models.TextField()

2.3 IntegerField

정수를 저장하기 위한 필드입니다.

class Comment(models.Model):
    post = models.ForeignKey(BlogPost, on_delete=models.CASCADE)
    likes = models.IntegerField(default=0)

3. 데이터베이스 관계 설정

Django에서는 데이터 간의 관계를 설정할 수 있는 여러 가지 방법을 제공합니다. 주로 사용되는 관계는 다음과 같습니다.

3.1 OneToOneField

OneToOneField는 서로 다른 두 모델 간의 1:1 관계를 설정할 때 사용합니다. 예를 들어, 사용자가 프로필을 가지는 경우에 사용할 수 있습니다.

class UserProfile(models.Model):
    user = models.OneToOneField(Author, on_delete=models.CASCADE)
    bio = models.TextField()
    avatar = models.ImageField(upload_to='avatars/')

3.2 ForeignKey

ForeignKey는 1:N 관계를 설정할 때 사용합니다. 예를 들어, 한 명의 저자가 여러 개의 포스트를 가진다고 가정해봅시다.

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

class BlogPost(models.Model):
    author = models.ForeignKey(Author, on_delete=models.CASCADE)
    title = models.CharField(max_length=100)
    content = models.TextField()

3.3 ManyToManyField

ManyToManyField는 N:M 관계를 설정할 때 사용합니다. 예를 들어, 여러 개의 태그가 여러 개의 블로그 포스트에 연관될 수 있습니다.

class Tag(models.Model):
    name = models.CharField(max_length=30)

class BlogPost(models.Model):
    title = models.CharField(max_length=100)
    tags = models.ManyToManyField(Tag)

4. 실습: 블로그 어플리케이션 모델 설계

이제 실습을 통해 위의 개념을 종합적으로 이해해보겠습니다. 간단한 블로그 게시물과 관련된 여러 모델을 설계해보겠습니다.

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

class Tag(models.Model):
    name = models.CharField(max_length=30)

class BlogPost(models.Model):
    title = models.CharField(max_length=100)
    content = models.TextField()
    author = models.ForeignKey(Author, on_delete=models.CASCADE)
    tags = models.ManyToManyField(Tag)
    created_at = models.DateTimeField(auto_now_add=True)

5. 마이그레이션

모델을 정의한 후에는 마이그레이션을 통해 데이터베이스에 반영해야 합니다. 다음 명령어를 통해 마이그레이션을 생성하고 실행할 수 있습니다.

$ python manage.py makemigrations
$ python manage.py migrate

6. Django Admin을 통한 모델 관리

Django Admin을 사용하면 모델을 쉽게 관리할 수 있습니다. Admin에 모델을 등록해보겠습니다.

from django.contrib import admin
from .models import Author, Tag, BlogPost

admin.site.register(Author)
admin.site.register(Tag)
admin.site.register(BlogPost)

7. 결론

이와 같이 Django에서는 다양한 필드 유형과 관계를 설정할 수 있는 방법을 제공합니다. 이는 데이터베이스 모델링 시 유연성과 강력함을 보장합니다. 본 강좌를 통해 Django 모델의 설계에 대한 깊이 있는 이해를 했길 바라며, 자신만의 어플리케이션을 개발하는 데 도움이 되었으면 합니다.

더 많은 정보를 원하시면 Django 공식 문서를 참조하시기 바랍니다.

DJango 서버개발, 정적 파일(자바스크립트, CSS) 및 미디어 파일(업로드된 파일) 설정하기

Django는 웹 애플리케이션을 개발하기 위한 강력한 프레임워크로, 데이터베이스와의 상호작용, URL 라우팅, 사용자 인증 등의 기능을 제공합니다. 본 글에서는 Django 프로젝트에서 정적 파일과 미디어 파일을 설정하는 방법에 대해 자세히 설명하겠습니다. 정적 파일은 자바스크립트, CSS 파일을 포함하며, 미디어 파일은 사용자가 업로드한 파일으로 정의합니다.

1. Django 프로젝트 생성

먼저, Django 프로젝트를 생성해야 합니다. Django가 설치되어 있지 않은 경우, 다음 명령어로 설치합니다:

pip install django

Django를 설치한 후, 프로젝트를 생성합니다:

django-admin startproject myproject

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

cd myproject

2. 정적 파일 설정

정적 파일은 주로 CSS, JavaScript, 이미지 파일 등을 포함하며, 웹 애플리케이션의 프론트엔드 요소를 구성합니다. Django에서는 정적 파일을 관리하기 위해 `STATIC_URL`, `STATICFILES_DIRS`, `Collectstatic` 같은 설정을 활용합니다.

2.1 settings.py 설정

`settings.py` 파일을 열어 정적 파일의 설정을 추가합니다. 아래와 같은 설정을 추가합니다:


# settings.py
import os

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

# 정적 파일 설정
STATIC_URL = '/static/'
STATICFILES_DIRS = [os.path.join(BASE_DIR, 'static')]

위의 설정에서 `STATIC_URL`은 정적 파일에 접근하기 위한 URL 경로를 정의합니다. `STATICFILES_DIRS`는 정적 파일이 저장된 디렉토리 경로를 설정합니다. 위 예시에서는 프로젝트의 루트 디렉토리에 `static`이라는 폴더를 생성했다고 가정하고 있습니다.

2.2 정적 파일 생성 및 사용

이제 `static` 폴더를 생성하고 CSS 또는 JavaScript 파일을 추가할 수 있습니다. 예를 들어, `static/css/styles.css` 파일을 생성합니다:


/* static/css/styles.css */
body {
    font-family: Arial, sans-serif;
    background-color: #f0f0f0;
}

HTML 파일에서 이 CSS 파일을 사용하기 위해 템플릿 파일을 만들어야 합니다. 예를 들어, `templates/index.html` 파일을 생성하고 다음 코드를 추가합니다:







    
    
    
    정적 파일 예제


    

정적 파일을 적용한 Django 예제

템플릿에서 `{% static ‘css/styles.css’ %}`를 사용하여 정적 파일 경로를 설정하였습니다. 이 코드는 Django의 template tag를 이용하여 정적 파일의 실제 URL을 생성합니다.

2.3 Django 정적 파일 서버 실행

개발 중에는 Django가 자동으로 정적 파일을 제공하지만, 프로덕션 환경에서는 Nginx 또는 Apache와 같은 웹 서버를 사용하는 것이 좋습니다. 그러나 개발 중에 정적 파일을 수동으로 제공하기 위해, Django의 개발 서버를 실행합니다:

python manage.py runserver

이제 웹 브라우저에서 `http://127.0.0.1:8000`에 접속하면 정적 파일이 포함된 페이지를 확인할 수 있습니다.

3. 미디어 파일 설정

미디어 파일은 사용자가 업로드한 파일을 포함합니다. Django에서 미디어 파일을 관리하는 방법에 대해 설명하겠습니다.

3.1 Media 설정

`settings.py`에 미디어 파일에 대한 설정을 추가합니다. 아래와 같은 코드를 추가합니다:


# settings.py
MEDIA_URL = '/media/'
MEDIA_ROOT = os.path.join(BASE_DIR, 'media')

`MEDIA_URL`은 미디어 파일에 접근하기 위한 URL 경로를 정의하고, `MEDIA_ROOT`는 파일이 저장될 디렉토리 경로를 설정합니다. 여기서는 프로젝트의 루트에 `media` 디렉토리를 생성한다고 가정합니다.

3.2 모델 생성 및 파일 업로드 처리

이제 미디어 파일을 업로드할 수 있는 모델을 생성하겠습니다. `app/models.py`에 아래와 같은 모델을 추가합니다:


from django.db import models

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

    def __str__(self):
        return self.title

`Upload` 모델은 파일 업로드를 위해 필요한 필드를 정의합니다. `FileField`를 사용하여 파일을 저장합니다. `upload_to` 매개변수는 업로드된 파일이 저장될 경로를 설정합니다.

3.3 폼 생성

파일 업로드를 처리하기 위해 Django의 Form을 생성합니다. `app/forms.py` 파일을 생성하고 다음 코드를 추가합니다:


from django import forms
from .models import Upload

class UploadForm(forms.ModelForm):
    class Meta:
        model = Upload
        fields = ['title', 'file']

3.4 뷰(View) 및 URL 설정

이제 뷰를 생성하여 파일 업로드를 처리합니다. `app/views.py` 파일에 아래와 같은 뷰를 추가합니다:


from django.shortcuts import render
from .forms import UploadForm

def upload_file(request):
    if request.method == 'POST':
        form = UploadForm(request.POST, request.FILES)
        if form.is_valid():
            form.save()
            return redirect('upload_file')  # 업로드 후 페이지로 리다이렉트
    else:
        form = UploadForm()
    
    return render(request, 'upload.html', {'form': form})

`upload_file` 함수는 업로드 요청을 처리하며, POST 방식일 경우 폼 데이터를 확인하고 유효하다면 파일을 저장합니다. 그런 후 사용자에게 피드백을 주기 위해 폼을 다시 렌더링합니다.

3.5 URLconf 설정

`urls.py` 파일을 수정하여 업로드 URL을 추가합니다:


from django.urls import path
from .views import upload_file

urlpatterns = [
    path('upload/', upload_file, name='upload_file'),
]

3.6 템플릿 생성

마지막으로 업로드 폼을 위한 템플릿을 생성합니다. `templates/upload.html` 파일을 생성하고 다음과 같은 코드를 추가합니다:







    
    
    파일 업로드


    

파일 업로드

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

3.7 미디어 파일 제공 설정

개발 중에 미디어 파일을 제공하기 위해 `urls.py`에 다음과 같은 설정을 추가합니다:


from django.conf import settings
from django.conf.urls.static import static

urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

`static()` 함수는 미디어 파일을 제공하는 URL 경로를 설정합니다.

4. 결론

이제 Django 프로젝트에서 정적 파일과 미디어 파일을 설정하는 방법에 대해 배웠습니다. 정적 파일은 CSS와 JavaScript와 같은 클라이언트 측 리소스를 포함하고, 미디어 파일은 사용자가 업로드한 파일을 관리합니다. 이 두 가지 설정을 통해 Django 애플리케이션의 기능을 확장하고 사용자 경험을 개선할 수 있습니다.

이 포스팅이 Django 개발에 도움이 되길 바랍니다. 추가적인 질문이나 의견이 있다면 댓글로 남겨주세요.

DJango 서버개발, 개인 포트폴리오 웹사이트 만들기

Django는 파이썬으로 작성된 고급 웹 프레임워크로, 웹 애플리케이션 개발을 빠르고 쉽게 할 수 있게 도와줍니다. 본 글에서는 Django를 사용하여 개인 포트폴리오 웹사이트를 만드는 방법을 단계별로 알아보겠습니다.

1. Django란?

Django는 “모든 것을 포함하는” 프레임워크로서 다음과 같은 장점이 있습니다:

  • 빠른 개발
  • 보안 내장
  • 재사용 가능한 코드
  • 풍부한 생태계와 커뮤니티

2. 프로젝트 설정

2.1. Django 설치

우선, Django를 설치해야 합니다. 다음 명령어를 사용하세요:

pip install Django

2.2. 새로운 Django 프로젝트 만들기

Django 프로젝트를 생성하기 위해 다음 명령어를 입력합니다:

django-admin startproject portfolio

생성된 portfolio 폴더로 이동합니다:

cd portfolio

2.3. 개발 서버 시작하기

다음 명령어로 개발 서버를 시작합니다:

python manage.py runserver

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

3. 앱 생성

Django 프로젝트 내에서 기능별로 앱을 생성합니다. 포트폴리오 웹사이트를 위해 새로운 앱을 생성해 보겠습니다:

python manage.py startapp myportfolio

생성된 myportfolio 폴더에는 다양한 파일들이 포함되어 있습니다. 주로 수정해야 할 파일은 views.pyurls.py입니다.

4. 앱 등록

myportfolio 앱을 프로젝트에 등록합니다. settings.py 파일을 열어 INSTALLED_APPS 항목에 'myportfolio'를 추가합니다:


    INSTALLED_APPS = [
        ...
        'myportfolio',
    ]
    

5. URL 매핑

이제 이 앱의 URL을 매핑해보겠습니다. myportfolio/urls.py 파일을 생성하고 다음과 같이 작성합니다:


    from django.urls import path
    from . import views
    
    urlpatterns = [
        path('', views.home, name='home'),
    ]
    

views.py에서 home 뷰를 추가합니다:


    from django.shortcuts import render

    def home(request):
        return render(request, 'myportfolio/home.html')
    

6. 템플릿 생성

myportfolio 폴더 내에 templates/myportfolio 폴더를 생성하고 그 안에 home.html 파일을 만듭니다. 아래와 같이 작성해보세요:


    

    
    
        
        내 포트폴리오
    
    
        

안녕하세요, 저는 [이름]입니다.

제 포트폴리오에 오신 것을 환영합니다!

7. 정적 파일 및 CSS

포트폴리오 웹사이트에 스타일을 추가하기 위해 CSS 파일을 생성합니다. myportfolio/static/myportfolio/style.css 위치에 생성하고 다음과 같이 작성합니다:


    body {
        font-family: Arial, sans-serif;
        background-color: #f9f9f9;
    }

    h1 {
        color: #333;
    }

    p {
        font-size: 18px;
    }
    

이제 home.html에서 CSS 파일을 불러옵니다:


    
    

8. 데이터베이스 및 모델 설정

포트폴리오에 프로젝트나 경험을 저장하기 위해 모델을 생성합니다. myportfolio/models.py에서 다음과 같이 작성하세요:


    from django.db import models

    class Project(models.Model):
        title = models.CharField(max_length=100)
        description = models.TextField()
        url = models.URLField()

        def __str__(self):
            return self.title
    

8.1. 마이그레이션

모델을 생성한 후에는 마이그레이션을 통해 데이터베이스를 업데이트해야 합니다. 다음 명령어를 사용합니다:

python manage.py makemigrations
python manage.py migrate

9. 관리자 페이지 설정

Django의 관리자 페이지를 통해 프로젝트를 쉽게 관리할 수 있습니다. myportfolio/admin.py에 다음을 추가하세요:


    from django.contrib import admin
    from .models import Project

    admin.site.register(Project)
    

관리자 계정을 생성하려면:

python manage.py createsuperuser

9.1. 관리자 페이지 접속

서버를 재시작하고 http://127.0.0.1:8000/admin/에서 로그인하여 프로젝트를 추가해보세요.

10. 프로젝트 표시

views.py에서 프로젝트를 가져오는 뷰를 만들어야 합니다. 수정된 views.py는 다음과 같습니다:


    from .models import Project

    def home(request):
        projects = Project.objects.all()
        return render(request, 'myportfolio/home.html', {'projects': projects})
    

이제 home.html을 수정하여 프로젝트 목록을 표시합니다:


    

내 프로젝트

    {% for project in projects %}
  • {{ project.title }}: {{ project.description }} (링크)
  • {% endfor %}

11. 배포하기

포트폴리오 웹사이트가 완성되면, 이를 실제 환경에 배포할 차례입니다. Heroku 또는 DigitalOcean과 같은 클라우드 서비스를 이용하여 배포할 수 있습니다.

12. 결론

Django를 이용한 개인 포트폴리오 웹사이트 개발 과정이었습니다. 이 과정을 통해 Django의 기본 개념과 웹 애플리케이션 개발 방법을 이해했기를 바랍니다. 나만의 포트폴리오 웹사이트를 만들어보세요!

© 2023 내 포트폴리오