API REST com Django e PostgreSQL

Quando acessamos um site e queremos obter ou alterar as informações que estão armazenadas em seu banco de dados como, por exemplo, os dados da sua conta em uma rede social, o frontend do site (que é a parte visual que estamos interagindo) faz uma requisição para o backend, onde um servidor verifica se a requisição está correta, procura as informações no banco de dados e retorna o resultado para o cliente. Uma forma de implementar um sistema desses é através de uma API REST.

Neste artigo, veremos na prática como projetar este sistema utilizando o framework Django e o banco de dados postgreSQL.

API

Uma API (Application Programming Interface ou em português Interface de Programação de Aplicativos) é uma forma de dois sistemas interagirem: aquele que utiliza a API vai fazer requisições e aquele que fornece vai analisar estas requisições e retornar a resposta adequada. Dessa forma, o primeiro pode interagir com o segundo sem necessariamente precisar conhecer o código do segundo, apenas vão trocar dados.

REST

O REST (Representational State Transfer ou em português, transferência de estado representacional) é um padrão para troca de informações entre aplicações através de chamadas HTTP, então os recursos de uma API são organizados em vários URI’s únicos (abreviação de Uniform Resources Identifiers ou Identificador uniforme de recursos) que são strings que diferenciam recursos de dados em um servidor.

Requisição

A mensagem da requisição que o cliente envia ao servidor tem um formato bastante específico, a primeira linha diz o método utilizado (que pode ser, por exemplo, GET, POST, PUT ou DELETE) e em seguida a URI que estamos querendo acessar.

Em seguida vem os headers que são o cabeçalho da requisição, onde contém os metadados da requisição, como o accept que diz ao servidor o formato aceito dos dados, o authorization que é um token que permite o acesso do cliente aos dados no servidor, dentre outros. Por fim, tem o body que é onde vão os dados customizados que o cliente quer enviar ao servidor.

Observe o exemplo abaixo:

Nele temos o método POST que cria um registro e, em seguida, a URI que identifica a categoria produto, o tipo de dado da comunicação que é o json no accept e no body temos o nome do produto, o preço e o desconto. Este exemplo poderia ser utilizado no caso de um sistema de administração de estoque onde uma pessoa poderia cadastrar um novo produto no banco de dados para aparecer em sua loja.

Além do método POST que é usado para criar, existem também o GET que é usado para apenas ler um registro, o PUT para atualizar um já existente, o DELETE que vai eliminar um registro, dentre outros.

Resposta

A mensagem de resposta também possui um formato específico. A primeira linha contém o código de status para dizer ao cliente o que aconteceu com a requisição, em seguida vem os headers que vão conter informações a respeito do servidor e por fim o body que é o conteúdo, geralmente retornado no formato json.

Observe o exemplo abaixo:

Existem vários códigos de retorno, sendo que na casa dos 100 representam respostas de informação, 200 representam respostas de sucesso, 300 são redirecionamentos, 400 são erros no cliente e 500 são erros no servidor.

A arquitetura REST é Stateless, o que significa que ela não guarda estado, ou seja, cada ciclo de requisição e resposta é independente um do outro e nenhuma das partes, nem o cliente e nem o servidor, precisam armazenar informações a respeito um do outro.

Configurando o projeto

Entendido a parte teórica, vamos agora criar um projeto com o Django. Primeiro, vamos gerar e ativar um ambiente virtual Python e em seguida instalaremos as bibliotecas necessárias, no terminal digite respectivamente os comandos a seguir:

Feito isso, vamos iniciar um projeto Django com o nome myproject:

Esse comando vai criar vários arquivos. O manage.py será o ponto de entrada por onde vamos gerenciar a nossa aplicação através da linha de comando, dentro da pasta myproject os arquivos relevantes para o nosso projeto no momento são o settings.py que são as configurações e urls.py que são onde colocaremos os links customizados para o usuário acessar no navegador.

Para configurar o banco de dados, primeiro é necessário que tenha instalado o postgreSQL na sua máquina, então acesse o site oficial e instale junto do pgadmin. Feito isso, no arquivo settings.py onde tem databases vamos substituir o padrão que o Django gera com sqlite3 pelos dados do postgres da seguinte forma:

No lugar de name, user e password você vai colocar o nome do seu banco de dados, seu usuário e sua senha respectivamente. O host é o localhost por que o postgres está na nossa máquina e a porta é 5432 que é o padrão.

Esse arquivo settings tem várias informações sensíveis, então por questão de segurança, uma boa prática é sempre criar um arquivo chamado .env e colocar nele a SECRET_KEY e esses parâmetros do banco de dados. Para isso, vamos criar o arquivo .env e dentro dele colocaremos cada uma dessas variáveis com a string contendo o seu valor:

Para usar essas variáveis, dentro do settings.py, precisamos importar a função config da biblioteca decouple que instalamos no início:

Então agora basta passar no lugar do valor de cada variável a função config com o nome da variável que na hora da execução ele vai pegar as informações que estão no arquivo .env:

Quando for colocar o código em um repositório no GitHub, por exemplo, você declara o .env no arquivo .gitignore para ele não ser enviado. Se estiver trabalhando com mais desenvolvedores, você pode colocar um arquivo .env.example contendo o nome das variáveis e valores falsos para que os outros possam saber quais variáveis de ambiente precisam ser declaradas para o código funcionar.

Ainda no arquivo settings.py, em INSTALLED_APPS vamos adicionar ‘rest_framework’ para configurar a biblioteca que utilizaremos para criar a API REST:

Agora vamos criar uma pasta chamada api contendo um arquivo __init__.py vazio, um arquivo chamado views.py e outro urls.py. No views.py vamos importar a função response e o decorador api_view da biblioteca djangorestframework:

Em seguida vamos criar a função que vai retornar os dados. No decorador colocaremos o método da requisição, que neste caso vai ser GET, ela vai receber como parâmetro a request e retornar como resposta um dicionário:

Agora dentro do arquivo urls.py vamos importar a função path do Django urls, o módulo views e criaremos uma lista chamada urlpatterns contendo a função path com o caminho inicial e a função getData que criamos em views:

Por fim, vamos importar a função include do Django urls dentro do arquivo urls.py da pasta myproject e adicionar as urls da api dentro do urlpatterns:

Agora basta rodar o comando para iniciar o servidor e acessar no navegador o localhost com a porta 8000 (127.0.0.1:8000):

Você deve observar no navegador os dados colocados no dicionário se tudo correu bem até este ponto, o que significa que o sistema já está funcionando conforme o esperado. Agora a última parte que falta é conectar o banco de dados no sistema e criar uma função para lidar com uma requisição do tipo POST.

Para isso, vamos começar criando um App Django, o qual chamaremos de myapp com o seguinte comando:

Quando o app for criado, temos que adicioná-lo à lista de apps instalados dentro do arquivo settings.py do projeto:

Depois, dentro do arquivo models.py do app, vamos criar o primeiro modelo chamado Item que será uma classe que deriva de Model. Ela vai conter dois atributos, o nome e a data da sua criação:

A função Response presente no retorno das funções no arquivo views.py não é capaz de lidar com dados vindos direto do banco de dados, então é necessário serializar os dados primeiro, para isso vamos criar um arquivo chamado serializers.py dentro da pasta api e nele vamos importar os serializers, o modelo e depois criar uma classe para transformar os dados:

No lugar de fields pode ser colocado uma lista contendo os campos que você deseja, para aplicar a todos basta colocar ‘__all__’.

No arquivo views.py da api vamos importar o modelo, o serializer e substituir o dicionário na função getData pelo modelo do banco de dados:

Agora basta rodar no terminal os seguintes comandos para aplicar as modificações no banco de dados:

A este ponto, a aplicação já está funcionando, porém ainda não temos dados no banco para visualizar, então vamos codificar mais uma função para criar os dados. Dentro do views.py da api, a função vai receber o método POST no decorator, serializar os dados, verificar se eles são válidos e salvar:

Depois é só passar essa nova função para uma url dentro da lista de urls em urls.py da api:

Agora rodamos o servidor novamente e quando acessamos o 127.0.0.1:8000/add/ podemos criar um novo registro no banco enviando uma requisição do tipo POST. O campo que tiver media type você deixa application/json e no content coloca os dados no formato json (conjunto chave e valor com aspas duplas):

Ao acessar a página inicial que está com o método GET, você verá o dado que acabamos de criar sendo retornado do banco.

Conclusão

Graças a facilidade proporcionada pelas bibliotecas e pelo framework Django, conseguimos configurar em questão de minutos o backend para criar uma API. A partir deste ponto, você pode modificar o arquivo models.py do app para adicionar mais modelos no banco de dados, criar novas views na api e urls para acessar e modificar esses dados (lembrando de serializar os dados antes de retornar).

O backend é uma área ampla e ainda existem diversos tópicos que devem ser discutidos, como a possibilidade de criar um sistema de cadastro de usuários, como salvar a senha dos usuários de forma segura no banco, como gerenciar as permissões de cada usuário, fazer testes, tratar erros, dentre outras, mas com o projeto que desenvolvemos neste artigo já dá para ter um ponto de partida.