Creando una REST API con Django

Conceptos básicos

Antes de comenzar debemos definir qué es una REST API y a su vez qué es un servicio web.

Servicio web

Un servicio web es una tecnología que utiliza un conjunto de protocolos y estándares para intercambiar información entre diversas aplicaciones.

REST API

Una REST API (Representational State Transfer): es una arquitectura que, haciendo uso del protocolo HTTP, proporciona una API que utiliza cada uno de sus métodos (GET, POST, PUT, DELETE, etcétera) para poder realizar diferentes operaciones entre la aplicación que ofrece el servicio web y el cliente.

Tutoriales python y django:

• Tutoriales de python básicos
• Curso acelerado de Python
• Curso de python en Codecademy
• Tutorial básico django
• Fundamentos de Django
• Curso recomendado: Mi primera app en django

Creando nuestra REST API

Existen diversas tecnologías para crear una REST API, en este tutorial se utilizará Django para desarrollarla.

Instalando python

Basado en el tutorial Django
Django es un framework web ( para el desarrollo de aplicaciones web) derivado del lenguaje de programación Python. Es por ello que lo primero que necesitamos es instalar Python en nuestra pc. Linux y Mac vienen con python instalado de fábrica. Para windows, necesitamos seguir las instrucciones desde aquí

Usuarios de Windows

Para instalar python, primero debemos ir a la página de descargas de python y descargar la última versión de python para windows. La última versión cuando se hizo este tutorial fue la 3.6.4.

La instalación es muy sencilla, sólo debemos marcar las opciones install launcher for all users y add python 3.6 to path y dar clic en install now. Se abrirá una ventana de administrador y le damos continuar. El asistente instalará python y cuando finaliza pregunta si queremos deshabilitar los caracteres limites del path, le damos clic en esa opción y listo, tendremos python instalado en nuestra computadora.

Para comprobar que python se ha instalado, abrimos la terminal (cmd) y ejecutamos el siguiente comando y nos debe dar la versión :

python --version
Python 3.6.4

Crear entorno virtual

Antes de instalar Django, instalaremos una herramienta extremadamente útil que ayudará a mantener tu entorno de desarrollo ordenado en su computadora. Es posible omitir este paso, pero es muy recomendable no hacerlo - ¡comenzar con la mejor configuración posible ayuda a evitar muchos problemas en el futuro!

Así que, vamos a crear un entorno virtual (también llamado un virtualenv). Aislará la configuración Python/Django con base en cada proyecto, lo que significa que cualquier cambio que realices en un sitio web no afectará a otros que también estés desarrollando. Genial, ¿no?

Todo lo que necesitas hacer es encontrar un directorio en el que desees crear el virtualenv; tu directorio home, por ejemplo. En Windows puede verse como C:\Users\Name (donde nombre es el nombre de tu usuario).

Para este tutorial usaremos un nuevo directorio uaehdriia en tu directorio home, para ello ejecutamos el siguiente comando:

mkdir uaehdriia
cd uaehdriia

Windows

Para crear un nuevo virtualenv, debes abrir la consola y ejecutar python -m venv myvenv. Se verá así:

python -m venv uaehenv

en donde myvenv es el nombre de tu virtualenv. Puedes utilizar cualquier otro nombre, pero asegúrate de usar minúsculas y no dejar espacios, acentos o caracteres especiales. También es una buena idea mantener el nombre corto.

Trabajar con virtualenv

Lo primero que tenemos que hacer es habilitar los permisos para ejecutar scripts desde power shell. Para dicha tarea seguimos las instrucciones de Habilitar scripts en powershell.

En el paso anterior creamos un entorno virtual llamado uaehenv (o cualquier nombre que hayas escogido) que contiene nuestro entorno virtual (básicamente un montón de archivos y carpetas). Todo lo que queremos hacer ahora es iniciarlo, para windows, abrimos la terminal (power shell), nos dirigimos a la carpeta en donde está nuestro proyecto y ejecutamos:

.\uaehenv\Scripts\activate

Si todo sale bien, nuestra terminal tendrá el siguiente aspecto:

(uaehenv) PS C:\Users\User\uaehdriia\

¡Nota que el prefijo (uaehenv) aparece! (uaehenv) indica que el entorno está activado. Para desactivarlo basta con ejecutar en la terminal el comando:

deactivate

Tenemos todas las dependencias importantes en su lugar. ¡Finalmente podemos instalar Django!

Instalar Django

Con el entorno virtual uaehenv iniciado, puedes instalar Django usando pip. En la consola, ejecuta pip install django . Asegúrate que el prefijo (uaehenv) se muestra en la terminal.

pip install django
Downloading/unpacking django==1.8
Installing collected packages: django
Successfully installed django
Cleaning up...

En Windows

Si obtienes un error al ejecutar pip en Windows comprueba si la ruta de tu proyecto contiene espacios, acentos o caracteres especiales (por ejemplo, C:\Users\User Name\uaehenv). Si lo tiene, por favor considera moverla a otro lugar sin espacios, acentos o caracteres especiales (sugerencia: C:\uaehenv). Después de hacerlo ejecuta nuevamente el comando anterior.

¡Eso es todo! ¡Ahora estás listo (por fin) para crear una aplicación Django!

¡Crear proyecto en Django

El primer paso para crearlo es iniciar un nuevo proyecto en Django. Básicamente, esto significa que podrás correr algunos scripts proporcionados por Django que crearán el esqueleto de un proyecto para nosotros: un montón de directorios y archivos que vamos a utilizar más adelante.

Los nombres de algunos archivos y directorios son muy importantes para Django. No deberías renombrar los archivos que estamos a punto de crear. Moverlos a un lugar diferente tampoco es una buena idea. Django tiene que mantener una cierta estructura para ser capaz de encontrar cosas importantes.

Recuerda correr todo en el virtualenv. Si no ves un prefijo (myvenv) en tu consola necesitas activar tu virtualenv. Puedes hacerlo escribiendo el siguiente comando: .\myvenv\Scripts\activate en Windows o source myvenv/bin/activate en Mac OS / Linux.

Para crear el proyecto de debe ejecutar el siguiente comando en la consola:
En Windows:

django-admin.py startproject mysite 

Al finalizar el comando, verás que se crearán los siguientes

mysite
├───manage.py
└───mysite
        settings.py
        urls.py
        wsgi.py
        __init__.py

manage.py es un script que ayuda con la administración del sitio. Con ello podremos iniciar un servidor web en nuestro ordenador sin necesidad de instalar nada más, entre otras cosas.

El archivo settings.py contiene la configuración de tu sitio web.

El archivo urls.py contiene una lista de los patrones utilizados por urlresolver.

Ignoremos los otros archivos por ahora - no los cambiaremos. ¡Lo único que debes recordar es no borrarlos por accidente!

Cambiando la configuración

Vamos a hacer algunos cambios en mysite/settings.py. Abre el archivo usando el editor de código.

Por el momento vamos a permitir que todos los hosts puedan acceder a nuestra app, para ello en el archivo settings.py ponemos:

ALLOWED_HOSTS = ['*'] 

Vamos a poner la ruta de los templates externos 'DIRS': [os.path.join(BASE_DIR, 'templates')],:

TEMPLATES = [
 {
  'BACKEND': 'django.template.backends.django.DjangoTemplates',
  'DIRS': [os.path.join(BASE_DIR, 'templates')],
  'APP_DIRS': True,
  'OPTIONS': {
   'context_processors': [
   'django.template.context_processors.debug',
   'django.template.context_processors.request',
   'django.contrib.auth.context_processors.auth',
   'django.contrib.messages.context_processors.messages',
   ],
  },
 },
]

También vamos a configurar el lenguaje:

LANGUAGE_CODE = 'es-ES'

Sería bueno tener el horario correcto en nuestro sitio web. Ve a la lista de husos horarios de Wikipedia y copia tu zona horaria (TZ). (por ejemplo, Europe/Berlin )

En settings.py, encuentra la línea que contiene TIME_ZONE y modifícala para elegir tu propia zona horaria:

TIME_ZONE = 'Europe/Berlin'

Modificando “Europe/Berlin” como corresponda

También necesitaremos agregar una ruta para los archivos estáticos (aprenderemos todo sobre los archivos estáticos y CSS más tarde en este tutorial). Ve hacia abajo hasta el final del archivo, y justo por debajo de la entrada STATIC_URL, agrega una nueva llamada STATIC_ROOT:

STATIC_URL = '/static/'
STATIC_ROOT = os.path.join(BASE_DIR, 'static')

Configurar una base de datos

Hay una gran variedad de opciones de bases de datos para almacenar los datos de tu sitio. Utilizaremos el que viene por defecto, sqlite3.

Esto ya está configurado en esta parte de tu archivo mysite/settings.py:

    DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.sqlite3',
            'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
        }
    }

Para crear una base de datos para nuestro blog, ejecutemos lo siguiente en la consola:

manage.py migrate

(necesitamos estar en el directorio de mysite que contiene el archivo manage.py). Si eso va bien, deberías ver algo así en la consola:

python manage.py migrate
Operations to perform:
  Apply all migrations: admin, contenttypes, auth, sessions
Running migrations:
  Applying contenttypes.0001_initial... OK
  Applying auth.0001_initial... OK
  Applying admin.0001_initial... OK
  Applying sessions.0001_initial... OK

¡Y listo! ¡Es hora de iniciar el servidor web y ver si nuestro sitio web está funcionando!

Debes estar en el directorio que contiene el archivo manage.py (en la carpeta mysite). En la consola, podemos iniciar el servidor web ejecutando python manage.py runserver:

python manage.py runserver

Ahora todo lo que debes hacer es verificar que tu sitio esté corriendo - abre tu navegador (Firefox, Chrome, Safari, Internet Explorer o el que utilices) e ingresa la dirección:http://127.0.0.1:8000/ y verás algo como lo siguiente:

El servidor web se apropiará de tu consola hasta que lo termines manualmente: para tipear más comandos o abres una nueva terminal (y no te olvides de activar tu virtualenv allí también), o frena el servidor web yendo a la consola en la que está corriendo y presionando Ctrl+C - las teclas Control y C juntas (en Windows, deberás presionar Ctrl + Break).

¡Felicitaciones! ¡Has creado tu primer sitio web y lo has ejecutado usando un servidor web! ¿No es genial?

Ahora que hemos creado el proyecto, es momento de añadir algo de contenido a nuestro proyecto. La manera en la que Django genera una base de datos y todas las tablas necesarias es a través de modelos.

Modelos

Lo que queremos crear ahora es algo que va a almacenar todos los posts en nuestro blog. Pero para poder hacerlo tenemos que hablar un poco acerca de algo llamado objetos.

Objetos

Hay un concepto en el mundo de la programación llamado programación orientada a objetos. La idea es que en lugar de escribir todo como una aburrida secuencia de instrucciones de programación podemos modelar cosas y definir cómo interactúan con las demás.

Entonces ¿Qué es un objeto? Es un conjunto de propiedades y acciones. Suena raro, pero te daremos un ejemplo.

Si queremos modelar un gato crearemos un objeto Gato que tiene algunas propiedades, como son por ejemplocolor, edad, estado de ánimo (es decir, bueno, malo, sueño ;)), dueño (que es un objeto Persona o, tal vez, en el caso de que el gato sea callejero, esta propiedad estará vacía).

Y luego el Gato tiene algunas acciones: ronronear, rasguñar o alimentarse (en la cual daremos al gato algunos ComidaDeGato, que podría ser un objeto independiente con propiedades, como por ejemplo, sabor).

Gato
---------
color 
edad 
humor 
dueño 
ronronear() 
rasguñar() 
alimentarse(comida_de_gato) 

ComidaDeGato
----------
sabor

Básicamente se trata de describir cosas reales en el código con propiedades (llamadas propiedades del objeto) y las acciones (llamadas métodos).

Y ahora, ¿cómo modelamos los posts en el blog? Queremos construir un blog, ¿no?

Tenemos primero que responder algunas preguntas: ¿Qué es un post de un blog? ¿Qué características debe tener?

Bueno, seguro que nuestros posts necesitan un texto con su contenido y un título, ¿cierto? También sería bueno saber quién lo escribió, así que necesitamos un autor. Por último, queremos saber cuándo el post fue creado y publicado.

Post
--------
title
text
author
created_date
published_date

¿Qué tipo de cosas podría hacerse con una entrada del blog? Sería bueno tener algún método que publique la entrada, ¿no?

Así que vamos a necesitar el método publicar.

Puesto que ya sabemos lo que queremos lograr, ¡podemos empezar a moderlarlo en Django!

Modelo en Django

Sabiendo qué es un objeto, podemos crear un modelo en Django para nuestros posts en el blog.

Un modelo en Django es un tipo especial de objeto que se guarda en la base de datos. Una base de datos es una colección de datos. Allí es el lugar en el cual almacenarás la información sobre usuarios, posts del blog, etc. Utilizaremos una base de datos SQLite para almacenar nuestros datos. Este es el adaptador de base de datos predeterminada en Django – será suficiente para nosotros por ahora.

Piensa en el modelo en la base de datos como una hoja de cálculo con columnas (campos) y filas (datos).

Creando una aplicación

Para mantener todo en orden, crearemos una aplicación separada dentro de nuestro proyecto. Es muy bueno tener todo organizado desde el principio. Para crear una aplicación, necesitamos ejecutar el siguiente comando en la consola (dentro de la carpeta de mysite donde está el archivo manage.py):

Nota debes asegurarte que tu entorno virtual esté activo. activar entorno

python .\manage.py startapp blog

Vas a notar que se crea un nuevo directorio llamado blog y contiene una serie de archivos. Nuestros directorios y archivos en nuestro proyecto deberían parecerse a esto:

mysite
├── mysite
|       __init__.py
|       settings.py
|       urls.py
|       wsgi.py
├── manage.py
└── blog
    ├── migrations
    |       __init__.py
    ├── __init__.py
    ├── admin.py
    ├── models.py
    ├── tests.py
    └── views.py

Después de crear una aplicación también necesitamos decirle a Django que debe utilizarla. Lo hacemos en el archivo mysite/settings.py. Tenemos que encontrar INSTALLED_APPS y añadir una línea que contenga 'blog', justo por encima de ). El producto final debe tener este aspecto:

    INSTALLED_APPS = (
        'django.contrib.admin',
        'django.contrib.auth',
        'django.contrib.contenttypes',
        'django.contrib.sessions',
        'django.contrib.messages',
        'django.contrib.staticfiles',
        'blog',
    )

Creando el Modelo Post

En el archivo blog/models.py definimos todos los objetos llamados Models - este es un lugar en el cual definiremos nuestro modelo post.

Vamos abrir blog/models.py, quitamos todo y escribimos un código como este:

from django.db import models
from django.utils import timezone

class Post(models.Model):
    author = models.ForeignKey('auth.User',on_delete=models.CASCADE)
    title = models.CharField(max_length=200)
    text = models.TextField()
    created_date = models.DateTimeField(default=timezone.now)
    published_date = models.DateTimeField(blank=True, null=True)

    def publish(self):
        self.published_date = timezone.now()
        self.save()

    def __str__(self):
     return self.title

Vuelve a verificar que usaste dos guiones bajos (_) en cada lado del str. Estos se utilizan con frecuencia en Python y a veces también los llamamos “dunder” (diminutivo en inglés de “double-underscore”).

Todas las líneas que comienzan con from o import son líneas para añadir algo de otros archivos. Así que en vez de copiar y pegar las mismas cosas en cada archivo, podemos incluir algunas partes con from... import ....

class Post(models.Model): - esta línea define nuestro modelo (es un objeto).

• class es una palabra clave que indica que estamos definiendo un objeto.
• Post es el nombre de nuestro modelo. Podemos darle un nombre diferente (pero debemos evitar espacios en blanco y caracteres especiales). Una clase siempre comienza con su primera letra en mayúscula.
• models.Model significa que Post es un modelo de Django, así Django sabe que debe guardarlo en la base de datos.

Ahora definimos las propiedades que hablábamos: title, text, created_date, published_date y author. Para hacer eso tenemos que definir un tipo de campo (¿es texto? ¿un número? ¿una fecha? ¿una relación con otro objeto - es decir, un usuario?).

• models.CharField - así es como defines un texto con un número limitado de caracteres.
• models.TextField - esto es para textos largos sin un límite. Será ideal para el contenido de un post, ¿verdad?
• models.DateTimeField - esto es fecha y hora.
• modelos.ForeignKey - este es un vínculo con otro modelo.

No vamos a explicar cada pedacito de código, ya que nos tomaría demasiado tiempo. Debes echar un vistazo a la documentación de Django si quieres saber más sobre los campos de los Modelos y cómo definir cosas diferentes a las descritas anteriormente (tipos de datos Django).

¿Y qué sobre def publish(self):? def significa que se trata de una función o método. publish es el nombre del método. Puedes cambiarlo, si quieres. La regla es que usamos minúsculas y guiones bajos en lugar de espacios (es decir, si quieres tener un método que calcule el precio medio, este podría llamarse calculate_average_price).

Los métodos muy a menudo devuelven algo. Hay un ejemplo de esto en el método __str__. En este escenario, cuando llamamos a __str__() obtendremos un texto (string) con un título de Post.

Si algo todavía no está claro sobre modelos, ¡no dudes en preguntar a tu tutor! Sabemos que es muy complicado, sobre todo cuando estás entendiendo qué son funciones y objetos mientras sigues este documento. Con suerte, ¡todo tiene un poco más de sentido para ti ahora!

Crear tablas para los modelos en tu base de datos

El último paso es añadir nuestro nuevo modelo a nuestra base de datos. Primero tenemos que hacer que Django sepa que tenemos algunos cambios en nuestro modelo (acabamos de crearlo), escribe python manage.py makemigrations blog. Se verá así:

python manage.py makemigrations blog
Migrations for 'blog':
  0001_initial.py:
  - Create model Post

Django preparará un archivo de migración que tenemos que aplicar ahora a nuestra base de datos escribiendo python manage.py migrate blog. El resultado debe ser:

python manage.py migrate blog
Operations to perform:
  Apply all migrations: blog
Running migrations:
  Applying blog.0001_initial... OK

Administrador de Django

El primer paso en la administración de una aplicación en Django es crear un super usuario (un usuario que tiene control sobre todo lo que hay en el sitio). Ve a la terminal y ejecuta python manage.py createsuperuser, presiona enter y escribe tu nombre de usuario (en minúsculas, sin espacios), dirección de email y contraseña cuando sean requeridos. No te preocupes que no puedes ver tu contraseña mientras la tipeas - así es como debe ser. Simplemente escribela y presiona ‘Enter’ para continuar. La salida de este comando debería verse así (nombre de usuario y email deberían ser los tuyos) (terminal):

python manage.py createsuperuser
Username: admin
Email address: admin@admin.com
Password:
Password (again):
Superuser created successfully.

Para agregar, editar y borrar los posts que hemos modelado, utilizaremos el administrador de Django.

Vamos a abrir el archivo blog/admin.py y reemplazar su contenido con esto:

    from django.contrib import admin
    from .models import Post

    admin.site.register(Post)

Como puedes ver, importamos (incluimos) el modelo Post definido en el capítulo anterior. Para hacer nuestro modelo visible en la página del administrador, tenemos que registrar el modelo con admin.site.register(Post).

Ok, es hora de ver tu modelo Post. Recuerda ejecutar python manage.py runserver en la consola para correr el servidor web. Ve al navegador y tipea la dirección http://127.0.0.1:8000/admin/. Verás una página de ingreso como la que sigue:

Ingresa con las credenciales de super usuario que elegiste, ahora deberías poder ver el panel de administración de Django.

Dirígete a Posts y experimenta un poco con esto. Agrega cinco o seis posts del blog. No te preocupes por el contenido - puedes simplemente copiar y pegar texto de este tutorial en el contenido de tus posts para ahorrar tiempo :).

Asegúrate de que por lo menos dos o tres posts (pero no todos) tienen la fecha de publicación. Será útil luego.

Si quieres saber más sobre el administrador de Django, puedes visitar la documentación de Django: Administrador de Django

Creando nuestra REST API

Ahora que tenemos nuestros modelos podemos crear nuestro REST API. Para ello debemos instalar Django REST API. Para instalar debemos activar nuestro entorno virtual y ejecutar el siguiente comando en la consola:

pip install djangorestframework

Una vez instalado nos vamos a nuestro archivo settings.py y agregamos rest_framework a nuestra lista de aplicaciones instaladas:

INSTALLED_APPS = (
    ...
    'rest_framework',
)

Con esta configuración tenemos todo listo para crear nuestros serializadores y crear nuestra API.

Creando serializadores

Para crear nuestra API debemos crear nuestros serializadores. Mediante nuestros serializadores vamos a decidir qué modelos de nuestra base de datos van a ser serializados para poder ser transmitidos por la red.

Dentro de la carpeta blog de nuestra aplicación vamos a crear un nuevo archivo al cual le daremos el nombre de serializers.py.

En este archivo vamos a importar serializers de rest_framework e importar nuestro modelo llamado Post que hemos creado con anterioridad.
Posteriormente crearemos una clase que va a extender de serializers.ModelSerializer. Esta clase contendrá una clase llamada Meta con dos atributos:

• model: Indica el modelo que va a serializar
• fields: Indica los campos a serilizar (podemos utilizar __all__ para indicar que todos los campos se incluirán en nuestro serializador)

Nuestro archivo serializer.py quedará de la siguiente manera:

from rest_framework import serializers
from .models import Post

class PostSerializer(serializers.ModelSerializer):
    class Meta:
        model = Post
        fields = '__all__'

Creando viewsets

Ahora que tenemos nuestros serializadores es momento de generar nuestros view sets. Para ello nos dirigimos a nuestro archivo blog/views.py y creamos nuestra view set de la siguiente manera:

• Importamos viewsets de rest_framework
• Importamos nuestro serializador que hemos creado de nuestro modelo Post
• Importamos nuestro modelo Post
• Creamos nuestro PostViewSet de la siguiente manera:
  1. Creamos una clase que extienda de viewsets.ModelViewSet
  2. Agregamos dos atributos requeridos :
  queryset: La consulta que se ejecutará hacia la base de datos y que se mostrará en la API.
  serializer_class: Nuestra clase que hemos serializado en serializers.py

from rest_framework import viewsets
from .serializers import PostSerializer
from .models import Post

# Create your views here.
class PostViewSet(viewsets.ModelViewSet):
queryset = Post.objects.all()
serializer_class = PostSerializer

Asignando una URL a nuestra API

Por último debemos asignar una url a nuestro POST que hemos serializado y al cual hemos creado su viewset. Para ello nos dirigimos al archivo llamado urls.py dentro de la carpeta mysite (mysite/urls.py) y damos de alta nuestra url de la siguiente manera:

1. Importamos routers de rest_framework
2. Importamos nuestro PostViewSet desde nuestra las vistas de nuestra app de blog
3. Declaramos una variable la cual la igualamos a routers.DefaultRouter()
4. Registramos nuestro view set y le asignamos una dirección
5. Agregamos router.urls a nuestro path

from django.contrib import admin
from django.urls import path, include
from rest_framework import routers
from blog.views import PostViewSet

router = routers.DefaultRouter()
router.register(r'posts', PostViewSet)

urlpatterns = [
 path('admin/', admin.site.urls),
 path('api/', include(router.urls)),
]

¡Listo ! Hemos creado nuestra primera API con Django. Para verificar que todo está funcionando correctamente en la consola ejecutamos: ( Iniciamos el servidor)

python manage.py runserver

Y nos dirigimos a la url que le asignamos a nuestro Post API :
localhost:8000/api/posts

Si todo ha salido bien, veremos una pagina como la siguiente en donde se pueden ver la lista de posts serializados y listos para ser consumidos desde cualquier aplicación:

Creando sistema de registro y autenticación

Hasta el momento, nuestra API funciona de manera correcta, sin embargo no hemos especificado os permisos ni restricciones de acceso a nuestra base de datos. Por consiguiente, cualquier persona puede acceder a nuestra base de datos y hacer peticiones HTML, por lo que nuestra base de datos es vulnerable a ataques y no posee seguridad.

Para corregir ese problema debemos especificar a nuestro proyecto de Django los permisos y restricciones que nuestra API debe tener.
Django Rest Framework cuenta con diferentes métodos de autenticación, sin embargo, uno de los métodos más comunes es por medio de tokens.
Django Rest Framework tiene un par de librerías que simplifican la tarea de crear un sistema de registro y acceso. Para este ejemplo nosotros utilizaremos la librería llamada django-rest-auth.
El primer paso es instalar django-rest-auth. Para dicha tarea ejecutamos en la terminal:

pip install django-rest-auth
pip install django-allauth

Nota: Recuerda tener el entorno virtual activado activar entorno.

Una vez instalado nos dirigimos al archivo de settings.py dentro de la carpeta mysite (mysite/settings.py) y agregamos rest_framework, rest_framework.authtoken rest_auth ,django.contrib.sites, allauth, allauth.account yrest_auth.registration a nuestras aplicaciones instaladas, y abajo de las aplicaciones instaladas añadir la siguientes constantes SITE_ID = 1 y EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend':

INSTALLED_APPS = [
    ...,
    'rest_framework',
    'rest_framework.authtoken',
    ...,
    'rest_auth',
    'django.contrib.sites',
    'allauth',
    'allauth.account',
    'allauth.socialaccount',
    'rest_auth.registration',
]

SITE_ID = 1
EMAIL_BACKEND = 'django.core.mail.backends.console.EmailBackend'

Así mismo, en el mismo archivo de settings.py añadimos hasta la última líneas de código lo siguiente:

REST_FRAMEWORK = {
 'DEFAULT_AUTHENTICATION_CLASSES': (
  'rest_framework.authentication.SessionAuthentication',
  'rest_framework.authentication.TokenAuthentication',
  'rest_framework.authentication.BasicAuthentication',
 ),
 'DEFAULT_PERMISSION_CLASSES': (
  'rest_framework.permissions.IsAuthenticated',
 )
}

Posteriormente nos dirigimos al archivo urls.py dentro de la carpeta mysite y añadimos la siguiente ruta:

urlpatterns = [
    ...,
    path('rest-auth/', include('rest_auth.urls')),
    path('rest-auth/registration/', include('rest_auth.registration.urls')),
]

Por último nos dirigimos a nuestra terminal y migramos nuestra base de datos (terminal):

python manage.py migrate

Para poder utilizar nuestra API en cualquier aplicación es necesario instalar corsheaders:
Abrimos una terminal, activamos el entorno virtual y ejecutamos:

pip install django-cors-headers

Posteriormente nos dirigimos al archivo de settings.py dentro de la carpeta mysite (mysite/settings.py) y agregamos corsheaders a nuestras aplicaciones instaladas y agregamos la constante CORS_ORIGIN_ALLOW_ALL = True:

INSTALLED_APPS = [
    ...
    'corsheaders',
    ...
]

CORS_ORIGIN_ALLOW_ALL = True

En el mismo archivo de settings.py agregamos al principio de nuestro MIDDLEWARE 'corsheaders.middleware.CorsMiddleware' y 'django.middleware.common.CommonMiddleware':

Nota: es importante agregarlos al principio.

MIDDLEWARE = [  
    'corsheaders.middleware.CorsMiddleware',
    'django.middleware.common.CommonMiddleware',
    ...
]

Si todo ha salido bien tendremos nuestra API con seguridad y sistema de registro lista para utilizar. Para poder hacer peticiones html desde cualquier otra aplicación, primero debemos registrar/acceder usuarios y posteriormente utilizar los token que nos devuelva nuestro rest-auth api. En la siguiente página encontrarás una lista de todos los métodos disponibles de django-rest-auth:

API endpoints rest-auth