python - template - sesion django

Autenticación de token de marco de reposo Django

Question

He leído las Guías del Marco de Descanso de Django y he hecho todos los tutoriales. Todo parecía tener sentido y funcionar como debería. Obtuve la autenticación básica y de sesión trabajando como se describe. http://django-rest-framework.org/api-guide

Sin embargo, estoy luchando con la parte de autenticación de Token de la documentación, es un poco insuficiente o no profundiza tanto como los tutoriales.
http://django-rest-framework.org/api-guide/authentication/#tokenauthentication

Dice que necesito crear tokens para usuarios, pero ¿dónde, en models.py?

Mi pregunta es:

¿Alguien puede explicar la autenticación Token parte de la documentación un poco mejor para un primer contador de tiempo?

Answer 1

@ ian-clelland ya ha proporcionado la respuesta correcta. Solo hay unas pocas piezas pequeñas que no se mencionaron en su publicación, así que voy a documentar los procedimientos completos (estoy usando Django 1.8.5 y DRF 3.2.4):

1. Haga las siguientes cosas ANTES de crear el superusuario. De lo contrario, el superusuario no crea su token creado.

2. Vaya a settings.py y agregue lo siguiente:

   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. Agregue el siguiente código en myapp ''s models.py :

   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)

   Alternativamente, si quiere ser más explícito, cree un archivo llamado signals.py en el proyecto myapp . Pon el código de arriba en él, luego en __init__.py , escribe las import signals

4. Abra una ventana de consola, navegue a su directorio de proyecto e ingrese el siguiente comando:

   python manage.py migrate
   python manage.py makemigrations

   Eche un vistazo a su base de datos, debe crearse una tabla llamada authtoken_token con los siguientes campos: clave (este es el valor del token), creado (la fecha de creación), user_id (una clave externa que hace referencia a la columna id de la tabla auth_user)

5. crea un superusuario con python manage.py createsuperuser . Ahora, eche un vistazo a la tabla authtoken_token en su base de datos con select * from authtoken_token; , debería ver que se ha agregado una nueva entrada.

6. Usando curl o una alternativa mucho más simple de httpie para probar el acceso a tu API, estoy usando httpie:

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

   Eso es. A partir de ahora, para cualquier acceso a API, debe incluir el siguiente valor en el encabezado HTTP ( preste atención a los espacios en blanco ):

   Authorization: Token your_token_value

7. (Opcional) DRF también ofrece la posibilidad de devolver un token de usuario si proporciona el nombre de usuario y la contraseña. Todo lo que tiene que hacer es incluir lo siguiente en urls.py :

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

   Usando httpie para verificar:

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

   En el cuerpo de retorno, deberías ver esto:

   {
       "token": "blah_blah_blah"
   }

¡Eso es!

Answer 2

Además de las excelentes respuestas aquí, me gustaría mencionar un mejor enfoque para la autenticación de tokens: Autenticación de tokens web JSON. La implementación que ofrece http://getblimp.github.io/django-rest-framework-jwt/ es muy fácil de usar.

Los beneficios se explican con más detalle en esta respuesta .

Answer 3

En Django 1.8.2 y resto marco 3.3.2 después de todo lo anterior no fue suficiente para habilitar la autenticación basada en token.

Aunque la configuración de REST_FRAMEWORK se especifica en el archivo de configuración de django, las vistas basadas en función requieren @api_view decorator:

from rest_framework.decorators import api_view

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

De lo contrario, no se realiza autenticación de tokens en absoluto

Answer 4

Hay una manera más limpia de obtener el token de usuario.

simplemente ejecute el shell manage.py

y entonces

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

entonces se debe encontrar un registro en la tabla DB_Schema.authtoken_token

Answer 5

Solo para agregar mis dos centavos a esto, si tiene un administrador de usuarios personalizado que maneja la creación (y activación) del usuario, también puede realizar esta tarea de la siguiente manera:

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)

Si ya tiene usuarios creados, puede desplegarlos en el shell de Python en su terminal y crear Tokens para todos los usuarios en su base de datos.

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

¡Eso es todo lo que ella escribió, amigos! Espero que ayude a alguien.

Answer 6

No, no en su models.py - en el lado de los modelos, todo lo que necesita hacer es incluir la aplicación apropiada ( rest_framework.authtoken ) en su INSTALLED_APPS . Eso proporcionará un modelo de Token que tiene una clave externa para el Usuario.

Lo que debe hacer es decidir cuándo y cómo deben crearse esos objetos token. En tu aplicación, ¿todos los usuarios obtienen automáticamente una ficha? ¿O solo ciertos usuarios autorizados? ¿O solo cuando solicitan específicamente uno?

Si cada usuario siempre debe tener un token, hay un fragmento de código en la página a la que se vinculó que le muestra cómo configurar una señal para crearlos automáticamente:

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

(ponga esto en un archivo models.py, en cualquier lugar, y se registrará cuando se inicie un hilo de Django)

Si los tokens solo deben crearse en determinados momentos, entonces, en su código de vista, debe crear y guardar el token en el momento apropiado:

# 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)

Una vez que se crea (y se guarda) el token, será utilizable para la autenticación.