wake-up-neo.com

Django Rest Framework Token Authentication

Ich habe die Django Rest Framework Guides gelesen und alle Tutorials durchgearbeitet. Alles schien sinnvoll und funktionierte so, wie es sollte. Die Basis- und Sitzungsauthentifizierung funktionierte wie beschrieben. http : //Django-rest-framework.org/api-guide

Ich habe jedoch Probleme mit dem Teil "Token-Authentifizierung" in der Dokumentation, der ein wenig fehlt oder nicht so ausführlich ist wie die Tutorials.
http://Django-rest-framework.org/api-guide/authentication/#tokenauthentication

Es heißt, ich muss Token für Benutzer erstellen, gibt aber an, wo in models.py?

Meine Frage ist:

Kann jemand den Teil der Tokenauthentifizierung in der Dokumentation für einen Ersttimer etwas besser erklären?

70
Prometheus

Nein, nicht in Ihrer models.py - auf der Modellseite müssen Sie lediglich die entsprechende App (rest_framework.authtoken) in deinem INSTALLED_APPS. Dadurch wird ein Token-Modell bereitgestellt, das für den Benutzer mit einem Fremdschlüssel versehen ist.

Sie müssen lediglich entscheiden, wann und wie diese Tokenobjekte erstellt werden sollen. Bekommt in deiner App jeder Nutzer automatisch ein Token? Oder nur bestimmte autorisierte Benutzer? Oder nur auf ausdrücklichen Wunsch?

Wenn jeder Benutzer immer ein Token haben sollte, finden Sie auf der Seite, mit der Sie verlinkt sind, einen Codeausschnitt, der Ihnen zeigt, wie Sie ein Signal einrichten, um sie automatisch zu erstellen:

@receiver(post_save, sender=User)
def create_auth_token(sender, instance=None, created=False, **kwargs):
    if created:
        Token.objects.create(user=instance)

(setze this in eine models.py Datei, irgendwo, und es wird registriert, wenn ein Django Thread startet)

Wenn Token nur zu bestimmten Zeiten erstellt werden sollen, müssen Sie sie in Ihrem Ansichtscode zum richtigen Zeitpunkt erstellen und speichern:

# View Pseudocode
from rest_framework.authtoken.models import Token

def token_request(request):
    if user_requested_token() and token_request_is_warranted():
        new_token = Token.objects.create(user=request.user)

Sobald das Token erstellt (und gespeichert) wurde, kann es zur Authentifizierung verwendet werden.

61
Ian Clelland

@ Ian-Clelland hat bereits die richtige Antwort geliefert. Es gibt nur ein paar winzige Teile, die in seinem Beitrag nicht erwähnt wurden, daher werde ich die vollständigen Prozeduren dokumentieren (ich verwende Django 1.8.5 und DRF 3.2.4):

  1. Führen Sie die folgenden Schritte aus [~ # ~], bevor Sie [~ # ~] den Superuser erstellen. Andernfalls erhält der Superuser sein Token nicht erstellt.

  2. Gehen Sie zu settings.py und fügen Sie Folgendes hinzu:

    INSTALLED_APPS = (
        'rest_framework',
        'rest_framework.authtoken',
        'myapp',
    )
    
    REST_FRAMEWORK = {
        'DEFAULT_PERMISSION_CLASSES': (
            'rest_framework.permissions.IsAuthenticated',
        ),
        'DEFAULT_AUTHENTICATION_CLASSES': (
            'rest_framework.authentication.TokenAuthentication',
        )
    }
    
  3. Fügen Sie den folgenden Code in myapp 's models.py ein:

    from Django.db.models.signals import post_save
    from Django.dispatch import receiver
    from rest_framework.authtoken.models import Token
    from Django.conf import settings
    
    # This code is triggered whenever a new user has been created and saved to the database
    @receiver(post_save, sender=settings.AUTH_USER_MODEL)
    def create_auth_token(sender, instance=None, created=False, **kwargs):
        if created:
            Token.objects.create(user=instance)
    

    Wenn Sie expliziter sein möchten, erstellen Sie alternativ eine Datei mit dem Namen signals.py unter myapp project. Gib den obigen Code ein und schreibe dann in __ init __. Py import signals

  4. Öffnen Sie ein Konsolenfenster, navigieren Sie zu Ihrem Projektverzeichnis und geben Sie den folgenden Befehl ein:

    python manage.py migrate
    python manage.py makemigrations
    

    Werfen Sie einen Blick in Ihre Datenbank. Eine Tabelle mit dem Namen authtoken_token sollte mit den folgenden Feldern erstellt werden: key (dies ist der Token-Wert), created (das Datum und die Uhrzeit) es wurde erstellt), user_id (ein Fremdschlüssel, der auf die ID-Spalte der auth_user-Tabelle verweist)

  5. erstelle einen Superuser mit python manage.py createsuperuser. Schauen Sie sich jetzt die Tabelle authtoken_token in Ihrer DB mit select * from authtoken_token; An. Es sollte ein neuer Eintrag hinzugefügt worden sein.

  6. Mit curl oder einer viel einfacheren Alternative httpie zum Testen des Zugriffs auf Ihre API verwende ich httpie:

    http GET 127.0.0.1:8000/whatever 'Authorization: Token your_token_value'
    

    Das ist es. Von nun an müssen Sie für jeden API-Zugriff den folgenden Wert in den HTTP-Header aufnehmen (, achten Sie auf die Leerzeichen ):

    Authorization: Token your_token_value
    
  7. (Optional) DRF bietet auch die Möglichkeit, das Token eines Benutzers zurückzugeben, wenn Sie den Benutzernamen und das Kennwort angeben. Alles was Sie tun müssen, ist das Folgende in urls.py aufzunehmen:

    from rest_framework.authtoken import views
    
    urlpatterns = [
        ...
        url(r'^api-token-auth/', views.obtain_auth_token),
    ]
    

    Verwenden von httpie zur Überprüfung von:

    http POST 127.0.0.1:8000/api-token-auth/ username='admin' password='whatever'
    

    Im Rückkehrtext sollten Sie Folgendes sehen:

    {
        "token": "blah_blah_blah"
    }
    

Das ist es!

77
Cheng

Ein Django 1.8.2 und ein Rest-Framework 3.3.2 nach all dem oben Genannten reichten nicht aus, um die tokenbasierte Authentifizierung zu aktivieren.

Obwohl die Einstellung REST_FRAMEWORK in der Einstellungsdatei Django=) angegeben ist, sind funktionsbasierte Ansichten erforderlich @api_view decorator:

from rest_framework.decorators import api_view

@api_view(['POST','GET'])
def my_view(request):
    if request.user.is_authenticated():
       ...

Andernfalls wird überhaupt keine Tokenauthentifizierung durchgeführt

14
Super S

Um zwei Cent dazu zu addieren: Wenn Sie einen benutzerdefinierten Benutzermanager haben, der die Benutzererstellung (und -aktivierung) übernimmt, können Sie diese Aufgabe auch folgendermaßen ausführen:

from rest_framework.authtoken.models import Token
# Other imports

class UserManager(BaseUserManager):

    def create_user(self, **whatever_else):
        """
        This is your custom method for creating user instances. 
        IMHO, if you're going to do this, you might as well use a signal.

        """
        user = self.model(**whatever_params)
        .... #Method ramblings that somehow gave us a user instance
        Token.objects.create(user=user)

    #You may also choose to handle this upon user activation. 
    #Again, a signal works as well here.

    def activate_user(**activation_ramblings):
        .... #Method ramblings that somehow gave us a user instance
        Token.objects.create(user=user)

Wenn Sie bereits Benutzer erstellt haben, können Sie sich in die python Shell in Ihrem Terminal begeben und Tokens für alle Benutzer in Ihrer Datenbank erstellen.

>>>from *whatever import User
>>>from rest_framework.authtoken.models import Token 
>>>for user in User.objects.all():
>>>...    Token.objects.create(user=user)

Das ist alles, was sie geschrieben hat! Hoffe das hilft jemandem.

13
parsenz

Es gibt eine sauberere Möglichkeit, das Benutzertoken abzurufen.

führen Sie einfach die Shell manage.py aus

und dann

from rest_framework.authtoken.models import Token
from Django.contrib.auth.models import User
u = User.objects.get(username='admin')
token = Token.objects.create(user=u)
print token.key

dann sollte ein Satz in der Tabelle DB_Schema.authtoken_token gefunden werden

9

Zusätzlich zu den hervorragenden Antworten hier möchte ich einen besseren Ansatz für die Tokenauthentifizierung erwähnen: die JSON-Web-Token-Authentifizierung. Die Implementierung von http://getblimp.github.io/Django-rest-framework-jwt/ ist sehr einfach zu bedienen.

Die Vorteile werden in diese Antwort näher erläutert.

5
Def_Os