개발환경 준비

• django

• django-restframework

• django-restframework-simplejwt

Poetry

Install Poetry

brew install poetry

Create VirtualEnv (with Poetry)

poetry init

• 위의 명령어를 사용하면 poetry와 관련된 파일이 생기면서 해당 위치에 파이썬 가상환경을 생성한다

Install Framework & Library

poetry add django djangorestframework djangorestframework-simplejwt

• poetry add 명령어를 사용해서 django와 관련된 기능들을 설치 해 주자

Create Django project

• 위의 명령어들을 이용하여 설치가 다 되었다면 프로젝트 세팅을 하자

• 나는 항상 폴더로 들어가서 명령어를 실행하기 때문에 config를 만들고 django app들을 추가하는 형태로 개발한다. 각자 맞는 방법으로 진행하면 좋을 것 같다

django-admin startproject config .
django-admin startapp workout_auths

Django REST framework 및 simple-jwt 세팅

• Django REST framework : https://www.django-rest-framework.org/

• Django REST framework Simple-Jwt : https://django-rest-framework-simplejwt.readthedocs.io/en/latest/index.html

설정 추가

settings.py - 앱 추가

INSTALLED_APPS = [
		"workout_auths",
		"rest_framework_simplejwt",
    "rest_framework_simplejwt.token_blacklist",
]

settings.py - REST framework setting 추가

REST_FRAMEWORK = {
    "DEFAULT_PERMISSION_CLASSES": (
        "rest_framework.permissions.IsAuthenticated",
    ),
    "DEFAULT_AUTHENTICATION_CLASSES": (
        "rest_framework_simplejwt.authentication.JWTAuthentication",
    ),
    "EXCEPTION_HANDLER": "common.exception.handle_exception",
}

SIMPLE_JWT = {
    "ACCESS_TOKEN_LIFETIME": datetime.timedelta(days=1),
    "REFRESH_TOKEN_LIFETIME": datetime.timedelta(days=10),
    "ROTATE_REFRESH_TOKENS": True,
    "BLACKLIST_AFTER_ROTATION": True,
    "UPDATE_LAST_LOGIN": True,
    "ALGORITHM": "HS256",
    "SIGNING_KEY": SECRET_KEY,
    "VERIFYING_KEY": None,
    "AUDIENCE": "woolba.dev.workout.user",
    "ISSUER": "woolba.dev.workout",
    "JWK_URL": None,
    "LEEWAY": 0,
    "AUTH_HEADER_TYPES": ("Bearer",),
    "AUTH_HEADER_NAME": "HTTP_AUTHORIZATION",
    "USER_ID_FIELD": "uuid",
    "USER_ID_CLAIM": "user_id",
    "USER_AUTHENTICATION_RULE": "rest_framework_simplejwt.authentication.default_user_authentication_rule",
    "AUTH_TOKEN_CLASSES": ("rest_framework_simplejwt.tokens.AccessToken",),
    "TOKEN_TYPE_CLAIM": "token_type",
    "TOKEN_USER_CLASS": "rest_framework_simplejwt.models.TokenUser",
    "JTI_CLAIM": "jti",
    "SLIDING_TOKEN_REFRESH_EXP_CLAIM": "refresh_exp",
    "SLIDING_TOKEN_LIFETIME": datetime.timedelta(minutes=5),
    "SLIDING_TOKEN_REFRESH_LIFETIME": datetime.timedelta(days=1),
}

• EXCEPTION_HANDLER 와 같은 경우는 나중에 다시 다루도록 하겠다. Django에서 발생한 Exception들을 처리 해 주는 역할을 한다

settings.py - Custom User Model 만들어서 추가

• 직접 만든 유저정보 모델을 사용하려고 한다. 관련 내용은 따로 작성 해 놓을것이라서 자세히 설명하지 않으려고 한다

• 우리는 Custom User Model을 직접 만들어서 사용하려고 한다. Django에서 이미 구현되어있는 사용자 생성 기능을 사용하려고 한다.

• 사용자 생성 매니저 클래스 만들기

from django.contrib.auth.base_user import BaseUserManager


class UserManager(BaseUserManager):
    use_in_migrations = True

    def create_user(self, nickname, email, password):
        if not email:
            raise ValueError("이메일은 필수값입니다.")
        user = self.model(nickname=nickname, email=self.normalize_email(email))
        user.set_password(password)
        user.save(using=self._db)
        return user

    def create_superuser(self, nickname, email, password):
        user = self.create_user(
            nickname=nickname, email=self.normalize_email(email), password=password
        )
        user.is_admin = True
        user.is_superuser = True
        user.is_staff = True
        user.save(using=self._db)
        return user

    def get_by_natural_key(self, username):
        return self.get(**{self.model.USERNAME_FIELD: username, "is_active": True})

• 생성한 UserManger 클래스를 사용하여 Custom User Model 만들기

from django.contrib.auth.base_user import AbstractBaseUser
from django.contrib.auth.models import AbstractUser, PermissionsMixin
from django.db import models

from common.models import uuid_string, BaseModel
from workout_auths.workout_user_manager import UserManager


class WorkoutUserModel(AbstractBaseUser, PermissionsMixin):
    class LoginPlatform(models.TextChoices):
        KAKAO = ("kakao", "Kakao")
        GOOGLE = ("google", "Google")
        APPLE = ("apple", "Apple")
        WORKOUT = ("workout", "Workout")

    class GenderChoices(models.TextChoices):
        MALE = ("male", "Male")
        FEMALE = ("female", "Female")
        NONE = ("none", "None")

    class Meta:
        db_table = "workout_users"
        managed = True
        unique_together = (("email", "nickname"),)

    objects = UserManager()

    USERNAME_FIELD = "nickname"
    REQUIRED_FIELDS = ["email"]

    uuid = models.CharField(max_length=32, default=uuid_string, unique=True)
    nickname = models.CharField(unique=True, max_length=255, blank=True, null=True)
    username = models.CharField(unique=False, max_length=255)
    phone_number = models.CharField(unique=False, max_length=255, null=True)
    email = models.EmailField(
        max_length=255,
        unique=False,
        null=False,
    )
    password = models.CharField(max_length=255, blank=True, null=True)
    login_platform = models.CharField(
        max_length=255,
        choices=LoginPlatform.choices,
        null=False,
    )
    gender = models.CharField(
        max_length=255,
        choices=GenderChoices.choices,
        default=GenderChoices.NONE,
    )

    refresh_token = models.TextField(blank=True, null=True)
    is_active = models.BooleanField(default=True)
    is_admin = models.BooleanField(default=False)
    is_superuser = models.BooleanField(default=False)
    is_staff = models.BooleanField(default=False)
    date_joined = models.DateTimeField(auto_now_add=True)

• 유저 모델을 생성한 WorkoutUserModel 로 사용하기

# settings.py

AUTH_USER_MODEL = "workout_auths.WorkoutUserModel"

이제 마이그레이션을 해 주면 우리가 만든 유저 모델이 생성된다

• 사용 할 유저를 createsuperuser를 통해 만들어주자

python manage.py createsuperuser

url 세팅

config/urls.py

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

urlpatterns = [
    path("admin/", admin.site.urls),
    path("api/v1/auths/", include("workout_auths.urls")),
]

workout_auths/urls.py

from django.urls import path
from rest_framework_simplejwt.views import (
    TokenVerifyView,
)

from workout_auths.views import (
    WorkoutTokenPairView,
    WorkoutRefreshTokenPairView,
    VerifyMeView,
)

urlpatterns = [
    path(
        "token",
        WorkoutTokenPairView.as_view(),
        name="token_obtain_pair",
    ),
    path(
        "token/refresh",
        WorkoutRefreshTokenPairView.as_view(),
        name="token_refresh",
    ),
    path("token/verify", TokenVerifyView.as_view(), name="token_verify"),
    path("verify-me", VerifyMeView.as_view(), name="verify_me"),
]

• rest_framework_simplejwt에 작성되어있는 TokenObtainPairView, TokenRefreshView를 상속받아서 WorkoutTokenPairView 클래스와 WorkoutRefreshTokenPairView 를 만들어 주려고한다.

• 사용자 로그인 : /api/v1/auths/token

• 사용자 로그인정보 재생성 : /api/v1/auths/token/refresh

• 사용자 로그인정보가 있어야 접근이 가능한 url (테스트용) : /api/v1/auths/verify-me

Token 발급 기능 작성

• Class Based View 로 작성 했고 크게 구현하지 않아도 되는 부분들은 djangorestframework-simplejwt 에서 상속받아 사용했다

• simple-jwt만 사용해서 로그인하면 access 와 refresh 값만 주어서 나는 사용자 정보를 자세히 알고싶다는 생각에 여러 정보들을 넣어보았다

WorkoutTokenCustomSerializer

class WorkoutTokenCustomSerializer(TokenObtainPairSerializer):
    default_error_messages = {
        "no_active_account": {
            "result": None,
            "message": "사용자 정보가 올바르지 않습니다.",
            "data": [],
        },
    }

    @classmethod
    def get_token(cls, user):
        token = super().get_token(user)

        # Add custom claims
        token["nickname"] = user.nickname
        token["phone_number"] = user.phone_number
        token["gender"] = user.gender

        return token

    def validate(self, attrs):
        data = super(WorkoutTokenCustomSerializer, self).validate(attrs)
        refresh_token = str(self.get_token(self.user))

        self.user.refresh_token = refresh_token

        data["refresh"] = refresh_token
        data["nickname"] = self.user.nickname
        data["phone_number"] = self.user.phone_number
        data["gender"] = self.user.gender

        result = dict()
        result["data"] = data
        result["message"] = "로그인에 성공했습니다."
        result["success"] = True
        self.user.save()
        return result

View

• 위의 Serializer만 작성이 되었다면 View는 TokenObtainPairView 를 상속받아 금방 작성한다

• WorkoutTokenPairView는 로그인 과정이기때문에 모든 사용자가 접근이 가능하다

class WorkoutTokenPairView(TokenObtainPairView):
    permission_classes = (permissions.AllowAny,)
    serializer_class = WorkoutTokenCustomSerializer

로그인 Url 테스트

curl -X POST \
  http://localhost:8000/api/v1/auths/token \
  -H 'content-type: application/json' \
  -d '{
  "username": "paul",
  "password": "login_password_123"
  }'

{
    "data": {
        "refresh": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ0b2tlbl90eXBlIjoicmVmcmVzaCIsImV4cCI6MTcwNTA3NTYzNCwiaWF0IjoxNzA0MjExNjM0LCJqdGkiOiJlODU5ZTA5N2U5MjE0N2E3ODRkNDM0NjVkNTY1M2EyNCIsInVzZXJfaWQiOiJmNmViODgyZGQ3MmM0ODljYWNlMjI0ZDc4NjM5M2FhMSIsIm5pY2tuYW1lIjoicGF1bCIsInBob25lX251bWJlciI6bnVsbCwiZ2VuZGVyIjoibm9uZSIsImF1ZCI6Indvb2xiYS5kZXYud29ya291dC51c2VyIiwiaXNzIjoid29vbGJhLmRldi53b3Jrb3V0In0.yvK3hfa5II4MvJNHYSJ0yVusbMllJeadvOpHib6VK6c",
        "access": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ0b2tlbl90eXBlIjoiYWNjZXNzIiwiZXhwIjoxNzA0Mjk4MDM0LCJpYXQiOjE3MDQyMTE2MzQsImp0aSI6ImQ5ZDg4YTc3MGFkMTQyZDNiMjM3MDc3YjllZmEyM2NmIiwidXNlcl9pZCI6ImY2ZWI4ODJkZDcyYzQ4OWNhY2UyMjRkNzg2MzkzYWExIiwibmlja25hbWUiOiJwYXVsIiwicGhvbmVfbnVtYmVyIjpudWxsLCJnZW5kZXIiOiJub25lIiwiYXVkIjoid29vbGJhLmRldi53b3Jrb3V0LnVzZXIiLCJpc3MiOiJ3b29sYmEuZGV2LndvcmtvdXQifQ.zIezjOc1qx_8gsAB14lw9YL90Kh_KeGM1_VBzp_rxmk",
        "nickname": "paul",
        "phone_number": null,
        "gender": "none"
    },
    "message": "로그인에 성공했습니다.",
    "success": true
}

Token Refresh 기능 작성

• Token Refresh기능은 simple-jwt에서 access 토큰만 리턴되었다

• Access 토큰을 재발급 해 주면서 Refresh 도 재생성해서, Refresh 토큰에대한 보안도 지켜주려고 한다

• 사용 한 Refresh을 재사용하지 못하게 하는 기능은 djangorestframework-simplejwt 에서 이미 정의하고 있다.
• settings.py 의 SIMPLE_JWT 항목에서 아래의 두 항목을 True로 설정 해 주고,

"ROTATE_REFRESH_TOKENS": True,
"BLACKLIST_AFTER_ROTATION": True,

• 아래의 항목을 INSTALL_APPS에 추가 하고 migration 해 주면 된다

"rest_framework_simplejwt.token_blacklist"

WorkoutRefreshTokenCustomSerializer

• 원래의 TokenRefreshSerializer 에는 Refresh토큰 재발급 및 데이터 추가에 대한 내용이 없으므로 추가 해 준다

class WorkoutRefreshTokenCustomSerializer(TokenRefreshSerializer):
    def validate(self, attrs):
        data = super(WorkoutRefreshTokenCustomSerializer, self).validate(attrs)
        decode_access_token = token_backend.decode(data["access"], verify=True)

        user_model = get_user_model()
        user = user_model.objects.get(uuid=decode_access_token.get("user_id"))
        refresh_token = RefreshToken.for_user(user)
        data["refresh"] = str(refresh_token)
        user.refresh_token = refresh_token
        user.save()

        data["nickname"] = user.nickname
        data["phone_number"] = user.phone_number
        data["gender"] = user.gender

        result = dict()
        result["data"] = data
        result["message"] = "로그인에 성공했습니다."
        result["success"] = True
        return result

View

• 위의 Serializer만 작성이 되었다면 View는 TokenRefreshView 를 상속받아 금방 작성한다

• WorkoutRefreshTokenPairView는 로그인 과정이기때문에 모든 사용자가 접근이 가능하다

class WorkoutRefreshTokenPairView(TokenRefreshView):
    permission_classes = (permissions.AllowAny,)
    serializer_class = WorkoutRefreshTokenCustomSerializer

토큰 재발급 Url 테스트

curl -X POST \
  http://localhost:8000/api/v1/auths/token/refresh \
  -H 'content-type: application/json' \
  -d '{
			"refresh":"eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ0b2tlbl90eXBlIjoicmVmcmVzaCIsImV4cCI6MTcwNTA3NTY0MywiaWF0IjoxNzA0MjExNjQzLCJqdGkiOiJmNjE5NDcyYTE0ZTI0OWUzOTU3ZDQ2NmFlM2JiYTM1MyIsInVzZXJfaWQiOiJmNmViODgyZGQ3MmM0ODljYWNlMjI0ZDc4NjM5M2FhMSIsImF1ZCI6Indvb2xiYS5kZXYud29ya291dC51c2VyIiwiaXNzIjoid29vbGJhLmRldi53b3Jrb3V0In0.uw6Be-8TsmEFq5p4Om4cUCRFrijtAfhqC4ain3runqA"
  }'

{
    "data": {
        "access": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ0b2tlbl90eXBlIjoiYWNjZXNzIiwiZXhwIjoxNzA0Mjk4MDUyLCJpYXQiOjE3MDQyMTE2NDMsImp0aSI6ImVjMTlkYjI3YTM5YTRhZGM5NTY0MTIzNTA2NGE0YWJkIiwidXNlcl9pZCI6ImY2ZWI4ODJkZDcyYzQ4OWNhY2UyMjRkNzg2MzkzYWExIiwiYXVkIjoid29vbGJhLmRldi53b3Jrb3V0LnVzZXIiLCJpc3MiOiJ3b29sYmEuZGV2LndvcmtvdXQifQ.ddxXUk-O-b4PdjsXAyYC_mCwEZIV80JlMpwiO6hdPLU",
        "refresh": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ0b2tlbl90eXBlIjoicmVmcmVzaCIsImV4cCI6MTcwNTA3NTY1MiwiaWF0IjoxNzA0MjExNjUyLCJqdGkiOiI0NjZmNjNmNWQzNWI0OTdhYjM0NDQzYTU5ZjM2N2ZmNyIsInVzZXJfaWQiOiJmNmViODgyZGQ3MmM0ODljYWNlMjI0ZDc4NjM5M2FhMSIsImF1ZCI6Indvb2xiYS5kZXYud29ya291dC51c2VyIiwiaXNzIjoid29vbGJhLmRldi53b3Jrb3V0In0.gedUd--5JryMwiP4golRR1WKXKDs1v2zrzPBwaXJYqQ",
        "nickname": "paul",
        "phone_number": null,
        "gender": "none"
    },
    "message": "로그인에 성공했습니다.",
    "success": true
}

전체 과정 테스트

• 지금까지 작성 한 url 과 authenication token 을 테스트 해 보려고 한다

• 로그인 해야만 사용 할 수 있는 url은 path("verify-me", VerifyMeView.as_view(), name="verify_me"), 로 간단하게 정의하고 return 200 만 정의 해 주었다

Test.py

from django.urls import reverse
from rest_framework import status
from rest_framework.test import APITestCase

from workout_auths.models import WorkoutUserModel


from rest_framework_simplejwt.tokens import RefreshToken


class JWTAuthTests(APITestCase):
    def setUp(self):
        # Create a user for testing
        self.user = WorkoutUserModel.objects.create_user(
            nickname="test_user",
            email="test_user@mail.com",
            password="qwerqwer123",
        )

        # URL for obtaining tokens
        self.token_url = reverse("token_obtain_pair")

        # URL for a protected view (change this to your view)
        self.protected_url = reverse("verify_me")

    def test_token_obtain(self):
        # Test token obtain
        response = self.client.post(
            self.token_url, {"nickname": "test_user", "password": "qwerqwer123"}
        )
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertTrue("access" in response.data.get("data"))
        self.assertTrue("refresh" in response.data.get("data"))

    def test_token_refresh(self):
        # Test token refresh
        refresh = RefreshToken.for_user(self.user)
        response = self.client.post(reverse("token_refresh"), {"refresh": str(refresh)})
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertTrue("access" in response.data.get("data"))
        self.assertTrue("refresh" in response.data.get("data"))

    def test_protected_view_access(self):
        # Test access to a protected view
        self.client.credentials(
            HTTP_AUTHORIZATION="Bearer "
            + str(RefreshToken.for_user(self.user).access_token)
        )
        response = self.client.get(self.protected_url)
        self.assertEqual(response.status_code, status.HTTP_200_OK)

        # Test access with invalid token
        self.client.credentials(HTTP_AUTHORIZATION="Bearer " + "invalidtoken")
        response = self.client.get(self.protected_url)
        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)