API em Pyhton - Uma abordagem

Nesse post, ou artigo, iremos abordar o uso de API em Python. Conforme já disse, todo conteúdo postado aqui, ou melhor, a maioria desse conteúdo é fonte de estudo que venho realizado ao logo da semana e/ou mês. Acredito que isso sirva de um reforço para aquilo que estudei e uma forma de passar esse conteúdo.

Além de meus estudos, busquei também auxilio na web, onde realizei pesquisas para me auxliar em compor este.

O que é uma API?

API é a sigla de "Application Programming Interface", ou "Interface de Programação de Aplicativos" em português. É um conjunto de regras que governam como as diferentes partes de um software se comunicam entre si.

As APIs podem ser usadas para permitir que diferentes aplicativos se comuniquem uns com os outros, compartilhem dados e realizem ações em conjunto. Por exemplo, uma API pode permitir que um aplicativo de compras on-line se comunique com um sistema de pagamento para processar transações.

As APIs também são frequentemente usadas em serviços da web para permitir que outros aplicativos ou sites obtenham dados e informações de um serviço específico. Por exemplo, um site de previsão do tempo pode usar uma API de serviço meteorológico para obter informações atualizadas sobre as condições do tempo em uma determinada área.

Tipos de APIs

Existem vários tipos de APIs, mas as duas mais comuns são as APIs baseadas em REST e as APIs baseadas em SOAP.

REST (Representational State Transfer) são projetadas para serem simples e leves. Elas usam o protocolo HTTP para enviar solicitações e receber respostas, e geralmente retornam os dados no formato JSON (JavaScript Object Notation) ou XML (Extensible Markup Language).
SOAP (Simple Object Access Protocol) são projetadas para serem mais robustas e oferecer mais recursos do que as APIs baseadas em REST. Elas usam o protocolo HTTP, mas também podem usar outros protocolos, como SMTP (Simple Mail Transfer Protocol) e FTP (File Transfer Protocol). As APIs baseadas em SOAP geralmente retornam os dados no formato XML.

Criando uma API em Python

Agora que entendemos o que é uma API e os tipos de APIs disponíveis, podemos começar a criar uma API em Python. Para este exemplo, vamos criar uma API baseada em REST.

Configurando o ambiente

Antes de começarmos a escrever o código da API, precisamos configurar o ambiente. Vamos começar criando um novo diretório para o projeto:

$ mkdir minha-api
$ cd minha-api

Em seguida, precisamos criar um ambiente virtual para isolar nosso projeto do Python instalado no sistema:

$ python -m venv venv
$ source venv/bin/activate

Agora, podemos instalar o Flask, um framework de Python para construir APIs baseadas em REST:

(venv) $ pip install flask

Escrevendo a API

Com o ambiente configurado, podemos começar a escrever o código da API. Abra seu editor de código favorito e crie um arquivo chamado app.py.

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, World!'

Este código define uma rota básica para nossa API que retorna a mensagem "Hello, World!" quando a rota é acessada. Para executar a API, basta executar o seguinte comando no terminal:

(venv) $ FLASK_APP=app.py flask run

Isso iniciará o servidor de desenvolvimento do Flask e disponibilizará nossa API na URL http://localhost:5000. Podemos testar a API acessando essa URL em um navegador da web ou usando uma ferramenta de teste de API, como o Postman.

Definindo rotas

Agora que temos uma rota básica definida, podemos adicionar mais rotas para nossa API. Para isso, basta criar novas funções decoradas com o @app.route e especificar a rota desejada.

@app.route('/users')
def get_users():
    # código para obter os usuários do banco de dados
    return 'Lista de usuários'

@app.route('/users/<int:user_id>')
def get_user(user_id):
    # código para obter o usuário com o ID especificado do banco de dados
    return f'Informações do usuário {user_id}'

Essas rotas retornam uma lista de usuários e informações sobre um usuário específico, respectivamente. Note que a segunda rota usa um parâmetro <int:user_id> na rota para especificar que o ID do usuário deve ser um número inteiro.

Enviando dados

Em muitos casos, nossa API precisará receber dados de entrada do usuário, como informações de formulários ou dados enviados por outros aplicativos. Para isso, podemos usar o método POST do protocolo HTTP para enviar os dados para nossa API.

from flask import request

@app.route('/users', methods=['POST'])
def add_user():
    name = request.form['name']
    email = request.form['email']
    # código para adicionar o usuário ao banco de dados
    return 'Usuário adicionado com sucesso'

Esta rota recebe dados de um formulário com os campos "name" e "email" e adiciona um novo usuário ao banco de dados. Note que estamos usando o objeto request do Flask para acessar os dados do formulário.

Autenticação e segurança

Precisamos garantir que apenas usuários autenticados e autorizados possam acessar nossa API. Para isso, podemos usar técnicas de autenticação e autorização, como tokens de acesso e autenticação de dois fatores.

from flask_httpauth import HTTPTokenAuth

auth = HTTPTokenAuth(scheme='Bearer')

@auth.verify_token
def verify_token(token):
    # código para verificar se o token é válido
    return True

@app.route('/users')
@auth.login_required
def get_users():
    # código para obter os usuários do banco de dados
    return 'Lista de usuários'

Neste exemplo, estamos usando a extensão flask_httpauth para implementar a autenticação por tokens. A função verify_token é chamada sempre que uma rota decorada com @auth.login_required é acessada para verificar se o token de acesso é válido. Se o token for válido, a rota é executada normalmente. Caso contrário, o usuário é redirecionado para uma página de login.

Conclusão

Neste artigo, foi demonstrado o que é uma API e os tipos de APIs disponíveis. Também vimos como criar uma API básica em Python usando o framework Flask, definir rotas, enviar e receber dados, e implementar a autenticação e segurança. Existem muitos outros recursos e técnicas avançadas que podemos usar para criar APIs robustas e escaláveis em Python, mas espero que este artigo tenha dado uma ideia do que é possível e ajudado você a começar sua jornada na criação de APIs em Python.

Alguns dos recursos adicionais interessantes são:

Uso de bancos de dados: em muitos casos, precisamos armazenar dados persistentes em nossa API, como informações de usuários ou pedidos. Para isso, podemos usar um banco de dados como o SQLite ou o PostgreSQL e interagir com ele usando o ORM SQLAlchemy.
Implementação de testes automatizados: para garantir que nossa API esteja funcionando corretamente e detectar problemas antes que eles ocorram, podemos escrever testes automatizados que verifiquem as várias rotas e funcionalidades de nossa API.
Implementação de caching: para melhorar o desempenho de nossa API e reduzir a carga em nossos servidores, podemos usar o caching para armazenar em cache as respostas das rotas e reduzir o tempo de resposta.
Uso de ferramentas de monitoramento: para garantir que nossa API esteja funcionando corretamente e detectar problemas rapidamente, podemos usar ferramentas de monitoramento como o Sentry ou o Datadog.

Com essas técnicas e ferramentas adicionais, podemos criar APIs poderosas e escaláveis em Python para atender às necessidades de nossos usuários e clientes.

Espero que este artigo tenha sido útil e que você tenha adquirido uma compreensão mais profunda de como criar APIs em Python usando o Flask.

Fique avontade para entrar em contato e sugerir mudanças e melhorias...

Rodrigo Viana