Background

이번 포스팅에서는 아래의 질문으로 시작하려 한다.

여러분은 왜 django 를 사용하는가?

아마 대부분은...

1. `python` 으로 웹 애플리케이션을 만들 수 있기 때문에 
2. `Zero Base`에서 개발하는데에 큰 시간이 안 들기 때문에
3. 주변 동종업계에서 많이 채용하여 쓰고 있기 때문에
4. 업무 환경상 정해진 스펙이였기 때문에

위와 같은 이유가 아니였을까 싶다.

하지만 이번 포스팅에서는 아래 질문에 집중해보려 한다.

django 를 이용해서 어디까지 커버할 것 인지가 정해져야, 구체적인 프로젝트 기술 스펙과 Tier 구조가 명확해 지기 때문이다.

django로 어느 부분까지 개발할 것인지

혹시 위 질문에 대해서 아래처럼 대답하려 했다면, django 가 당신의 프로젝트에서 어떤 부분을 담당하게 되는지가 상당히 막연한 상황이 될 것이다.

서버는 django 를 이용해서 개발한다.

당신의 업무에서 Django의 역할을 정해라

django 로 할 수 있는 개발영역은 대략 아래와 같다.

1. 서버 (back-end) 로직 : 컨트롤러(View) + 모델(DB)
2. 서버 (back-end) 로직 + 프론트 엔드 페이지 > (fullstack) : 템플릿(Template) + α Packages (필요에 따라)
3. RESTful API 서버

즉, 사용자의 Use case 에 따라서, 서버, 서버/프론트 개발을 아우르는 fullstack 프레임워크로 활용할 수도 있고 API 전용 서버로 개발할 수도 있다.

어디까지 활용할 것인지에 대해서는 특별히 정답은 없다.

프로젝트의 시스템 구조, 개발인력, 데이터 구조 등 각각 처한 상황에 맞춰서 유연하게 사용하면 된다.

다만, django 사용을 고려하기에 앞서서 아래 3가지에 대한 답을 내보도록 하자.

1. django로 할수 있는 개발영역과 현재 업무의 개발사양 / 시스템 구조는 무엇인가?
2. 다른 웹 프레임워크 보다 django를 쓰면 좋은점과 나쁜점은 무엇인가?
3. django를 어디까지 사용할 것인가? 서버만? 서버 + 프론트 둘다? + API 서버로만 활용?

당신의 결정에 의해서 대략적인 프로젝트 구조의 이미지가 그려질 것이다.

아래와 같이예를 들어보자

서버 + 프론트 둘다 django를 이용하여 개발한다

위와 같은 사양으로 간다고 하면 당신은 따로 front-end 개발을 할 필요가 없어지는 대신에, django 프로젝트 안에 template 를 작성해야 할 것이고, page reloading 이 페이지별로 요쳥 할 때마다 불려지기 떄문에 성능이 살짝 느려질 수도 있다.

성능은 무조건 빠르게 하고싶다면?

만약 성능이 최고 우선순위라면, django 로는 서버로직만 맡고 front-end 로는 SPA 프레임워크로 결정하는게 나은지 검토해봐야 할 것이다.

이런식으로 django 의 활용 범위를 사용하기 전에 확실히 정한다면, 전체적인 프로젝트 시스템 아키텍쳐가 그려지고, 앞으로 개발을 위해 공부/조사해야 할 것들, 필요한 외부 packages, TODO 리스트 등이 훨씬 명확해 질 것이다.

다음 포스팅에서는 django 에 빠질 수 없는 라이브러리인 rest framework 에 대해서 알아보겠다.

Thank you!

Chapter 3: Pages App

오늘 포스팅에서는, 새로운 django App 을 개발해볼 것이다.

특히 Template 을 확장시켜서 저번에 만들었던 Hello World App 보다 그럴 듯한 페이지를 만들어보자.

프로젝트 생성 및 기본 환경 설정 하기

가상 python 환경에 들어가서, 새로운 project 와 app 을 만든다.

source venv/bin/activate

django-admin startproject config2

cd config2

python manage.py startapp pages

그리고, config2 프로젝트 폴더의 settings.py 에서 우리가 추가한 pages App 을 추가하자.

# Application definition

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',

    'pages', #new App
]

마지막으로 기본 DB link 작업을 위해, migrate 명령을 실행하자.

python manage.py migrate

이것으로 기본적인 환경 세팅은 끝났다. 서버를 가동하고 기본 페이지가 잘 표시되는지 확인해 보자.

python manage.py runserver

마이그레이션이 완료되었으면, 웹브라우저로 아래에 접속해보자.

http://127.0.0.1:8000/

화면이 잘 표시된다. 이것으로 기본 세팅은 완료되었다.

다음 포스팅에서는 본격적으로 Template 을 작성해보고, View 파일과 연계하는 법에 대하여 알아보자.

Thank you!

Chapter 2. Hello World App (3)

저번 포스팅에서는 App 을 Project 안에 만들어보았다.

이번 포스팅에서는 View 를 하나 만들어서, 우리가 요청하는 url에 응답하도록 해보자.

View 만들기

우리가 특정한 url로 request를 할때 반응시키기 위하여, View를 만들어보도록 한다.

pages/views.py 파일을 열어서 다음과 같이 작성한다.

# page/views.py
from django.http import HttpResponse

# Create your views here.
def homePageView(request):
  return HttpResponse('Hello, World!')

구조는 간단하다.

front-end 에 응답을 주기 위하여, HttpResponse 클래스를 import 하고, homePageView 라는 이름의 함수를 정의한다.

간단히 설명하자면, 특정한 요청이 들어올 때 views.py 파일에 정의되어있는 특정 메소드를 호출하여 처리하는 식이다.

외부 요청에 의해 homePageView 메소드가 불렸을 때, 우리는 단순히 front-end 에 Hello, World! 라는 문자열을 돌려주는 처리를 하게 된다.

다음으로, 외부 요청과 homePageView 를 연결하기 위한 url 라우팅 설정을 하도록 하자.

url routing 설정하기

우리는 pages App 전용 url 설정을 분리해서 처리할 것이다. 유지보수도 쉽고, App 별로 분리가 가능하기 때문이다.

아래 경로에 urls 파일을 하나 만들자.

config/pages/urls.py

아래와 같이 우리가 만들었던 View를 추가하자.

from django.urls import path
from .views import homePageView

urlpatterns = [
    path('', homePageView, name='home')
]

이것으로 끝이 아니다. 실제 root url 파일에 import 시켜야 한다.

config/urls.py

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

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

이것으로 개발작업은 끝이다.

서버를 가동하고, root url -> http://127.0.0.1:8000/ 로 접근해보자.

python manage.py runserver

아래와 같이 Hello, World! 문자열이 출력되는 것을 알 수 있다.

이것으로 간단히 뷰와 라우팅을 설정하여 실제로 원하는 문자열을 front-end 로 응답하여 보았다.

다음은 조금 더 관련내용을 자세하게 살펴보도록 하자.

Chapter 2. Hello World App (2)

전 포스팅에 이어서, config 프로젝트 아래에 App 을 하나 생성해보려 한다.

django 는 코드를 깔끔하고 읽기 쉽게 끔 하기 위해서 Project 와 App 의 컨셉을 사용한다.

django 는 1개의 Project 마다 다수의 App 을 가질 수 있으며 각각의 기능별로 분리하는 로직을 가짐으로써 보다 체계적인 프로젝트 관리가 가능하게끔 한다.

한가지 예를 들어보자.

어떤 e-commerce 사이트를 개발한다고 했을 때, e-commerce 프로젝트를 하나 만든 후에, 그 아래에 기능별로 여러가지 App을 생성하는 식이다.

Project -> e-commerce App -> user_authentication (회원 인증), payments (구매), listing (조회)

그럼 바로 pages 라는 이름의 App 을 만들어 보자.

python manage.py startapp pages

pages 폴더가 만들어졌다. 구조를 확인해보자.

tree

간단히 각각의 폴더 / 파일에 대해서 설명하자면 아래와 같다.

• admin.py : django 가 기본으로 제공해주는 Admin App
• apps.py : App 환경설정 파일
• migrations/ : models.py 에서 변경점을 기록하여 실제 DB 에 반영하기 위한 파일
• models.py : DB 모델을 정의 하는 파일, 이 파일을 참고하여 django 는 내부 Model과 DB 를 링크시킨다
• tests.py : App 단위의 테스트 파일
• views.py : Web browser / API 와 연동하여 Response / Request 로직을 작성하는 파일

이번 포스팅에서는 App의 개념과 구조에 대해서 간단히 알아보았다.

다음 포스팅에서는 실제로 App 아래에서 View를 만들어서, 특정한 url로 요청이 들어왔을 떄 웹브라우저에 원하는 문자를 출력시켜 보도록 하자.

Thank you!

Django For Beginners 공부를 시작하면서...

이번 시리즈는 William S. Vincent 가 집필한 Django For Beginners 를 참고하여 첫 예제부터 차근차근 공부해 나가보려 한다.

기획 의도로는 여러가지 실전 예제를 개발해나가면서 다양한 상황에서 필요한 Django 스킬과 개념을 초보자 관점에서 쉽게 풀어내고 있기 때문이다.

또, 이론과 개념/구조 위주로만 기술하고 있는 기존의 레퍼런스 보다는 직접 결과물을 볼 수 있으니 보람도 있고, 실제로 실무적인 context에 필요한 Django의 다양한 라이브러리 / 기능의 사용법, 확장하는 법을 경험할 수 있기에 필자로서도 이를 여러분께 공유하는 것도 여러모로 도움이 될 것 같아서이다.

그럼 Chapter 2: Hello World App 부터 시작해보자!

Chapter 2: Hello World App

자, 시작하기에 앞서서 작업할 폴더를 생성하고 python 가상환경을 링크 시킨뒤에 django 를 설치하자.

terminal 에 들어가서, 작업하고 싶은 폴더에 들어간다. 그리고 가상환경을 venv 폴더안에 구축하기 위해서 아래 커맨드로 만들어준다.

python3 -m venv venv

venv 폴더 안에 가상환경 파일이 만들어졌다. 이제 방금 만든 가상환경 모드로 아래 커맨드를 실행해서 세팅해보자.

source venv/bin/activate

위의 스크린샷에서 보이듯이 왼쪽에 (venv) 현재세팅되어있는 가상환경폴더명이 보이고 있음을 확인 할 수 있다.

세팅이 완료되었으니, 가상환경안에서 우리가 작업에 필요한 다양한 라이브러리를 설치하면 된다.

덧붙여서, 우리가 현재 들어와있는 가상환경은 이번에 개발할 Hello World App 프로젝트만을 위한, 완전히 독립적인 환경이기 때문에 곧 설치할 라이브러리 버전에 의한 호환성 문제가 다른 프로젝트를 개발할때 생긴다던지의 문제는 일어나지 않으니 안심하고 진행해도 된다.

이제 아래 커맨드로 django 를 설치해보자.

본 도서가 집필되었을 당시에는 3.1.0 버전 기준이였으니 적어도 그 이상은 되야 한다.

pip install django~=3.1.0

django 가 설치되었으므로, 프로젝트를 아래 커맨드로 하나 만들자.

django-admin startproject config

위 처럼 config 이름의 프로젝트가 생성되었다. 프로젝트의 폴더 구조를 아래 커맨드로 확인해보자.

tree

tree 라이브러리가 필요하기 때문에, 설치가 되어있지 않다면 아래 커맨드로 설치한후에 다시 실행하자.

brew install tree

각각의 파일의 용도에 대해 간단히 설명하면 아래와 같다.

• settings.py 프로젝트의 전체적인 시스템을 설정한다. (DB, Template 설정 등)

• urls.py 웹 브라우저나, URL Request가 들어오면 어떤 View 로 라우팅 해줄 것 인지를 설정한다.

• wsgi.py 외부에서 이벤트 처리가 필요할 경우에 로직을 작성한다.

• manage.py Django 에서 제공해주는 여러가지 편리한 커맨드를 사용할 수 있다. (server 실행, db 접근, migration 등)

• asgi.py Django 3.0 버전부터 새롭게 추가된 기능으로, 비동기로 처리해야할 작업이 있을 때 작성한다.

자, 이제 Django 프로젝트를 새롭게 만든 후에 자동으로 작성된 DB Model 에 대해서 Migration 을 실행하자. 실제 물리 DB와 매핑하는 과정이다.

아래 커맨드를 실행한다.

python manage.py migrate

기본적으로 필요한 DB 매핑 작업이 완료되었다.

이제 서버를 실행시키는데 최소한의 작업이 끝났으니, 아래 커맨드로 서버를 가동시켜보자.

python manage.py runserver

에러 없이 실행이 완료되었다.

마지막으로 아래 url에 접속하여 보자.

http://127.0.0.1:8000/

아래 처럼 페이지가 표시되었다면 작업하기 위한 기본 환경설정은 끝난 것이다. 다음 포스팅에서는 새로운 페이지를 추가하여 우리가 원하는 내용을 웹 페이지에 표시해 보도록 하겠다.

Thank you!

권한 설정 해보기

이번 포스팅에서는 로그인 한 유저만 페이지 및 데이터를 표시하게 끔 해보자.

이를 위해서는 권한을 체크하는 로직이 필요한데, rest framework 에서는 permissions 이라는 패키지를 따로 제공하고 있다.

권한 설정을 하고 싶은 View 파일로 들어가서 아래(## 권한설정 추가부분 ##)와 같이 추가해준다. 아래의 예는 Post 데이터를 보여주는 PostViewSet 에서 설정하였다.

ex) view 파일 위치 /dashboard/dashboard_core/views.py

from rest_framework.permissions import IsAuthenticatedOrReadOnly
.
.
.
# Create your views here.
class PostViewSet(ModelViewSet):
  queryset = Post.objects.all()
  serializer_class = PostSerializer
  ## 권한설정 추가부분 ##
  permission_classes = [IsAuthenticatedOrReadOnly]
  ## 권한설정 추가부분 ##

우리가 추가한 부분은 아래 한 줄인데, 해당하는 View 클래스에 적용하고 싶은 권한 로직이 구현되어 있는 클래스를 permission_classes 정의변수에 assign 한다.

permission_classes = [IsAuthenticatedOrReadOnly]

참고로 IsAuthenticatedOrReadOnly 는 이미 rest_framework.permissions 라이브러리에서 제공하는 권한로직들중 하나이다.

당연히, Overriding 도 가능하니 원하는 대로 커스터마이징 해서 쓰면 된다. 필자의 경우에는 GET 요청일 때도 로그인 한 유저만 보이도록 변경하였다.

변경파일: /venv/lib/python3.8/site-packages/rest_framework/permissions.py

SAFE_METHODS = ('HEAD', 'OPTIONS')
.
.
.
.
class IsAuthenticatedOrReadOnly(BasePermission):
    """
    The request is authenticated as a user, or is a read-only request.
    """

    def has_permission(self, request, view):
        return bool(
            request.method in SAFE_METHODS or
            request.user and
            request.user.is_authenticated
        )

이제, 서버를 가동시켜서 로그인 하지 않은 경우와 로그인 한 경우에 각각, posts 데이터를 조회 (GET요청) 해보자.

확인 url: http://127.0.0.1:8000/posts/

로그인 하지 않은 경우

아래 처럼 권한에러(HTTP RESPONSE CODE -> 403) 가 발생하면서 데이터 로드에 실패했음을 알 수 있다.

로그인을 한 경우

아래 처럼 정상처리(HTTP RESPONSE CODE -> 200) 된 데이터를 볼 수 있다.

이것으로 간단히 View 로직에 권한 설정을 하는 방법을 알아보았다.

Thank you!

로그인 기능 만들어 보기

오늘 포스팅에서는 PostUser Model의 username , password 데이터로 로그인 하는 기능을 만들어 보자.

django는 기본적으로 로그인 시에, 회원인지 인증하는 처리를 제공해주고 있다. 오늘은 django가 제공하는 인증기능을 이용하여 로그인 기능을 만들어 보도록 하자.

그러나 사실은 이미 로그인 페이지는 존재한다. 저번 포스팅에서 restframework에서 기본적으로 제공해주는 패키지가 있기 때문이다.

서버를 실행하고, 아래 URL에 접속해보자.

python manage.py runserver

http://127.0.0.1:8000/api-auth/login

위 페이지로 정상적으로 로그인은 가능하다.

그러나, 직접 템플릿을 만들어서 자기가 원하는 로그인 화면을 구성할 수도 있다.

아래 경로에 login.html 을 만들고 아래와 같이 작성한다.

dashboard/templates/registration/login.html

{% extends 'auth_layout.html' %}
{% load crispy_forms_tags %}
{% block content %}
<h1>Login</h1>
<div class="login-form-container">
  <form method="POST">
    {% csrf_token %} {{ form|crispy }}
    <button type="submit" class="btn btn-sm btn-outline-primary">Login</button>
  </form>
</div>
{% endblock %}

그리고 urls.py 파일에, accounts/ 경로를 임의로 추가해주고 django.contrib.auth.urls 라우팅 설정을 매핑해주자.

그 뒤는 django 가 알아서 templates 파일을 로드해준다.

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

from django_registration.backends.one_step.views import RegistrationView
from dashboard_core.forms import PostUserForm

from rest_framework.routers import DefaultRouter
from dashboard_core.views import PostViewSet, PostUserViewSet

router = DefaultRouter()
router.register(r"posts", PostViewSet, basename="post_status")
router.register(r"users", PostUserViewSet, basename="user_status")

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

이제 준비는 끝났다.

아래 스크린 샷에서 12번째 경로로 들어가 보자.

http://127.0.0.1:8000/accounts/login/

그럼 아래와 같이 templates 안에 작성했던 로그인 html 파일이 렌더링 된다.

정상적으로 로그인도 아래처럼 처리된다.

다음 포스팅에서는 원하는 유저만 접근할 수 있게 끔 permission 처리에 대해서 알아보도록 하자.

Thank you.

Django란?

이번 포스팅에서는 Django　가 무엇인지에 대해서 간략히 소개해본다.

Django 는 2005년부터 서비스 되고 있는 python 언어기반 오픈 소스 웹 프레임워크다.

주로 backend 프레임워크로 알려져있지만 frontend 부분도 통합하여 Fullstack 프레임워크로도 개발할 수 있다.

python 언어로 웹 서비스를 개발한다고 한다면, Django or Flask 라고 보면 된다.

Flask 는 Django 에 비해 경량화 된 웹 프레임워크라고 보면 된다.

Django의 특징

1. ORM 제공

Django 는 MVT (Model - View - Template) 패턴을 채용하고 있다.

Model의 경우 데이터베이스와 연동이 편하게 되어 있으며, 각 테이블을 객체 화 하여 Django 의 서버 로직 (View) 레벨에서 OOP 개념으로 프로그래밍 할 수 있다. 이를 ORM (Object-relational mapping) 이라 한다.

즉, 일일히 DB 레벨에서 CRUD 처리를 위해 query 를 작성할 필요가 없다. ORM 에 의해 객체의 멤버 메소드로 정의되어 있다. (e.g. create(), delete() ..)

2. 관리자 페이지 제공

Django 는 기본적으로 모든 Model 데이터를 관리할 수 있는 관리자 전용 폐이지를 제공한다.

Django 프로젝트 내에서 관리하는 모든 테이블과 각각의 CRUD 처리를 관리자 페이지에서 웹 UI 기반으로 실행할 수 있다.

물론, 관리자가 존재해야 하므로, superuser는 생성해야 한다.

3. 자주 사용되는 로직을 제공

Django 는 웹 프레임워크를 개발함에 있어서 누구라도 개발하기 고민되는 부분을 이미 기본적으로 제공해주고 있다. CRUD API는 물론, 기본 회원 인증, 데이터 직렬화, 데이터 검증, 화면에 뿌려주는 Template 도 기본으로 제공해 준다.

4. 방대한 라이브러리

Django 는 python 언어 기반이기 때문에, 커뮤니티와 생태계 자체가 방대하다. 즉, Django 에 없는 기능이 필요할 지라도, 조금만 조사해보면 커스텀된 Django 전용 라이브러리가 많이 공개되어 있다.

Thank you!

회원가입 기능 API 만들기

이번 포스팅에서는 로그인 기능을 만들기 위한 전 단계인 회원가입을 API로 만들어보도록 한다.

처음으로 봐야할 부분은 Model 이다.

velog_series_01/dashboard/dashboard_core/models.py 파일을 열어보자.

# 유저 Model을 정의한다
class PostUser(AbstractUser):
  pass

기본적으로 유저정보에 대해 django 에서 템플릿을 제공해주고 있고, 우리는 그것을 가져다가 쓰기만 하기 때문에 위의 몇줄로 유저관련 Model 정의는 끝이다.

그러면, 어떤 데이터가 저장되어 있을까?

위 소스 코드에서 우리는 PostUser Model을 정의하기 위해서 AbstractUser 클래스를 상속하고 있다.

AbstractUser 를 살펴보면 또 AbstractBaseUser Model을 상속하고 있음을 알 수 있다.

즉,

class AbstractBaseUser

password last_login is_active

↑

class AbstractUser

username first_name last_name email is_staff is_active date_joined

↑

class PostUser

구조가 된다.

이제 View 부분으로 가보자.

velog_series_01/dashboard/dashboard_core/views.py 파일을 열고 아래 소스를 확인한다.

class PostUserViewSet(ModelViewSet):
  queryset = PostUser.objects.all()

  def get_serializer_class(self):
    if self.action == 'list':
      return PostUserSerializer
    elif self.action == 'create':
      return PostUserPostSerializer
    elif self.action == 'update':
      return PostUserPostSerializer
    elif self.action == 'delete':
      return PostUserPostSerializer
    else:
      return PostUserSerializer

저번 포스팅에서도 언급하였지만 PostUserViewSet 클래스가 ModelViewSet View를 상속하고 있으므로 CRUD 처리가 기본적으로 포함하고 있다.

View 에서 추가적으로 해야할 작업은 없다.

다음은, Serailzer 를 확인해보자.

velog_series_01/dashboard/dashboard_core/serializers.py

class PostUserPostSerializer(serializers.ModelSerializer):

  class Meta:
    model = PostUser
    fields = ("username","password",)

  def validate_password(self, value):
    if len(value) < 7:
      raise serializers.ValidationError("The password has to be at least 7 characters long!")
    return value

간편하게 username 과 password 만 입력받게 하였으며, 덤으로 저번 포스팅에서 테스트로 작성하였던password는 7글자 이상으로 하지 않으면 검증에러가 나게끔 검증로직도 추가되어있다.

자, 마지막으로 urls.py 만 확인하고 테스트 해보자.

이미 DefaultRouter 를 사용하고 있기 때문에 POST로만 바꿔서 서버로 데이터를 송신하면 된다.

from dashboard_core.forms import PostUserForm

from rest_framework.routers import DefaultRouter
from dashboard_core.views import PostViewSet, PostUserViewSet

router = DefaultRouter()
router.register(r"posts", PostViewSet, basename="post_status")
router.register(r"users", PostUserViewSet, basename="user_status")

이제 서버를 올리고 다음과 같이 Request 를 해보자.

python manage.py runserver

password 를 7글자 이상으로 하고, 문제없이 처리되었다면 아래처럼 등록된 데이터가 클라이언트로 돌아온다.

우리 시스템에 잘 유저가 등록되어있는지 admin 페이지에서 확인해보자.

http://localhost:8000/admin/

DATABASE_CORE > Users 에 들어가 보면 방금 등록한 유저 데이터가 조회됨을 알 수 있다!

다음 포스팅에서는 Login 기능을 구현해보도록 한다.

Thank you!

Request Data 검증이 필요한 배경

이번 포스팅에서는 클라이언트로부터 Request 받은 데이터를 Model과 연계하기 전에 검증하는 방법에 대하여 알아보려 한다.

당연한 얘기지만, 클라이언트 단에서 어느정도 폼 데이터 검증을 거쳐서 서버로 전달되긴 하겠지만 100% 클라이언트에서 서버에서 원하는 형식으로 데이터가 온다고 보장할 수는 없다.

만에 하나, 서버에서 정의한 Model 형식대로 데이터가 오지 않을 경우에 원치 않은 에러가 나서 클라이언트로 에러 메시지가 올 가능성도 있고 오히려 에러가 나야 하는데 서버는 정상적인 데이터로 간주하여 Model 에 저장해버리는 상황도 있을 수 있다.

django 에서 Request 받은 데이터를 체크해주는 역할은 언제까지나 Model의 스키마 정의에 위반되었는지 아닌지 정도이다.

그 이상으로 체크해주지 않기 때문에 직접 개발자가 Request Data 검증로직을 추가해줘야 한다.

그럼 어떻게 추가해주면 될까?

Serializer에 검증 로직 추가하기

바로 Serializer 에 원하는 검증로직을 추가하면 된다.

여러가지 방법이 있지만, validate 메소드를 Overriding 해서 해결해보자.

지금까지는 PostUser Model에 대해서 API TEST 를 진행했지만

이번부터는 DashBoard의 게시글 데이터 모델인 Post 를 중심으로 테스트 해보자.

velog_series_01/dashboard/dashboard_core/serializers.py 파일을 열어보면 현재 최신 코드는 다음과 같을 것이다.

from rest_framework import serializers
from dashboard_core.models import Post, PostUser

class PostSerializer(serializers.ModelSerializer):
  title = serializers.CharField()
  contents = serializers.CharField()
  created_at = serializers.DateTimeField(read_only=True)

  class Meta:
    model = Post
    fields = "__all__"

여기에 validate 메소드를 Overriding 하자. 검증 시나리오는 Post Model의 title 데이터가 7글자 아래라면 에러가 나도록 해보자.

위의 코드에 바로 아래 줄에 다음과 같이 코드를 추가하자.

def validate(self, attrs):
    title_val = attrs['title']
    if len(title_val) < 7:
      raise serializers.ValidationError("Title has to be at least 7 characters long!")
    return attrs

Request 데이터 검증 테스트하기

이제 서버를 올리고, POST API로 새로운 포스트를 등록해보자.

1) 정상 데이터의 경우 Advanced REST client 툴을 넣고 아래처럼 Request 한다.

문제가 없다면, 아래처럼 정상적으로 등록되었다고 Response 가 올 것이다.

2) 정상 데이터가 아닌 경우 Advanced REST client 툴을 넣고 아래처럼 Request 한다.

Title이 7글자 보다 작은 데이터를 일부러 넘겨보자.

SEND 버튼을 누르면, 아래처럼 글자수가 부족하다고 메시지가 뜨면서 등록이 실패하게 된다.

이것으로 클라이언트에서 받은 데이터를 간단히 검증하는 법에 대해서 테스트 해보았다.

다음 포스팅에는 API 를 사용해서 로그인 / 로그아웃을 테스트 해보자.

Thank you!

유저정보 삭제 (DELETE) API 테스트 하기

본 포스팅에서는 PostUser Model의 데이터를 삭제하기 위해 DELETE API 를 테스트 해보기로 한다.

저번 포스팅에서도 작업하였듯이 API 를 작성하기 위해서 아래코드가 필요하다.

1. Router 작성 (URL 라우팅)

from dashboard_core.forms import PostUserForm

from rest_framework.routers import DefaultRouter
from dashboard_core.views import PostViewSet, PostUserViewSet

router = DefaultRouter()
router.register(r"posts", PostViewSet, basename="post_status")
router.register(r"users", PostUserViewSet, basename="user_status")

2. View 작성 (로직)

from rest_framework import response
from rest_framework.viewsets import ModelViewSet
from rest_framework.permissions import IsAuthenticatedOrReadOnly
from dashboard_core.models import Post, PostUser
from dashboard_core.serializers import PostSerializer, PostUserSerializer, PostUserGetSerializer, PostUserPostSerializer

# Create your views here.
class PostViewSet(ModelViewSet):
  queryset = Post.objects.all()
  serializer_class = PostSerializer
  permission_classes = [IsAuthenticatedOrReadOnly]

class PostUserViewSet(ModelViewSet):
  queryset = PostUser.objects.all()

  def get_serializer_class(self):
    if self.action == 'list':
      return PostUserSerializer
    elif self.action == 'create':
      return PostUserPostSerializer
    elif self.action == 'update':
      return PostUserPostSerializer
    elif self.action == 'delete':
      return PostUserPostSerializer
    else:
      return PostUserSerializer

3. Serializers 작성 (클라이언트에게 보내기 위해 데이터 처리)

from django.db.models import fields
from rest_framework import serializers

from dashboard_core.models import Post, PostUser

class PostSerializer(serializers.ModelSerializer):
  title = serializers.CharField()
  contents = serializers.StringRelatedField()
  created_at = serializers.DateTimeField()

  class Meta:
    model = Post
    fields = "__all__"

class PostUserSerializer(serializers.ModelSerializer):
  username = serializers.CharField()

  class Meta:
    model = PostUser
    fields = "__all__"

class PostUserGetSerializer(serializers.ModelSerializer):
  username = serializers.CharField()

  class Meta:
    model = PostUser
    fields = ("id", "username", "password",)

class PostUserPostSerializer(serializers.ModelSerializer):

  class Meta:
    model = PostUser
    fields = ("username","password",)

  def validate_password(self, value):
    if len(value) < 7:
      raise serializers.ValidationError("The password has to be at least 7 characters long!")
    return value

위처럼 기본적인 위의 코드는 이미 들어가 있으므로

우리는 테스트만 해보면 될 것이다.

서버를 다음 커맨드와 같이 올린다.

python manage.py runserver

그리고 Advanced REST client 를 열고 아래와 같이 작성한다.

보내고 나면 현재 데이터를 알 수 있다.

나온 데이터들 중, id 가 4인 데이터가 존재한다.

이제부터 위 아이디에 해당하는 데이터를 지워보겠다.

위처럼 DELETE Request를 작성하고 전송하면 아래처럼 메시지가 돌아온다.

자, 실제 데이터를 다시 한번 확인해보자.

4번째 아이디를 가진 데이터가 삭제되었음을 알 수 있다.

Thank you!

유저정보 변경 (PUT, PATCH) API 테스트 하기

지금까지 PostUser Model에 대하여 데이터를 가져오는 GET API와, 새로운 데이터를 등록하는 POST API에 대해서 테스트 하였다.

본 포스팅에서는 기존 데이터를 편집하는 PUT, PATCH API에 대하여 테스트를 해보겠다.

저번 포스팅에서도 언급하였지만, 우리가 현재 API 개발에 기초로 두고 있는 클래스는 ModelViewSet 이다.

이 클래스 안에서 기본적인 API에 대해서 내부적으로 이미 개발이 되어 있기 때문에 세세한 사양변화의 Customizing 작업이나, 특별한 처리를 추가하고 싶을때를 제외하면 추가 개발은 딱히 필요 없다.

우리가 신경써야 할 부분은 API 에서 처리할 대상을 어떻게 추릴 것이며, 클라이언트에게 돌려줄 데이터를 어떻게 정의할 것인가 에 해당하는 Serializer 를 용도에 맞게 끔 수정해야 한다는 점이다.

일단 간단하게, 신규 등록은 ID, Password 정보로만 테스트 해보자.

프로젝트 폴더 아래에 dashboard_core/views.py 파일을 열고 아래와 같이 편집한다.

class PostUserViewSet(ModelViewSet):
  queryset = PostUser.objects.all()

  def get_serializer_class(self):
    if self.action == 'list':
      return PostUserSerializer
    elif self.action == 'create':
      return PostUserPostSerializer
    elif self.action == 'update':
      return PostUserPostSerializer
    elif self.action == 'delete':
      return PostUserPostSerializer
    else:
      return PostUserSerializer

이것으로 각 API에 따라서 다른 Serializer를 정의하였다.

이제부터 딱히 소스를 만질 필요는 없지만, 간단히 유저가 요청할때부터 응답을 받을 때까지의 흐름에 대해서 다시 정리해보자.

1. 유저가 원하는 API로 데이터와 함께 서버에게 리퀘스트 요청을 한다.

2. django 의 urls.py 파일(DefaultRouter) 에서 유저 요청을 분석하여 처리를 어느 View 클래스로 분기시킬지 결정한다.

3. 해당 View 클래스에서 action에 맞게 데이터 처리를 시행한다.

action 이란, ModelViewSet 클래스 기준으로 create, retrieve, update, partial_update, destroy, list 의 총 6가지로 나뉜다.

4. 처리가 끝난 데이터는 Serializer 에 의해, JSON 형태로 클라이언트에 돌려진다.

이상, 처리 Cycle은 끝이다.

django와 restframework 에서 내부적으로 처리해주는 부분이 많기 때문에 이해가 힘들수도 있겠지만 그럴수록 더 흐름에 대해서 만큼은 빠삭하게 알고 있어야 한다.

자, 본격적으로 기존 데이터를 PUT API를 이용하여 수정해보자.

서버를 실행하자.

python manage.py runserver

이어서 Advanced REST Client 를 열고, 아래와 같이 GET API를 리퀘스트 한다.

결과는 아래와 같다.

위와 같이 현재 데이터가 확인되었으니 id가 3인 데이터(username: test1, password: 123123123)를 아래와 같이 수정해보도록 하자.

{
  "username": "test3",
  "password": "4564567"
}

아래와 같이 PUT API 리퀘스트 양식을 작성한다.

전송해서 성공하면, 아래처럼 서버로부터 갱신된 데이터를 클라이언트로 반환시켜준다.

리퀘스트 요청대로 잘 처리되었음을 알 수 있다.

이어서, 부분적인 데이터만 수정하는 PATCH API를 테스트해보자.

방금전에 수정했던 데이터의 username 필드만 수정해보겠다.

아래와 같이 리퀘스트를 작성한다.

SEND 버튼을 눌러서 서버에 리퀘스트하면, 변경사항이 반영된 전체 PostUser Model의 데이터가 반환됨을 알 수 있다.

지금까지 수정 API인 PUT과 PATCH를 각각 테스트 해보았다.

여기서 POST API 와의 차이점에 대해서 간단히 정리해보겠다.

Serailizer 에 정의된 모든 필드를 다 서버에 넘겨줘야만 하는 POST API라면, 정의된 필드중에서 수정하고싶은 몇개 필드만 넘기고 싶을 때에는 PATCH API를 사용한다고 보면 이해가 쉽다.

다음 포스팅에는 삭제하는 DELETE API에 대하여 테스트 해보도록 한다.

Thank you!

유저등록 POST API 테스트 하기

유저에 대한 CRUD API를 계속해서 작성해보도록 하자.

이번에는 유저등록 부분이다. POST API 테스트를 해보도록 하자!

저번 포스팅에서 이미 모든 CRUD API 가 포함된 ModelViewSet 클래스를 상속하여 View를 생성했었기 때문에 POST API 테스트를 위해서 추가 작업은 필요하지 않다.

하지만, 현재 PostUserViewSet View 클래스는 PostUser Model의 모든 데이터를 반환하기 때문에 효율적이지 않다. 필요한 데이터만 클라이언트에게 받아서 회원등록 POST API 을 테스트 해보자.

일단 PostUser Model의 Serializer 를 POST API 용으로 하나 더 만들자.

velog_series_01/dashboard/dashboard_core/serializer.py 파일을 열고, 아래와 같이 PostUserPostSerializer 클래스를 추가한다.

class PostUserPostSerializer(serializers.ModelSerializer):

  class Meta:
    model = PostUser
    fields = ("username","password",)

위 코드에서 확인할 수 있듯이 PostUser Model 신규데이터 등록에 필요한 필드는 POST API 테스트를 보다 간편하게 만들기 위해서 username 과 password 으로만 제한하였다.

위 코드를 추가한 후에 serializer.py 파일의 전체 코드는 아래와 같다.

from django.db.models import fields
from rest_framework import serializers

from dashboard_core.models import Post, PostUser

class PostSerializer(serializers.ModelSerializer):
  title = serializers.CharField()
  contents = serializers.StringRelatedField()
  created_at = serializers.DateTimeField()

  class Meta:
    model = Post
    fields = "__all__"

class PostUserSerializer(serializers.ModelSerializer):
  username = serializers.CharField()

  class Meta:
    model = PostUser
    fields = "__all__"

class PostUserPostSerializer(serializers.ModelSerializer):

  class Meta:
    model = PostUser
    fields = ("username","password",)

마지막으로 views.py 파일을 열어서 PostUserViewSet 클래스를 아래와 같이 수정하여 PostUserPostSerializer 클래스를 추가한다.

class PostUserViewSet(ModelViewSet):
  queryset = PostUser.objects.all()

  def get_serializer_class(self):
    if self.action == 'create':
      return PostUserPostSerializer
    else:
      return PostUserSerializer

위 코드를 적용함으로써 클라이언트로부터 POST 요청이 오면, ModelViewSet 클래스에 적용하는 Serializer 클래스를 PostUserPostSerializer 로 바꿔준다.

이제 Advanced REST client 로 아래와 같이 POST 로 유저등록 데이터와 함께 Request 를 보낸다.

아래처럼 서버로부터 201 OK 메시지가 도착하였다. 정상처리가 되었음을 의미한다!

이제 직접 웹브라우저에서 방금 추가한 유저정보가 로드되는지 확인해보자.

http://127.0.0.1:8000/users/

아래에서 우리가 방금 추가했던 유저정보가 등록되어있음을 알 수 있다!

이번 포스팅에서는 PostUser Model의 POST API 테스트를 해보았다.

다음에는 이어서 UPDATE API 테스트에 대해서 알아보겠다.

Thank you!

유저등록 GET API 테스트 하기

이번 포스팅부터는 본격적으로 유저에 대해 CRUD API를 작성해보도록 하자.

처음은 유저조회 부분이다. 즉, GET API 테스트를 해보자.

일단 PostUser Model에 대한 Serializer 를 개발한다.

velog_series_01/dashboard/dashboard_core/serializers.py 파일을 열어 아래와 같이 추가한다.

from rest_framework import serializers

from dashboard_core.models import Post, PostUser

class PostSerializer(serializers.ModelSerializer):
  title = serializers.CharField()
  contents = serializers.StringRelatedField()
  created_at = serializers.DateTimeField()

  class Meta:
    model = Post
    fields = "__all__"

class PostUserSerializer(serializers.ModelSerializer):
  username = serializers.CharField()

  class Meta:
    model = PostUser
    fields = "__all__"

그리고 같은 위치의 views.py 파일에 CRUD API가 포함되어 있는 ModelViewSet 클래스를 상속하여 아래와 같이 추가해준다.

from rest_framework.viewsets import ModelViewSet
from rest_framework.permissions import IsAuthenticatedOrReadOnly
from dashboard_core.models import Post, PostUser
from dashboard_core.serializers import PostSerializer, PostUserSerializer

# Create your views here.
class PostViewSet(ModelViewSet):
  queryset = Post.objects.all()
  serializer_class = PostSerializer
  permission_classes = [IsAuthenticatedOrReadOnly]

class PostUserViewSet(ModelViewSet):
  queryset = PostUser.objects.all()
  serializer_class = PostUserSerializer

위 작업으로, CRUD API가 자동으로 추가된다. 이해가 되지 않는다면, ModelViewSet 클래스를 살펴보자.

class ModelViewSet(mixins.CreateModelMixin,
                   mixins.RetrieveModelMixin,
                   mixins.UpdateModelMixin,
                   mixins.DestroyModelMixin,
                   mixins.ListModelMixin,
                   GenericViewSet):
    """
    A viewset that provides default `create()`, `retrieve()`, `update()`,
    `partial_update()`, `destroy()` and `list()` actions.
    """
    pass

위에서 보다시피

C(mixins.CreateModelMixin), R(mixins.RetrieveModelMixin, mixins.ListModelMixin), U(mixins.UpdateModelMixin), D(mixins.DestroyModelMixin)

4가지의 API 처리가 이미 포함되어 있음을 알 수 있다.

이제 마지막은 urls.py 파일에 PostUser Model에 대한 URL을 DefaultRouter 을 이용해서 추가한다.

router = DefaultRouter()
router.register(r"posts", PostViewSet, basename="post_status")
router.register(r"users", PostUserViewSet, basename="user_status")

드디어 GET API 를 테스트 할 준비가 되었다.

서버를 가동한 다음,

python manage.py runserver

Advanced REST Client 같은 API Client Test Tool을 열어서 GET API로 리퀘스트를 설정한다.

SEND 를 눌러서 Response 객체를 확인한다. 아래처럼 현재의 유저정보 로드에 성공하였다!

서버 로그를 보면, 200 OK 정상 처리가 됬음을 확인할 수 있다.

이것으로 GET API 처리가 잘 되는지 테스트 해보았다.

다음 포스팅에서는 이어서 POST API 에 대해서 테스트 해보겠다.

Thank you!

유저 등록 가상 폼 작성과 View 연계

오늘 포스팅은, 직전 포스팅에 이어서 유저 등록 가상 폼을 작성하여 PostUser View와 연계해보도록 하겠다.

velog_series_01/dashboard/dashboard_core 아래에 forms.py 파일을 신규 생성한다.

그리고 다음과 같이 작성한다.

from django_registration.forms import RegistrationForm
from dashboard_core.models import PostUser

class PostUserForm(RegistrationForm):

  class Meta(RegistrationForm.Meta):
    model = PostUser

가상 폼 포맷은 작성하였으니 URL에 가상 폼을 등록하자.

velog_series_01/dashboard/dashboard 에서 urls.py 을 열고 아래와 같이 추가해주자.

 .
 .
 .
from django_registration.backends.one_step.views import RegistrationView
from dashboard_core.forms import PostUserForm
 .
 .
 .

urlpatterns = [
 .
 .
 .
    path('accounts/register/', RegistrationView.as_view(
            form_class=PostUserForm,
            success_url='/'
        ), name='django_registration_register'),
 .
 .
 .
]

다음으로 settings.py 파일에서 로그인 / 아웃 후에 자동 다이렉트 페이지 URL을 추가해준다.

  .
  .
  .
USE_L10N = True

USE_TZ = True

LOGIN_URL = "accounts/login/"
LOGIN_REDIRECT_URL = "/"
LOGOUT_REDIRECT_URL = "/"

# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/3.2/howto/static-files/

STATIC_URL = '/static/'

  .
  .
  .

다음으로, 로그인 기능 관련해서 페이지에 간단히 로그인 정보를 표시해줄 template 을 만들어 보자.

velog_series_01/dashboard/dashboard 폴더 아래에 아래와 같이 폴더와 파일을 만든다.

• dashboard (velog_series_01/dashboard/dashboard)
• • templates (폴더)
• • -- django_registration (폴더)
• • -- -- registration_form.html (파일)
• • -- registration (폴더)
• • -- -- login.html (파일)
• • -- auth_layout.html (파일)

그리고 settings.py 에서 TEMPLATES > DIRS 에 templates 폴더 패스를 등록한다.

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [BASE_DIR / 'dashboard' / 'templates'],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
                'django.template.context_processors.debug',
                'django.template.context_processors.request',
                'django.contrib.auth.context_processors.auth',
                'django.contrib.messages.context_processors.messages',
            ],
        },
    },
]

이제 templates 폴더의 아래 3개 파일을 아래와 같이 작성한다. auth_layout.html registration_form.html login.html

1. auth_layout.html

<html>
  <head>
    <meta charset="utf-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge" />
    <meta name="description" content="" />
    <meta name="viewport" content="width=device-width, initial-scale=1" />
    <title>Post</title>
    <link rel="stylesheet"
    href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.7/css/bootstrap.min.css"
    integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u"
    crossorigin="anonymous/>
    <style>
      .login-form-container {
        width: 300px;
        margin: auto;
      }

      .registration-form-container {
        width: 400px;
        margin: auto;
      }
    </style>
  </head>
  <body>
    <div class="auth-box text-center">{% block content %} {% endblock %}</div>
  </body>
</html>

2. registration_form.html

{% extends 'auth_layout.html' %} {% load crispy_forms_tags %} {% block content%}
<h1>Create your account</h1>
<div class="registration-form-container">
  <form method="POST">
    {% csrf_token %} {{ form|crispy }}
    <button type="submit" class="btn btn-sm btn-outline-primary">
      Create an user
    </button>
  </form>
</div>
{% endblock %}

3. login.html

{% extends 'auth_layout.html' %} {% load crispy_forms_tags %} {% block content
%}
<h1>Login</h1>
<div class="login-form-container">
  <form method="POST">
    {% csrf_token %} {{ form|crispy }}
    <button type="submit" class="btn btn-sm btn-outline-primary">Login</button>
  </form>
</div>
{% endblock %}

위의 파일들을 저장하고, 서버를 올려서 아래 URL로 접근해보자.

python manage.py runserver

http://127.0.0.1:8000/accounts/register/

아래처럼 회원등록 폼이 나타나면 성공이다!

위에 화면에서 한번 회원등록을 해보자.

등록하자마자, http://127.0.0.1:8000/ 페이지로 리다이렉트 된다.

우상단 화면에 방금전에 가입한 Username 이 표시됨을 알수있다.

자, 실제로 유저관리화면에 추가되었는지 확인해보자.

아래 admin 계정으로 관리화면에 로그인 해보자.

http://127.0.0.1:8000/admin

Users Model 을 조회해보자. 아래처럼, 방금 추가한 Username 이 존재함을 알 수 있다.

이것으로 가상폼이긴 하나, 유저 모델을 추가해서 django 프로젝트의 Post 모델과 연계하여 보았다.

다음 포스팅에서는 실제API로 확장해서, 클라이언트에서 직접 Request 로 받아서 처리 하는 로직을 작성해보겠다.

Thank you!

유저 모델 등록

이번 포스팅에서는 유저 등록하는 부분을 가상 폼을 이용해서 만들어 보자.

처음에 해야 할 부분은 Model에 유저정보 모델 (PostUser) 을 추가하는 것이다.

velog_series_01/dashboard/dashboard_core/models.py 파일을 열고 다음을 추가한다.

# 유저 Model을 정의한다
class PostUser(AbstractUser):
  pass

코드를 추가한 models.py 파일은 다음과 같다.

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

# Create your models here.

# DashBoard 게시글 Model을 정의한다
class Post(models.Model):
  title = models.CharField(max_length=60)
  contents = models.TextField()
  created_at = models.DateTimeField(auto_now_add=True)

# 유저 Model을 정의한다
class PostUser(AbstractUser):
  pass

다음으로 유저를 인증하기 위한 Model을 settings.py 파일 마지막줄에 아래와 같이 추가한다.

AUTH_USER_MODEL = 'dashboard_core.PostUser'

이어서 admin.py 파일을 열고, django 의 admin 내장 모듈에 방금전에 추가했던 유저정보 모델 PostUser 을 추가한다.

from django.contrib import admin
from django.contrib.auth.admin import UserAdmin
from dashboard_core.models import Post, PostUser

class CustomUserAdmin(UserAdmin):
  model = PostUser
  list_display = ["username", "email", "is_staff"]

# Register your models here.
admin.site.register(Post)
admin.site.register(PostUser, CustomUserAdmin)

기본적인 작업은 이것으로 끝이다.

하지만, PostUser Model을 추가했기 때문에 다시 migration 을 해줘야 한다. 다음 커맨드를 실행한다.

python manage.py migrate

지금까지 django 에 Post Model과 연계하기 위한 User Model을 만들어보았다.

이제는 인증 모듈과 연계할 차례다.

다음 커맨드로 유저 인증처리 / 유저 등록에 필요한 패키지를 설치한다.

pip install django-rest-auth

pip install django-allauth

pip install django-registration

pip install django-crispy-forms

설치가 다 되었다면, settings.py 파일의 INSTALLED_APPS 배열에 추가한다.

추가한 최종 코드는 아래와 같다.

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'django.contrib.sites',

    'rest_framework',
    'rest_framework.authtoken',

    'allauth',
    'allauth.account',
    'allauth.socialaccount',

    'rest_auth',
    'rest_auth.registration',

    'crispy_forms',

    'dashboard_core',
]

그리고 settings.py 파일의 맨 아랫줄에 유저등록 폼 template / 인증관련 설정을 추가해준다.

# django-crispy-forms
CRISPY_TEMPLATE_PACK = "bootstrap4"

# django-allauth
ACCOUNT_EMAIL_VERIFICATION = "none"
ACCOUNT_EMAIL_REQUIRED = (True)

방금 설치한 패키지가 django Model에 영향을 주기 때문에, 다시 한번 migrate 를 실행하자.

python manage.py migrate

migrate 작업이 완료되었다.

이제 설치된 유저인증 패키지를 Request URL과 연결시키기 위해 urls.py 파일에 추가해준다.

추가한 후에 urls.py 의 전체 소스는 다음과 같다.

from django.contrib import admin
from django.urls import include, path
from rest_framework.routers import DefaultRouter
from dashboard_core.views import PostViewSet

router = DefaultRouter()
router.register(r"posts", PostViewSet, basename="post_status")

urlpatterns = [
    path('', include(router.urls)),
    path('admin/', admin.site.urls),
    path('accounts/', include('django.contrib.auth.urls')),
    path('api-auth/', include('rest_framework.urls')),
    path('rest-auth/', include('rest_auth.urls')),
    path('rest-auth/registration/', include('rest_auth.registration.urls')),
]

이것으로 유저 인증 / 등록에 관련된 패키지의 설치 및 우리의 django > dashboard 프로젝트, 앱에 연계관련하여 개발을 진행하였다.

다음 포스팅에서는 실제로 가상 유저등록 Form 을 만들어보도록 하겠다.

Thank you!

User 회원등록 / 로그인 기능을 추가하자

django 에서는 restframework 라는 API 개발 라이브러리를 추가하여 간단히 회원관련 기능을 만들 수 있다.

먼저 필요한 라이브러리를 pip 커맨드를 이용하여 설치한다.

아래 커맨드를 실행한다.

pip install django-allauth pip install django-rest-auth

문제 없이 설치되었다면 settings.py 에서 아래 앱들을

    'allauth',
    'allauth.account',
    'allauth.socialaccount',
    'rest_auth',
    'rest_auth.registration',

INSTALLED_APPS 배열에 추가하자

# Application definition

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'django.contrib.sites',

    'rest_framework',

    'allauth',
    'allauth.account',
    'allauth.socialaccount',
    'rest_auth',
    'rest_auth.registration',

    'dashboard_core',
]

다음으로는, User가 접근할 회원가입 관련 URL을 매핑해준다.

velog_series_01/dashboard/dashboard/urls.py 파일을 열고 아래와 같이 편집한다.

from django.contrib import admin
from django.urls import include, path
from rest_framework.routers import DefaultRouter
from dashboard_core.views import PostViewSet

router = DefaultRouter()
router.register(r"posts", PostViewSet, basename="post_status")

urlpatterns = [
    path('', include(router.urls)),
    path('admin/', admin.site.urls),
    path('api-auth/', include('rest_framework.urls')),
    path('rest-auth', include('rest_auth.urls')),
    path('rest-auth/registration', include('rest_auth.registration.urls')),
]

이제 회원가입에 관련된 앱들도 설치했고 자동으로 해당하는 모델이 추가되었기 때문에, DB와 sync를 맞추기 위해 Migrate 가 필요하다.

아래 커맨드를 실행하자.

python manage.py migrate

무사히 성공한다!

마지막으로 settings.py 파일 맨 아래에 회원 인증 방식에 대한 설정과, site 번호를 넣어준다.

REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework.authentication.SessionAuthentication',
        'rest_framework.authentication.TokenAuthentication',
    ]
}

SITE_ID = 1

이제 서버를 실행하고, http://127.0.0.1:8000/ 에 접속해보자.

오른쪽 상단에 Login 버튼에 생겼다. 버튼을 눌러, 관리자 계정으로 로그인 해보자.

로그인 한뒤에, Post URL로 이동해보자.

아래를 보면 회원 로그인이 된 상태여서, Post Model에 새로운 게시글을 작성할 수 있게 되었다.

다음 포스팅에서는, 유저를 등록할 수 있는 화면을 간단히 구성해보고 이를 Post Model 등록 권한과 연계하면서 CRUD API를 만들어 보도록 하자.

Thank you!

Serializer는 무엇인가?

저번 시간에는 Post Table에 대한 View를 만들어서, 누구라도 data를 조회할 수 있도록 유저의 Request로 온 URL로 연결시켰다.

그러나, 서버를 가동시킨 후에 우리가 설정했던 URL http://localhost:8000/posts/ 로 들어가보니 아래와 같이 에러가 나버린다.... -_-;;

↓ Serializer 가 존재하지 않는다고 에러가 난다.

..그렇다면 Serializer가 없으면 왜 에러가 날까?

일단 Serailizer 개념에 대해서 알아보자.

말 그대로 직렬화 라는 뜻인데, 크게 2가지 기능을 한다.

1. 유저에서 받아온 데이터를 django 에서 처리할 수 있는 (Python 언어가 다룰 수 있는) 데이터 형으로 변환해 주는 기능을 한다고 이해하면 된다.

django [Model, QuerySet, Instance...] <----> Content[JSON, XML...]

2. 보통 웹 애플리케이션은 유저에서 받은 데이터를 처리 한 후에, 서버가 유저의 화면에 뿌려 줄 데이터를 Response 객체와 함께 붙여서 유저에게 전송하는데 그때 보낼 데이터가 정의된 타입과 일치하는지 1차적으로 검증을 하는 역할을 한다.

검증하는 법은, Serializer 클래스에 기본적으로 포함되어 있는 is_valid() 함수를 이용하면 되는데 다음 포스팅에서 더 알아볼 것이다. 지금은 개념만 이해하고 넘어가도록 하자.

지금까지 Serializer 의 기본적인 정의에 대해서 알아보았다.

간단히 유저에서 받은 데이터가 어떻게 유저에게 다시 돌려지는지 django 의 처리흐름을 정리하고 넘어가자.

django 에서의 데이터 처리 Flow

0. django 서버에 Request가 들어옴

1. url.py 에서 유저가 접속한 URL 주소를 파싱해서 해당하는 View를 호출한다

2. View에서 링크된 DB Table 에서 데이터를 가져온다

3. 유저 요청에 따라 해당하는 Python 로직을 작성하여, 데이터를 가공한다. 필요에 따라서는 View를 이용해 CRUD 처리를 한다.

4. 유저에게 전송하기 전에 Serializer 클래스로 데이터를 검증한다

5. 유저에게 전송할 데이터를 클라이언트의 Content 타입(JSON, XML..)으로 Serializer 클래스를 사용해서 변환한다

6. 유저에게 보낼 데이터를 Response 객체에 붙여서 같이 전송한다

Serializer를 정의하자

이제 본격적으로, Serializer 를 정의하자.

dashbord_core 폴더 안에서, serializers.py 파일을 생성하고 아래와 같이 작성하고 저장한다.

velog_series_01/dashboard/dashboard_core/serializers.py

from rest_framework import serializers
from dashboard_core.models import Post

class PostSerializer(serializers.ModelSerializer):
  title = serializers.CharField()
  contents = serializers.StringRelatedField()
  created_at = serializers.DateTimeField()

  class Meta:
    model = Post
    fields = "__all__"

위 코드로 기본적인 Post Model에 대한 Serializer 클래스를 등록했으니 View에 연동시켜줘야 한다.

아래 코드 파일을 열고, Serializer class 를 추가해주자. 추가한 최종코드는 아래와 같다.

velog_series_01/dashboard/dashboard_core/views.py

from rest_framework.viewsets import ModelViewSet
from rest_framework.permissions import IsAuthenticatedOrReadOnly
from dashboard_core.models import Post
from dashboard_core.serializers import PostSerializer

# Create your views here.
class PostViewSet(ModelViewSet):
  queryset = Post.objects.all()
  serializer_class = PostSerializer
  permission_classes = [IsAuthenticatedOrReadOnly]

고생이 많으셨다.

이제 다시 서버를 올리고, http://127.0.0.1:8000/ 에 접속해보자.

저번 포스팅에서 등록했던 Default Router 의 메인 페이지가 표시된다.

자, 처음에 시도했었다 실패했었던 http://127.0.0.1:8000/posts/ 에 접근해보자.

위와 같이 에러없이 Post Model의 데이터 리스트 화면이 표시된다면, 성공한 것이다!

다음 포스팅에서는 Serailizer 까지 등록하였으니 본격적으로 데이터의 CRUD 처리를 확장시켜보자.

Thank you!

[Post] Model의 데이터를 조회하자!

저번 포스팅에서는 SuperUser 를 만들어서, django 프로젝트 안에 속해 있는 Model에 접근해 보았다.

그러나, 관리자권한으로 로그인하지 않으면 Model의 데이터를 볼 수 없었기 때문에 모두에게 보여줄 수 없는 부분을 개선해야 한다.

오늘은 이 문제를View를 만들어서 해결해보자.

django에서 View는 클라이언트에서 받은 요청에 따라 DB Tier (Model) 과 연결시켜서 필요한 데이터를 조회, 수정, 등록, 삭제하도록 중계하는 역할을 한다.

쉽게 말해서, 서버에서 데이터를 처리하는로직 부분이라 할 수 있다.

우리가 지금까지 DashBoard 프로젝트를 진행하면서 Model 과 Admin 만 생성했기 때문에, 데이터를 실제적으로 처리하고 클라이언트에게 돌려주는 부분이 없었다고 생각하면 된다.

자, 지금부터 본격적으로 View를 만들어 보자. velog_series_01/dashboard/dashboard_core/views.py 를 코드 에디터로 열고 아래와 같이 작성하자.

from rest_framework.viewsets import ModelViewSet
from rest_framework.permissions import IsAuthenticatedOrReadOnly
from dashboard_core.models import Post

# Create your views here.
class PostViewSet(ModelViewSet):
  queryset = Post.objects.all()
  permission_classes = [IsAuthenticatedOrReadOnly]

Post Model 전용 View를 만들기 위해, PostViewSet 이라는 Python 클래스를 정의하는 코드이다.

이어서, 유저가 접근할 URL 패턴을 정의하자. velog_series_01/dashboard/dashboard/urls.py 파일을 코드 에디터로 열고, 다음과 같이 작성하자.

from django.contrib import admin
from django.urls import include, path
from rest_framework.routers import DefaultRouter
from dashboard_core.views import PostViewSet

router = DefaultRouter()
router.register(r"posts", PostViewSet, basename="post_status")

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

원래는 서버에 업로드 한 후에 http://localhost:8000 으로 접속하면 로켓 애니메이션이 표시되는 index 페이지로 다이렉트 하였으나, 그 부분을 우리가 만들었던 Post Model의 조회 페이지 /posts 로 보여주고 싶은 것이다.

여기까지 되었으면 기본적인 설정은 끝난 것이다.

django 서버를 올린 다음, http://localhost:8000 으로 접속해보자.

다음과 같이 라우팅 설정이 되었음을 알 수 있다.

이어서 다음 포스팅에서는 본격적으로 Model의 Data를 보여주는 페이지를 만들어 보겠다.

Thank you!