Techniques de contrôle des autorisations dans le framework Django (Partie 2)

Compétences en matière de contrôle des autorisations dans le framework Django (Partie 2)

Dans le framework Django, le contrôle des autorisations est une partie très importante. Dans l'article précédent, nous avons présenté quelques techniques de contrôle d'autorisation de base dans le framework Django, notamment l'utilisation du système d'authentification d'autorisation intégré et le contrôle d'autorisation basé sur le décorateur. Cet article continuera à explorer d'autres techniques de contrôle des autorisations dans le framework Django.

1. Backend d'authentification personnalisé

Dans le framework Django, nous pouvons utiliser un backend d'authentification personnalisé pour implémenter une logique d'authentification personnalisée. En héritant de la classe backend d'authentification de Django et en implémentant ses méthodes d'authentification, nous pouvons définir notre propre logique d'authentification. Par exemple, nous pouvons utiliser un backend d'authentification personnalisé pour implémenter une authentification basée sur LDAP ou OAuth.

Ce qui suit est un exemple d'utilisation d'un backend d'authentification personnalisé pour implémenter l'authentification basée sur LDAP :

from django.contrib.auth.backends import BaseBackend
import ldap

class LDAPBackend(BaseBackend):
    def authenticate(self, request, username=None, password=None, **kwargs):
        ldap_server = "ldap://example.com"
        ldap_base_dn = "ou=people,dc=example,dc=com"
        conn = ldap.initialize(ldap_server)
        try:
            conn.simple_bind_s("uid=%s,%s" % (username, ldap_base_dn), password)
            return User.objects.get(username=username)
        except ldap.INVALID_CREDENTIALS:
            return None

Dans l'exemple ci-dessus, nous définissons notre propre logique d'authentification en héritant de la classe BaseBackend de Django et en y implémentant la méthode d'authentification. Dans cette méthode, nous utilisons le module ldap de Python pour nous connecter au serveur LDAP et vérifier que le nom d'utilisateur et le mot de passe sont corrects via la méthode simple_bind_s. Si la vérification réussit, l'objet User est renvoyé.

Après avoir fini d'écrire le backend d'authentification personnalisé, nous devons spécifier la classe du backend d'authentification dans le fichier de paramètres de Django :

AUTHENTICATION_BACKENDS = ['path.to.LDAPBackend']

2. Utilisez Django-guardian pour un contrôle précis des autorisations

django-guardian est l'un des Django frameworks Une application tierce très puissante qui fournit des fonctions de contrôle des autorisations précises. Comparé au système d'authentification des autorisations intégré de Django, django-guardian fournit une méthode de contrôle des autorisations plus flexible et personnalisée.

Utiliser Django-guardian est très simple, il vous suffit d'installer et de spécifier AUTHENTICATION_BACKENDS et AUTHORIZATION_BACKENDS dans le fichier de paramètres de Django. Par exemple :

# settings.py

AUTHENTICATION_BACKENDS = ('django.contrib.auth.backends.ModelBackend',)

INSTALLED_APPS = (
    # ...
    'guardian',
)

MIDDLEWARE_CLASSES = (
    # ...
    'guardian.middleware.PermissionDeniedMiddleware',
)

AUTHORIZATION_BACKENDS = (
    'guardian.backends.ObjectPermissionBackend',
)

django-guardian fournit des décorateurs qui peuvent être utilisés pour contrôler l'accès à des objets spécifiques dans le modèle. Par exemple :

from django.views.generic import DetailView
from guardian.decorators import permission_required
from myapp.models import MyModel

@permission_required('myapp.view_mymodel', (MyModel, 'pk', 'pk'))
class MyModelDetailView(DetailView):
    model = MyModel

Dans l'exemple ci-dessus, nous avons utilisé le décorateur permission_required pour contrôler les autorisations d'accès de MyModel. Le décorateur doit spécifier les autorisations et les informations sur les objets à vérifier. Si la vérification des autorisations échoue, une exception PermissionDenied sera automatiquement levée.

3. Utilisez Django-rules pour le contrôle des autorisations basé sur des règles

django-rules est une autre application tierce très pratique qui fournit une fonctionnalité de contrôle des autorisations basée sur des règles. Comparé à Django-guardian, Django-rules est plus simple et léger.

L'utilisation de Django-rules est similaire à l'utilisation de Django-guardian. Il vous suffit d'installer et de spécifier AUTHENTICATION_BACKENDS et AUTHORIZATION_BACKENDS dans le fichier de paramètres de Django. Par exemple :

# settings.py

INSTALLED_APPS = (
    # ...
    'rules',
)

AUTHENTICATION_BACKENDS = ('django.contrib.auth.backends.ModelBackend',)

AUTHORIZATION_BACKENDS = ('rules.permissions.ObjectPermissionBackend',)

Utiliser Django-rules pour le contrôle des autorisations nécessite de définir un ensemble de règles, dont chacune contient une condition et un résultat. Si les conditions sont remplies, l'opération dans le résultat sera effectuée, sinon elle ne sera pas effectuée. Par exemple :

from rules import rule
from myapp.models import MyModel

@rule('view', 'myapp.view_mymodel')
def can_view_mymodel(user, mymodel):
    return True

@rule('change', 'myapp.change_mymodel')
def can_change_mymodel(user, mymodel):
    return user.is_superuser or user == mymodel.user

Dans l'exemple ci-dessus, nous avons défini deux règles pour contrôler les autorisations d'affichage et de modification de l'objet MyModel. Dans chaque règle, nous utilisons le décorateur de règles pour définir les conditions et les résultats. Deux paramètres, user et mymodel, doivent être transmis dans la condition de jugement d'autorisation. Si l'autorisation est accordée, vous pouvez continuer à effectuer les opérations suivantes.

Après avoir écrit les règles, nous devons ajouter les règles à Django :

# settings.py

RULES_MODULE = 'myapp.rules'

Dans l'exemple ci-dessus, nous utilisons RULES_MODULE pour spécifier le module Python où se trouvent les règles. De cette façon, Django peut charger automatiquement les règles au démarrage.

Résumé

Dans le framework Django, le contrôle des autorisations est une fonction très importante et essentielle. Grâce à certaines des techniques présentées ci-dessus, nous pouvons facilement implémenter des fonctions de contrôle d'autorisation basiques ou complexes. Qu'il s'agisse du système d'authentification intégré, du contrôle des autorisations basé sur le décorateur, du backend d'authentification personnalisé, de Django-Guardian ou des Django-Rules, nous pouvons choisir la méthode de contrôle des autorisations la plus appropriée en fonction des besoins spécifiques de l'entreprise.

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!