Django REST Framework Fortgeschritten: JWT-Authentifizierung und Throttling

Einführung in Fortgeschrittene APIs

Django REST Framework (DRF) bietet fortgeschrittene Funktionen zum Erstellen von Enterprise-Grade-APIs. In diesem Tutorial erkunden wir JWT-Authentifizierung, Throttling und benutzerdefinierte Berechtigungen.

1. JWT-Authentifizierung

JSON Web Tokens (JWT) sind der Standard für zustandslose Authentifizierung in modernen APIs.

Installation

pip install djangorestframework-simplejwt

Konfiguration in settings.py

REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework_simplejwt.authentication.JWTAuthentication',
    ],
}

from datetime import timedelta

SIMPLE_JWT = {
    'ACCESS_TOKEN_LIFETIME': timedelta(minutes=60),
    'REFRESH_TOKEN_LIFETIME': timedelta(days=7),
    'ROTATE_REFRESH_TOKENS': True,
    'BLACKLIST_AFTER_ROTATION': True,
    'ALGORITHM': 'HS256',
    'SIGNING_KEY': SECRET_KEY,
    'AUTH_HEADER_TYPES': ('Bearer',),
}

URLs für Token

from rest_framework_simplejwt.views import (
    TokenObtainPairView,
    TokenRefreshView,
    TokenVerifyView,
)

urlpatterns = [
    path('api/token/', TokenObtainPairView.as_view(), name='token_obtain_pair'),
    path('api/token/refresh/', TokenRefreshView.as_view(), name='token_refresh'),
    path('api/token/verify/', TokenVerifyView.as_view(), name='token_verify'),
]

2. API-Throttling

Throttling begrenzt die Anzahl der Anfragen, um Missbrauch zu verhindern und Stabilität zu gewährleisten.

Globale Konfiguration

REST_FRAMEWORK = {
    'DEFAULT_THROTTLE_CLASSES': [
        'rest_framework.throttling.AnonRateThrottle',
        'rest_framework.throttling.UserRateThrottle',
    ],
    'DEFAULT_THROTTLE_RATES': {
        'anon': '100/hour',      # Anonyme Benutzer
        'user': '1000/hour',     # Authentifizierte Benutzer
        'burst': '60/minute',    # Burst-Rate
    }
}

Benutzerdefiniertes Throttling

from rest_framework.throttling import UserRateThrottle

class PremiumUserThrottle(UserRateThrottle):
    """Höheres Rate-Limit für Premium-Benutzer"""
    scope = 'premium'

    def get_rate(self):
        if self.request.user.is_premium:
            return '10000/hour'
        return '1000/hour'

3. Benutzerdefinierte Berechtigungen

from rest_framework.permissions import BasePermission

class IsOwnerOrReadOnly(BasePermission):
    """Erlaubt Bearbeitung nur dem Eigentümer"""

    def has_object_permission(self, request, view, obj):
        # Lesen für alle erlaubt
        if request.method in ['GET', 'HEAD', 'OPTIONS']:
            return True
        # Schreiben nur für Eigentümer
        return obj.author == request.user

class IsAdminOrReadOnly(BasePermission):
    """Nur Admins können bearbeiten"""

    def has_permission(self, request, view):
        if request.method in ['GET', 'HEAD', 'OPTIONS']:
            return True
        return request.user and request.user.is_staff

4. Fortgeschrittene Serializers

from rest_framework import serializers

class BlogPostSerializer(serializers.ModelSerializer):
    author = serializers.SerializerMethodField()
    reading_time = serializers.ReadOnlyField()

    class Meta:
        model = BlogPost
        fields = ['id', 'title', 'content', 'author', 'reading_time', 'created_at']

    def get_author(self, obj):
        return {
            'id': obj.author.id,
            'username': obj.author.username,
            'email': obj.author.email
        }

    def validate_title(self, value):
        if len(value) < 10:
            raise serializers.ValidationError("Titel zu kurz")
        return value

5. ViewSet mit Custom Actions

from rest_framework.decorators import action
from rest_framework.response import Response

class BlogPostViewSet(viewsets.ModelViewSet):
    queryset = BlogPost.objects.all()
    serializer_class = BlogPostSerializer
    permission_classes = [IsOwnerOrReadOnly]
    throttle_classes = [UserRateThrottle]

    @action(detail=True, methods=['post'])
    def publish(self, request, pk=None):
        """Veröffentlicht einen Artikel"""
        post = self.get_object()
        post.status = 'published'
        post.published_at = timezone.now()
        post.save()
        return Response({'status': 'published'})

    @action(detail=False, methods=['get'])
    def popular(self, request):
        """Gibt die beliebtesten Artikel zurück"""
        popular = self.queryset.order_by('-views')[:10]
        serializer = self.get_serializer(popular, many=True)
        return Response(serializer.data)

Best Practices

• Verwenden Sie immer HTTPS in der Produktion
• Implementieren Sie angemessenes Rate-Limiting
• Validieren Sie alle Eingaben mit Serializers
• Verwenden Sie granulare Berechtigungen für jeden Endpunkt
• Protokollieren Sie alle API-Anfragen für Debugging

Fazit

Mit JWT, Throttling und benutzerdefinierten Berechtigungen sind Ihre Django-APIs sicher, skalierbar und produktionsbereit.