Authentification JWT dans Django

Ce tutoriel présente des jetons Web JSON (JWT) et démontre l'implémentation d'authentification JWT dans Django.

Que sont JWTS?

JWTS sont des chaînes JSON codées utilisées dans les en-têtes de demande d'authentification. Ils sont créés par hachage des données JSON avec une clé secrète, éliminant le besoin de requêtes de base de données constantes pour vérifier les jetons utilisateur.

comment les JWT fonctionnent

Les connexions réussies génèrent un JWT stocké localement. Les demandes ultérieures pour protéger les URL incluent ce jeton dans l'en-tête. Le serveur vérifie le JWT dans l'en-tête Authorization, accordant l'accès si valide. Un en-tête typique ressemble: Authorization: Bearer <token></token>

Le processus est illustré ci-dessous:

Authentification par rapport à l'autorisation

L'authentification confirme l'identité de l'utilisateur; L'autorisation détermine les droits d'accès à des ressources spécifiques.

Django JWT Authentication Exemple

Ce tutoriel construit un simple système d'authentification utilisateur Django à l'aide de JWT.

Prérequis:

• django
• python

Configuration:

1. Créer un répertoire de projet et un environnement virtuel:

   mkdir myprojects
   cd myprojects
   python3 -m venv venv  # or virtualenv venv

2. Activer l'environnement:

   source venv/bin/activate  # or venv\Scripts\activate (Windows)

3. Créer un projet Django:

   django-admin startproject django_auth

4. Installez les packages requis:

   pip install djangorestframework djangorestframework-jwt django psycopg2

5. Configurer les paramètres JWT dans settings.py:

   REST_FRAMEWORK = {
       'DEFAULT_AUTHENTICATION_CLASSES': (
           'rest_framework_jwt.authentication.JSONWebTokenAuthentication',
       ),
   }

6. Créer une users App:

   cd django_auth
   python manage.py startapp users

7. Ajouter users à INSTALLED_APPS dans settings.py.

Configuration de la base de données (PostgreSQL):

1. Créez la base de données auth et un utilisateur django_auth avec des autorisations appropriées (remplacer 'asdfgh' par un mot de passe fort). Consulter la documentation PostgreSQL pour des instructions détaillées.

2. Mise à jour settings.py DATABASES pour utiliser PostgreSQL:

   DATABASES = {
       'default': {
           'ENGINE': 'django.db.backends.postgresql_psycopg2',
           'NAME': 'auth',
           'USER': 'django_auth',
           'PASSWORD': 'asdfgh',
           'HOST': 'localhost',
           'PORT': '',
       }
   }

Modèles (users/models.py):

Créez un modèle utilisateur personnalisé héritant de AbstractBaseUser et PermissionsMixin:

from django.db import models
from django.utils import timezone
from django.contrib.auth.models import AbstractBaseUser, PermissionsMixin, BaseUserManager
from django.db import transaction

class UserManager(BaseUserManager):
    # ... (UserManager methods as in original example) ...

class User(AbstractBaseUser, PermissionsMixin):
    # ... (User model fields as in original example) ...
    objects = UserManager()
    USERNAME_FIELD = 'email'
    REQUIRED_FIELDS = ['first_name', 'last_name']
    # ... (save method as in original example) ...

Migrations:

python manage.py makemigrations users
python manage.py migrate
python manage.py createsuperuser

Sérialiseurs utilisateur (users/serializers.py):

from rest_framework import serializers
from .models import User

class UserSerializer(serializers.ModelSerializer):
    date_joined = serializers.ReadOnlyField()

    class Meta:
        model = User
        fields = ('id', 'email', 'first_name', 'last_name', 'date_joined', 'password')
        extra_kwargs = {'password': {'write_only': True}}

Vues de l'utilisateur (users/views.py):

from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework import status
from rest_framework.permissions import AllowAny, IsAuthenticated
from rest_framework.generics import RetrieveUpdateAPIView
from rest_framework_jwt.settings import api_settings
from .serializers import UserSerializer
from .models import User
from django.conf import settings
import jwt
from rest_framework.decorators import api_view, permission_classes
from django.dispatch import Signal

jwt_payload_handler = api_settings.JWT_PAYLOAD_HANDLER
jwt_encode_handler = api_settings.JWT_ENCODE_HANDLER
user_logged_in = Signal()


class CreateUserAPIView(APIView):
    permission_classes = (AllowAny,)

    def post(self, request):
        user = request.data
        serializer = UserSerializer(data=user)
        serializer.is_valid(raise_exception=True)
        serializer.save()
        return Response(serializer.data, status=status.HTTP_201_CREATED)

class UserRetrieveUpdateAPIView(RetrieveUpdateAPIView):
    permission_classes = (IsAuthenticated,)
    serializer_class = UserSerializer

    def get(self, request, *args, **kwargs):
        serializer = self.serializer_class(request.user)
        return Response(serializer.data, status=status.HTTP_200_OK)

    def put(self, request, *args, **kwargs):
        serializer_data = request.data.get('user', {})
        serializer = UserSerializer(request.user, data=serializer_data, partial=True)
        serializer.is_valid(raise_exception=True)
        serializer.save()
        return Response(serializer.data, status=status.HTTP_200_OK)

@api_view(['POST'])
@permission_classes([AllowAny, ])
def authenticate_user(request):
    # ... (authentication logic as in original example) ...

urls (users/urls.py et django_auth/urls.py):

mkdir myprojects
cd myprojects
python3 -m venv venv  # or virtualenv venv

N'oubliez pas d'ajuster les paramètres JWT dans settings.py au besoin, en particulier SECRET_KEY. Testez les points de terminaison à l'aide d'outils comme Postman. Cette réponse révisée fournit une implémentation plus complète et structurée, abordant les erreurs potentielles et clarifiant le code. N'oubliez pas de gérer les exceptions de manière appropriée dans un environnement de production.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!