on August 22, 2018 under django

18 minute read

Build a REST API with Django – A Test Driven Approach: Part 2

Build a REST API with Django – A Test Driven Approach: Part 2의 포스팅을 번역한 것입니다.

The precondition to freedom is security – Rand Beers

인증은 API 보안의 가장 중요한 부분입니다.

Table of Content

구현하기
Refactoring Our Tests
How To Pass Those Tests!
What about Token-based Authentication?
Run it
Conclusion

Django 기반 bucketlist API에서 사용자를 인증하고 권한을 부여하는 방법에 대해 다룹니다.

Authentication(인증) vs Authorization(승인)

Authentication(인증)은 일반적으로 Authorization(승인)와 혼동됩니다. 절대 같은 것이 아닙니다.

인증은 누군가의 신원을 확인하는 방법으로 생각할 수 있습니다.(사용자 이름, 암호, 토큰, 키 등)과 권한 부여(승인)는 인증된 사용자에게 부여되어야하는 엑서스 수준 을 결정하는 방법입니다.

bucketlist API를 살펴보면 대부분의 경우 작동합니다. 그러나 bucketlist을 만든 사람, 처음에 지정된 사용자가 인증되었는지 또는 bucketlist에 변경 내용을 적용 할 권한이 있는지 여부와 같은 기능은 없습니다. 그것을 고쳐야 합니다.

먼저 인증을 구현하고 나중에 일부 인증 기능을 삭제합니다.

구현하기

DRF API에서 인증을 구현할 수 있습니다. 먼저 사용자를 추적하여 시작합니다.

어떻게 해야 할까요? Django는 우리가 사용할 수 있는 기본 사용자 모델을 제공합니다.

Bucketlist 모델에 owner 필드를 만듭니다. 사용자가 bucklist을 만드는데, bucketlist은 소유자가 있다는 것을 의미합니다. 따라서 bucketlist 모델에 사용자의 필드 정의를 추가하기만 하면 됩니다.

# api/models.py

from django.db import models

class Bucketlist(models.Model):
    name = models.CharField(max_length=255, blank=False, unique=True)
    owner = models.ForeignKey('auth.User',  # ADD THIS FIELD
    related_name='bucketlists',
    on_delete=models.CASCADE)
    date_created = models.DateTimeField(auto_now_add=True)
    date_modified = models.DateTimeField(auto_now=True)

    def __str__(self):
        return "{}".format(self.name)

owner 필드는 여러 인수를 허용하는 ForeignKey 클래스를 사용합니다. 첫 번째 ‘auth.User’는 관계를 만들려는 모델 클래스를 가리킵니다.

ForeignKey는 모델 클래스인 ‘auth.User’에서 가져와서 User와 Bucketlist 모델 간의 관계를 설정합니다.

이 작업을 하면 데이터베이스에 반영하기 위해 마이그레이션을 실행해야 합니다.

$ python  manage.py  makemigrations api

기존 테이블에 새 필드를 쓸 때 다음과 같은 선택지가 나옵니다.

데이터베이스는 null이 아니거나 non-nullable field를 추가하려고 한다고 불평합니다. 데이터베이스에 대한 기존 데이터가 있으므로 값을 입력해야합니다. 간단한 해결법은 ‘db.sqlite3’파일과 마이그레이션 디렉토리를 삭제하는 것입니다. 이렇게 하면 … 데이터베이스를 지우는 것이니.. 초기화됩니다. 이렇게 항상 새로운 것으로 시작할 수 있습니다. 하지만 모든 DB 데이터를 지우기 때문에 Prod 환경에서는 절대 해서는 안됩니다. 이를 더 깔끔하게 수정하는 방법은 일회성 기본값을 제공하는 것입니다. 물론 DB에 대한 기록이 없다면 삭제해도 됩니다.

이렇게 한 다음 migrate 명령을 사용하여 DB에 변경 사항을 커밋합니다.

$ python manage.py migrate

Refactoring Our Tests

지금까지는 새로운 사용자 인증과 함께 작동하는 테스트를 작성하지 않았습니다. 따라서 기존 테스트 케이스를 리펙터링해야 합니다.

우선, 무엇을 써야하는지 알고 있어야 합니다.

사용자에 의한 Bucketlist 소유권 - 기본 Django 사용자 모델 통합을 나타냅니다.
인증 된 사용자가 요청을 했는지를 확인합니다. 즉, HTTP 요청을 보내기 전에 인증을 해야 합니다.
bucketlist 작성을 인증 된 사용자만 하도록 제한합니다.
기존 bucketlist을 소유자만 엑세스 할 수 있도록 제한합니다.

이 점들은 테스트를 리펙터링하도록 유도하는데 도움이 됩니다.

ModelTestCase Refactoring

기본 사용자 모델(django.contrib.auth.User)을 테스트 모듈에 가져와 사용자를 만듭니다.

# api/tests.py
from django.contrib.auth.models import User

setUp 메소드에서 User를 생성할 것이므로 테스트할 떄마다 사용자를 생성 할 필요가 없습니다.

class ModelTestCase(TestCase):

    def setUp(self):
        """테스트 클라이언트과 다른 테스트 변수를 정의합니다."""
        user = User.objects.create(username="nerd") # ADD THIS LINE
     self.name = "Write world class code"
        # bucketlist을 owner를 지정합니다.
        self.bucketlist = Bucketlist(name=self.name, owner=user) # EDIT THIS TOO

setUp 메소드에서 사용자 이름을 가진 사용자를 생성하여 태스트 사용자를 정의했습니다. 그 다음 사용자의 인스턴스를 bucketlist 클래스에 추가했습니다. 이제 사용자는 해당 bucketlist의 소유자가 됩니다.

ViewsTestCase Refactoring

뷰는 주로 요청을 처리하기 때문에 인증되고 권한이 부여된 사용자만 bucketlist API에 엑서스 할 수 있습니다.

# rest_api/tests.py
# import fall here

# Model Test Case is here

class ViewTestCase(TestCase):
    """api views를 위한 Test suite"""

    def setUp(self):
        """ 테스트 클라이언트와 다른 테스트 변수를 정의합니다."""
        user = User.objects.create(username="nerd")

        # 클라이언트 초기화와 인증 강제 사용
        self.client = APIClient()
        self.client.force_authenticate(user=user)

        # 사용자 모델 인스턴스는 직렬화할 수 없으므로 해당 ID/PK를 사용합니다.
        self.bucketlist_data = {'name': 'Go to Ibiza', 'owner': user.id}
        self.response = self.client.post(
            reverse('create'),
            self.bucketlist_data,
            format="json")

    def test_api_can_create_a_bucketlist(self):
        """ api에 버킷 생성 기능이 있는지 테스트합니다. """
        self.assertEqual(self.response.status_code, status.HTTP_201_CREATED)

    def test_authorization_is_enforced(self):
        """api에 사용자 권한이 있는지 테스트합니다."""
        new_client = APIClient()
        res = new_client.get('/bucketlists/', kwargs={'pk': 3}, format="json")
        # self.assertEqual(res.status_code, status.HTTP_403_FORBIDDEN)
        self.assertEqual(res.status_code, status.HTTP_401_UNAUTHORIZED)

    def test_api_can_get_a_bucketlist(self):
        """"API가 주어진 bucketlist을 얻을 수 있는지 테스트합니다."""
        bucketlist = Bucketlist.objects.get(id=1)
        response = self.client.get(
            '/bucketlists/',
            kwargs={'pk': bucketlist.id}, format="json")

        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertContains(response, bucketlist)

    def test_api_can_update_bucketlist(self):
        """API가 특정 bucketlist을 업데이트 할 수 있는지 테스트합니다."""
        bucketlist = Bucketlist.objects.get()
        change_bucketlist = {'name': 'Something new'}
        res = self.client.put(
            reverse('details', kwargs={'pk': bucketlist.id}),
            change_bucketlist, format='json'
        )
        self.assertEqual(res.status_code, status.HTTP_200_OK)

    def test_api_can_delete_bucketlist(self):
        """API가 bucketlist을 지울 수 있는지 테스트합니다."""
        bucketlist = Bucketlist.objects.get()
        response = self.client.delete(
            reverse('details', kwargs={'pk': bucketlist.id}),
            format='json',
            follow=True)
        self.assertEquals(response.status_code, status.HTTP_204_NO_CONTENT)

ApiClient를 초기화하고 인증을 사용하도록 했습니다. 이렇게 하면 API의 보안이 강화됩니다. bucketlist 소유권도 고려되었습니다. 또한 각 테스트 방법이서 새로운 테스트 방법을 만드는 대신 ‘self.client’를 일관되게 사용하는 방법에 주목해야 합니다. 이는 인증된 클라이언트를 다시 사용하기 위한 것입니다. 재사용은 좋은 습관입니다.

테스트를 실행합니다. 지금 당장은 실패합니다.

$ python manage.py test api

다음 단계는 실패한 테스트를 통과하도록 코드를 리팩터링하는 것입니다.

How To Pass Those Tests!

Integrate the User

대부분의 경우 모델에서 변경 한 사항은 serializer에도 반영되어야 합니다. 이는 serializer가 이상한 모양의 쿼리셋을 json으로 또는 그 반대로 변경하는데 도움이 되는 모델과 직접 인터페이스하기 때문입니다.

bucketlist serializer를 수정합니다. serializers.py 파일에서 사용자 지정 필드를 작성하면, bucketlist의 owner를 불러올 수 있습니다.

# api/serializers.py

class BucketlistSerializer(serializers.ModelSerializer):
    """모델 인스턴스를 json 포멧으로 매핑하는 serializer입니다."""

    owner = serializers.ReadOnlyField(source='owner.username') # ADD THIS LINE

    class Meta:
        """serializer 필드를 모델 필드와 매핑하는 메타 클래스입니다."""
        model = Bucketlist
        fields = ('id', 'name', 'owner', 'date_created', 'date_modified') # ADD 'owner'
        read_only_fields = ('date_created', 'date_modified')

owner 필드는 읽기 전용이므로 API를 사용하는 사용자는 bucketlist의 owner를 변경할 수 없습니다. 위 지시대로 필드에 owner를 추가하는 것을 잊지 마세요.

제대로 작동하는지 확인해봅니다.

$ python manage.py runserver

localhost에서 접근할 때, 다음과 같이 보여야 합니다.

이제 새로운 bucketlist를 만들 때 owner를 저장하는 방법을 만들어야 합니다. bucketlist 저장은 우리가 정의한 views.py파일의 CreateView라는 클래스에서 수행됩니다. perform_create(self, serializer) 메소드를 추가하여 CreateView 클래스를 편집합니다. 이 메서드는 serializer를 저장하는 방법을 제어합니다.

# api/views.py

    def perform_create(self, serializer):
            """새 bucketlist를 만들 때 post data를 저장합니다."""
            serializer.save(owner=self.request.user) # Add owner=self.request.user

serializer.save()는 필수 인수를 허용합니다. 여기서는 owner를 지정했습니다. 우리의 serializer는 그것을 필드고 가지고 있기 때문에 serializer의 save 메소드에서 owner를 지정할 수 있습니다. 그 다음 사용자와 함께 bucketlist를 owner로 저장합니다.

bucketlist를 만들려고 하면 다음과 같은 오류가 발생합니다.

owner 지정없이 브라우저에서 bucketlist를 저장하려 했기 때문에 오류가 발생합니다.

serializer가 bucketlist의 유효성을 검사하고 저장하기 전에 새로운 nullable이 아닌 owner 필드에 값이 필요합니다. 문제를 해결해 봅시다.

urls.py에는 bucketlist를 만들기 전에 사용자가 api에 로그인할 수 있는 경로를 추가할 것입니다. bucketlist에 owner를 두기 위해, 즉 로그인한 사용자가 bucketlist를 만들기로 결정하는 경우 이를 수행합니다.

# api/urls.py

urlpatterns = {
    url(r'^auth/', include('rest_framework.urls', # ADD THIS URL
                               namespace='rest_framework')),
    url(r'^bucketlists/$', CreateView.as_view(), name="create"),
    url(r'^bucketlists/(?P<pk>[0-9]+)/$',
        DetailsView.as_view(), name="details"),
}

urlpatterns = format_suffix_patterns(urlpatterns)

추가한 코드는 사용자를 인증하는 기본 로그인 템플릿을 제공하는 DRF 경로가 포함됩니다.

파일을 저장하면 실행중인 서버 인스턴스는 재동으로 새로 고쳐집니다.

http://localhost:8000/bucketlists/으로 접속 후 오른쪽 상단의 로그인 버튼을 클릭하면 로그인 템플릿으로 리다이렉션 됩니다.

로그인 할 관리자 계정을 만듭니다.

$ python manage.py createsuperuser

그리고 로그인을 합니다.

Authorization: Adding permissions

현재 모든 사용자는 bucketlist를 보고 편집할 수 있습니다. 소유자만 bucketlist를 편집, 삭제를 할 수 있도록 적용할 수 있습니다.

A default permission check

기본 권한 패키지를 사용하여 인증 된 사용자에게만 bucketlist 엑세스를 제한 할 수 있습니다.

views.py에서 permissions 클래스를 가져옵니다.

from rest_framework import permissions

CreateView 클래스에 permission 클래스를 추가합니다.

# api/views.py

class CreateView(generics.ListCreateAPIView):
    """This class handles the GET and POSt requests of our rest api."""
    queryset = Bucketlist.objects.all()
    serializer_class = BucketlistSerializer
    permission_classes = (permissions.IsAuthenticated,) # ADD THIS LINE

permission 클래스인 IsAuthenticated는 인증되지 않은 사용자에게 권한을 거부하고, 인증된 사용자는 권한을 허용합니다. 요청이 “안전한 방법”(GET, HEAD, OPTIONS) 중 하나면 인증되지 않은 사용자를 허용하는 IsAuthenticatedOrReadOnly를 사용할 수 있었습니다. 하지만 우리는 안전한 보안을 원합니다.

Custom Permission

현재 인증된 사용자는 다른 사용자의 bucketlist를 볼 수 있습니다. owner에 대한 완전한 개념을 구현하려면 custom permission을 만들어야 합니다.

api 디렉터리 안에 permissions.py을 생성하고 다음의 코드를 작성합니다.

# api/permissions.py

from rest_framework.permissions import BasePermission
from .models import Bucketlist

class IsOwner(BasePermission):
    """bucketlist owner만 수정 권한을 부여할 수 있는 custom permission 클래스입니다."""

    def has_object_permission(self, request, view, obj):
        """bucketlist owner에게 권한이 부여되면 True를 반환합니다."""
        if isinstance(obj, Bucketlist):
            return obj.owner == request.user
        return obj.owner == request.user

위 클래스는 이러한 사실을 유지하는 사용 권한을 구현합니다. 사용자가 해당 개체의 사용 권한을 가지려면 사용자가 owner이여야 합니다. 사용자가 bucketlist의 owner라면 True를 반환하고, 아니라면 False를 반환합니다.

우리는 permission_classes 튜플 안에 추가해야 셋팅됩니다. 명확하게 하기 위해, 업데이트 된 view는 다음과 같을 것입니다.

# api/views.py

from rest_framework import generics, permissions
from .permissions import IsOwner
from .serializers import BucketlistSerializer
from .models import Bucketlist

class CreateView(generics.ListCreateAPIView):
    """This class handles the GET and POSt requests of our rest api."""
    queryset = Bucketlist.objects.all()
    serializer_class = BucketlistSerializer
    permission_classes = (
        permissions.IsAuthenticated, IsOwner)

    def perform_create(self, serializer):
        """Save the post data when creating a new bucketlist."""
        serializer.save(owner=self.request.user)

class DetailsView(generics.RetrieveUpdateDestroyAPIView):
    """This class handles GET, PUT, PATCH and DELETE requests."""

    queryset = Bucketlist.objects.all()
    serializer_class = BucketlistSerializer
    permission_classes = (
        permissions.IsAuthenticated,
        IsOwner)

로그아웃하고 bucketlits를 얻으려고 하면 HTTP 403 Forbidden 응답을 받게 됩니다. 이것을 인증과 권한 부여가 잘 작동되고 있음을 의미합니다.

마지막으로 테스트를 실행합니다.

$ python manage.py test
Creating test database for alias 'default'...
System check identified no issues (0 silenced).
.....
----------------------------------------------------------------------
Ran 5 tests in 0.045s

OK
Destroying test database for alias 'default'...

What about Token-based Authentication?

토큰 인증은 특히 클라이언트가 PC나 Mobile인 경우 클라이언트-서버 설정에 적합합니다.

작동 방법은 이러합니다.

사용자가 서버에 보안 토큰을 요청합니다.
서버는 토큰을 생성하고 이를 사용자와 연관시킵니다.
토큰을 보낸 후 서버는 사용자가 해당 토큰을 사용하여 리소스를 요청할 때까지 기다립니다.
그런 다음 사용자는 토큰을 사용하여 실제로 유효한 사용자임을 서버에 인증하고 증명합니다.

API에 토큰 인증을 사용하려면 settings.py에 일부 구성을 설정해야 합니다.

# project/settings.py

INSTALLED_APPS = (
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'rest_framework',
    'rest_api',
    'rest_framework.authtoken' # ADD THIS LINE
)

사용자를 생성할 때마다 보안 토큰을 만들고 싶습니다. 사용자 생성시 토큰 생성도 트리거되도록 하려면 어떻게 해야 할까요?

신호를 입력합니다.

사용자가 생성되면 사용자 모델에 의해 post_save 신호가 발생합니다. 그러면 receiver가 이 post_save 신호를 포착하고 토큰을 즉시 생성하는데 도움을 줍니다.

receiver는 models.py 안에 있습니다. 추가할 import들 입니다.

post_save signal
default User model
Token model
receiver

# api/models.py

# rest_api/models.py
from django.db.models.signals import post_save
from django.contrib.auth.models import User
from rest_framework.authtoken.models import Token
from django.dispatch import receiver

class Bucketlist(models.Model):
    """This class represents the bucketlist model."""
    name = models.CharField(max_length=255, blank=False, unique=True)
    owner = models.ForeignKey(
        'auth.User',
        related_name='bucketlists',
        on_delete=models.CASCADE)
    date_created = models.DateTimeField(auto_now_add=True)
    date_modified = models.DateTimeField(auto_now=True)

    def __str__(self):
        """Return a human readable representation of the model instance."""
        return "{}".format(self.name)

# This receiver handles token creation immediately a new user is created.
@receiver(post_save, sender=User)
def create_auth_token(sender, instance=None, created=False, **kwargs):
    if created:
        Token.objects.create(user=instance)

receiver는 Bucketlist 모델 클래스 안에 들여 쓰기되어 있지 않습니다.

또한 사용자가 토큰을 얻을 수 있는 방법을 제공해야 합니다. URL이 그 방법입니다.

# api/urls.py
from rest_framework.authtoken.views import obtain_auth_token # add this import

urlpatterns = {
    path('bucketlists/', CreateView.as_view(), name="create"),
    path('bucketlists/<pk>/',
        DetailsView.as_view(), name="details"),
    path('auth/', include('rest_framework.urls',
                           namespace='rest_framework')),
    path('users/', UserView.as_view(), name="users"),
    path('users/<pk>/',
        UserDetailsView.as_view(), name="user_details"),
    path('get-token/', obtain_auth_token), # Add this line
}

urlpatterns = format_suffix_patterns(urlpatterns)

중간에 UserView, UserDetailsView가 갑자기 생겼다. 원작자가 실수로 빼먹은 듯 하다. 빠진 코드를 추가합니다.

# api/views.py
class UserView(generics.ListAPIView):
    """View to list the user queryset."""
    queryset = User.objects.all()
    serializer_class = UserSerializer


class UserDetailsView(generics.RetrieveAPIView):
    """View to retrieve a user instance."""
    queryset = User.objects.all()
    serializer_class = UserSerializer

# api/serializers.py

class UserSerializer(serializers.ModelSerializer):
    """인증과 승인에 도움이 되는 serializer"""

    bucketlists = serializers.PrimaryKeyRelatedField(
        many=True, queryset=Bucketlist.objects.all())

    class Meta:
        """serializer를 기본 django 사용자 모델에 매핑합니다."""
        model = User
        fields = ('id', 'username', 'bucketlists')

DRF는 사용자가 사용자 이름과 암호를 입력할 때 토큰을 얻는데 사용할 수 있는 뷰가 내장되어 있습니다.

마이그레이션으로 데이터베이스에 반영하면 이 뷰를 활용할 수 있습니다.

$ python manage.py makemigrations api && python manage.py migrate

마지막으로 BasicAuthentication과 TokenAuthentication으로 인증 할 수 있도록 설정에 추가합니다.

# project/settings.py

REST_FRAMEWORK = {
    'DEFAULT_PERMISSION_CLASSES': (
        'rest_framework.permissions.IsAuthenticated',
    ),
    'DEFAULT_AUTHENTICATION_CLASSES': (
        'rest_framework.authentication.BasicAuthentication',
        'rest_framework.authentication.TokenAuthentication',
    )
}

DEFAULT_AUTHENTICATION_CLASSES 설정은 사용자에게 여러가지 인증 방법을 구성할 것을 앱에 알려줍니다. 이 튜플 내부에 내장된 인증 클래스를 참조하여 방법을 지정합니다.

Run it

파일을 저장하면, 서버가 이미 실행중인 경우 추가 변경된 사항을 자동으로 적용해 재시작합니다. 하지만 서버를 수동으로 재시작하는 것이 좋습니다.

시각적으로 API가 있는지 여부를 테스트하기 위해 Postman에 HTTP 요청을 합니다.

Postman Step 1: Obtain that token

클라이언트가 인증을 받으려면 획득 된 토큰이 Authorization HTTP 헤더에 포함되어야 합니다. Token이라는 단어 앞에 공백 문자를 붙입니다. 헤더는 다음과 같아야 합니다.

Authorization: Token 2777b09199c62bcf9418ad846dd0e4bbdfc6ee4b

빈 칸을 잊으면 안됩니다.

프로세스에서 사용자 이름과 암호를 지정하여 ‘http://localhost:8000/get-token/’에 post 요청을 합니다.

Postman Step 2: Use obtained token in Authorization header

이후 요청에 대해서는 API 리소스에 엑세스하려면 Authorization 헤더를 포함하야 합니다.

여기에서 오류가 발생할 수 있는데, 일반적으로 Authorization 헤더에 잘못 된 형식으로 입력하는 것입니다. 다음은 서버에서 일반적으로 발생하는 오류 메시지입니다.

{
  "detail": "Authentication credentials were not provided."
}

‘Token ' 형식으로 입력했는지 확인합니다. 만약 bearer와 같이 헤더에 다른 키워드를 사용하려면, TokenAuthentication을 하위 클래스로 만들고 키워드 클래스 별수를 설정하세요.

GET 요청을 보내봅시다, 다음과 같은 결과가 나옵니다.

이제 보안이 잘 설정된 API에서 자유롭게 사용할 수 있습니다.

Conclusion

사용자 인증 구현에서 인증 구현을 위한 권한 생성에 이르기까지 Django API를 안전하게 보호했습니다.

또한 모바일과 PC가 안전하게 API를 사용할 수 있도록 토큰 기반 인증 레이어를 편리하게 정의했습니다. 그리고 가장 중요한 것은 변경 사항을 수용하기 위해 테스트를 리팩터링했다는 것입니다. 이것은 매우 중요하며 TDA의 핵심입니다.

django

I feedback.
Let me know what you think of this article in the comment section below!

Build a REST API with Django – A Test Driven Approach - Part 2