Django Rest Framework é um framework Python baseado na estrutura do Django e dedicado à construção de APIs . Com este framework , podemos construir APIs REST de modo fácil e flexível , aproveitando-se das diversas estruturas que o framework oferece para personalizar a aplicação. Neste tutorial, vamos instalar o DRF e construir uma API do zero com esta incrível ferramenta!

Requisitos

Para dar continuidade a este tutorial é necessário o Python 3 instalado e do gerenciador de pacotes pip:

https://www.python.org/downloads/

https://pip.pypa.io/en/stable/installing/

Além disso, isolar as dependências de uma aplicação Python é sempre recomendado. Para tanto, vamos utilizar o virtualenv para criar um ambiente virtual para a aplicação. Basta executar o seguinte comando:

pip install virtualenv

Configurações iniciais

Primeiramente, vamos criar uma pasta para o projeto (estou utilizando um ambiente Linux para este tutorial):

$ mkdir api-drf/ && cd api-drf

Em seguida, criar um ambiente virtual com o virtualenv:

$ virtualenv api-drf-venv -p python

O parâmetro api-drf-venv indica o nome do ambiente virtual do projeto (uma pasta com esse nome será criado no diretório atual) e pode ser substituído por qualquer outro nome. A opção -p do virtualenv espera como parâmetro o local (path) do interpretador Python instalado. Neste caso, basta passar o comando python.

Agora precisamos ativar esse ambiente virtual:

$ source api-drf-venv/bin/activate

O comando source do Linux lê e executa uma série de comandos escritos em um arquivo. Neste caso, os comandos estão escritos no arquivo api-drf-venv/bin/activate .  Após a ativação, podemos instalar as dependências (Django e o Django Rest Framework) e garantir que estarão disponíveis apenas para este projeto:

(api-drf-venv) $ pip install django djangorestframework

Caso queira sair do ambiente virtual, utilize o comando deactivate.

Após a instalação, podemos consultar a lista de dependências do projeto com o comando list do pip:

(api-drf-venv) $ pip list

Veja que além do Django e o DRF, o pip instalou outros pacotes que são necessários tanto para a sua execução como também dos frameworks WEB:

• asgiref (Asynchronous Server Gateway Interface): software que provê uma interface padrão de comunicação entre aplicações assíncronas desenvolvidas em Python e servidores WEB. Basicamente, o objetivo do ASGI é substituir o WSGI (padrão utilizado pelo Django) que processa apenas requisições síncronas.
• pytz (World Timezone Definitions for Python): basicamente uma biblioteca para realizar cálculos de fuso horário.
• setuptools: biblioteca para criação de pacotes Python distribuíveis.
• sqlparse: software que oferece suporte a análise de código SQL.
• wheel: formato de pacotes Python que não necessitam de compilação para serem instalados.

*Outras dependências podem ser adicionadas com tempo, portanto não é garantido que seja a mesma lista.

Para este tutorial não precisamos de mais detalhes sobre esses pacotes, uma vez que são dependências dos frameworks que instalamos (Django, DRF e pip). De toda forma, recomendo pesquisar um pouco mais sobre essas bibliotecas, pois elas compõem a maioria das aplicações desenvolvidas em Python e muitas delas são consideradas como bibliotecas de uso padrão em softwares escritos com a linguagem.

Chegamos no momento de iniciar o nosso projeto e, para tanto, devemos iniciar um projeto Django:

(api-drf-venv) $ django-admin startproject api_drf .

O django-admin é a interface CLI (Command Line Interface) do Django para gerenciar a aplicação. Com ele, podemos verificar se existe algum erro na produção do software (check), criar migrações entre os modelos do framework e o banco de dados (makemigrations) e criar novos aplicativos (startapp).  Por meio do comando startproject , criamos um projeto chamado api_drf e indicamos o diretório atual para descarregar os arquivos padrão do Django. Um desses arquivos descompactados é o gerenciador de comandos manage.py que, além das opções do django-admin, oferece funções para sessões, arquivos estáticos e autenticação.  A estrutura atual do projeto deve ser a seguinte:

Antes de testar o funcionamento do servidor Django, devemos realizar as migrações dos modelos dos módulos admin, auth, contenttypes e sessions para o banco de dados, uma vez que por padrão esses modelos já estão mapeados pelo ORM do Django e falta apenas criar as tabelas no banco de dados registrado no arquivo de configuração do framework:

(api-drf-venv) $ python manage.py migrate

Por padrão o Django utiliza o SQLite3 e podemos conferir que o arquivo db.sqlite3 foi criado no diretório raiz do nosso projeto:

Agora podemos executar a opção runserver e, em seguida, acessar http://localhost:8000 :

(api-drf-venv) $ python manage.py runserver

Criação da API com Django Rest Framework

Por enquanto apenas iniciamos um projeto Django. Para criar a nossa API devemos criar um app com o seguinte comando:

(api-drf-venv) $ python manage.py startapp api_song

O argumento api_song é o nome e diretório da nossa API e, antes de tudo, precisamos registrá-lo no módulo de configuração do Django que está em api-drf/api_song/settings.py. Nesse módulo, o Django define as suas configurações básicas, como: registro e carregamento de aplicações complementares (no caso o DRF), configurações de banco de dados, idioma, fuso horário, entre outras. Para o nosso caso, devemos incluir api_song.apps.ApiSongConfig e rest_framework na lista INSTALLED_APPS no módulo settings.py:

# api-drf/api_song/settings.py
INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    # internal apps
    'api_song.apps.ApiSongConfig',
    # external apps
    'rest_framework'
]

Em seguida, vamos criar um modelo de dados os quais serão persistidos e consumidos pela API:

# api-drf/api_song/models.py

from django.db import models

class Song(models.Model):
    name = models.CharField('Name', max_length=50)
    comments = models.TextField('Comments')

    def __str__(self):
        return f'Song: {self.name}; Comments: {self.comments}'

O nosso modelo é simples e terá apenas uma tabela com nomes de músicas e comentários sobre cada música.

Agora precisamos configurar o modo de serialização e desserialização desse modelo de dados para um objeto JSON. Para tanto, vamos criar um módulo serializers.py no diretório da API e aproveitar a classe ModelSerializer do pacote serializers do DRF:

# api-drf/api_song/serializers.py

from rest_framework import serializers
from api_song.models import Song

class SongModelSerializer(serializers.ModelSerializer):
    class Meta:
        model = Song
        fields = ['name', 'comments']

Depois de criar o nosso modelo de dados e a forma de transformá-lo em JSON, temos que criar uma view para receber as requisições e respondê-las adequadamente. O DRF possui várias formas de realizar essas operações (ver Tutorial 3: Class-based Views), mas, para simplificar, vamos utilizar o pacote generics e as classes ListCreateAPIView (GET e POST) e RetrieveUpdateDestroyAPIView (PUT e DELETE):

# api-drf/api_song/views.py

from rest_framework import generics
from api_song.serializers import SongModelSerializer
from api_song.models import Song

class SongListGenerics(generics.ListCreateAPIView):
    queryset = Song.objects.all()
    serializer_class = SongModelSerializer

class SongDetailGenerics(generics.RetrieveUpdateDestroyAPIView):
    queryset = Song.objects.all()
    serializer_class = SongModelSerializer

Agora basta criar as rotas em api_song/urls.py e incluir esse módulo em tutorial/urls.py:

# api-drf/api_song/urls.py

from django.urls import path
from rest_framework.urlpatterns import format_suffix_patterns
from api_song import views

urlpatterns = [
    path('songs/', views.SongListGenerics.as_view()),
    path('songs/<int:pk>/', views.SongDetailGenerics.as_view()),
]

urlpatterns = format_suffix_patterns(urlpatterns)

# api-drf/api_song/urls.py

from django.contrib import admin
from django.urls import path, include

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

Antes de testar a nossa api, temos que rodar os comandos makemigrations e migrate para criar a tabela do nosso modelo no banco de dados sqlite3:

(api-drf-venv) $ python manage.py makemigrations

(api-drf-venv) $ python manage.py migrate

E finalmente rodar a nossa aplicação com o comando runserver e acessá-la pela url http://localhost:8000/songs:

(api-drf-venv) $ python manage.py runserver

Observe que o DRF oferece uma interface para interagir com a API utilizando os métodos GET, POST, HEAD e OPTIONS para a rota da view SongListGenerics e para a SongDetailGenerics os métodos GET, PUT, PATCH, DELETE, HEAD e OPTIONS:

Como podemos perceber, a criação de APIs REST com o DRF é algo simples e de fácil aplicação. Para aqueles acostumados com o Django, utilizar o DRF é trivial. De toda forma, o framework possui outras funcionalidades que podem ser exploradas no site DRF, principalmente na API Guide.