Como Criar APIs RESTful com Flask e Python

APIs RESTful são essenciais no desenvolvimento moderno, permitindo que diferentes sistemas se comuniquem de forma eficiente e escalável. Python, com seu framework Flask, oferece uma abordagem simples e poderosa para criar APIs. Neste guia, vamos explorar como criar uma API RESTful utilizando Flask, cobrindo desde os conceitos básicos até autenticação e consumo com clientes HTTP.

O que é uma API RESTful?

Antes de começarmos com o código, é importante entender o que é uma API RESTful. API (Application Programming Interface) é um conjunto de regras que permitem que um software se comunique com outro. O estilo REST (Representational State Transfer) define um conjunto de princípios que a API deve seguir:

• Client-Server: Separação entre o cliente (quem consome a API) e o servidor (quem fornece os dados).
• Stateless: Cada requisição feita pelo cliente deve conter todas as informações necessárias para o servidor processar.
• Cacheable: As respostas da API podem ser cacheadas para melhorar o desempenho.
• Uniform Interface: A comunicação entre cliente e servidor deve ser feita de maneira padronizada, usando métodos HTTP como GET, POST, PUT e DELETE.

Criando uma API RESTful com Flask

Vamos agora criar uma API simples que gerencia uma lista de usuários. A API permitirá adicionar, editar, visualizar e excluir usuários.

1. Instalando o Flask

Primeiro, certifique-se de ter o Flask instalado. Caso não tenha, você pode instalá-lo usando o pip:

pip install Flask 

2. Estrutura do Projeto

Nosso projeto terá a seguinte estrutura:

/api_flask │ ├── app.py └── requirements.txt 

3. Configurando o Flask

No arquivo app.py, começamos importando as bibliotecas necessárias e configurando nossa aplicação Flask:

from flask import Flask, jsonify, request app = Flask(__name__) # Dados simulados users = [ {'id': 1, 'name': 'Alice', 'email': 'alice@example.com'}, {'id': 2, 'name': 'Bob', 'email': 'bob@example.com'} ] 

4. Criando Endpoints

Agora, vamos criar nossos endpoints para visualizar, adicionar, atualizar e deletar usuários.

4.1. Endpoint para Listar Usuários

Usaremos o método GET para listar todos os usuários:

@app.route('/users', methods=['GET']) def get_users(): return jsonify(users), 200 

4.2. Endpoint para Obter um Usuário Específico

Usaremos o método GET com o ID do usuário para obter detalhes de um usuário específico:

@app.route('/users/<int:user_id>', methods=['GET']) def get_user(user_id): user = next((user for user in users if user['id'] == user_id), None) if user: return jsonify(user), 200 else: return jsonify({'message': 'User not found'}), 404 

4.3. Endpoint para Criar um Novo Usuário

O método POST será usado para adicionar um novo usuário. O cliente enviará os dados em formato JSON.

@app.route('/users', methods=['POST']) def create_user(): data = request.get_json() new_user = { 'id': len(users) + 1, 'name': data['name'], 'email': data['email'] } users.append(new_user) return jsonify(new_user), 201 

4.4. Endpoint para Atualizar um Usuário

Aqui, usamos o método PUT para atualizar os dados de um usuário existente:

@app.route('/users/<int:user_id>', methods=['PUT']) def update_user(user_id): data = request.get_json() user = next((user for user in users if user['id'] == user_id), None) if user: user['name'] = data['name'] user['email'] = data['email'] return jsonify(user), 200 else: return jsonify({'message': 'User not found'}), 404 

4.5. Endpoint para Deletar um Usuário

Usamos o método DELETE para remover um usuário:

@app.route('/users/<int:user_id>', methods=['DELETE']) def delete_user(user_id): global users users = [user for user in users if user['id'] != user_id] return jsonify({'message': 'User deleted'}), 200 

5. Rodando a API

Agora, basta rodar nossa aplicação:

if __name__ == '__main__': app.run(debug=True) 

Executando o arquivo app.py, nossa API estará disponível em http://127.0.0.1:5000/users.

6. Autenticação com Flask

Para adicionar uma camada de segurança à nossa API, podemos usar JWT (JSON Web Token). Com JWT, podemos garantir que apenas usuários autenticados possam acessar certos endpoints.

6.1. Instalando o Flask-JWT-Extended

Instale a extensão necessária:

pip install Flask-JWT-Extended 

6.2. Configurando o JWT

Atualize seu arquivo app.py para incluir autenticação JWT:

from flask_jwt_extended import JWTManager, create_access_token, jwt_required app.config['JWT_SECRET_KEY'] = 'your-secret-key' # Troque pela sua chave secreta jwt = JWTManager(app) # Login para obter o token @app.route('/login', methods=['POST']) def login(): data = request.get_json() if data['username'] == 'admin' and data['password'] == 'admin': access_token = create_access_token(identity={'username': 'admin'}) return jsonify(access_token=access_token), 200 else: return jsonify({'message': 'Invalid credentials'}), 401 # Exemplo de endpoint protegido @app.route('/protected', methods=['GET']) @jwt_required() def protected(): return jsonify({'message': 'Access granted to protected endpoint'}), 200 

Agora, ao acessar o endpoint /protected, será necessário enviar o token JWT no cabeçalho da requisição para autenticar o usuário.

7. Consumindo a API com Cliente HTTP

Para consumir a API, podemos usar ferramentas como Postman ou bibliotecas como requests no Python.

Exemplo de como consumir a API usando requests:

import requests # Consumindo o endpoint de listagem de usuários response = requests.get('http://127.0.0.1:5000/users') print(response.json()) 

Conclusão

Criar uma API RESTful com Flask é direto e flexível. Flask oferece uma estrutura minimalista que pode ser expandida para incluir funcionalidades como autenticação, manipulação de erros e outras camadas de segurança. Ao seguir os princípios do REST e boas práticas de desenvolvimento, é possível construir APIs eficientes e escaláveis com Python.

Agora você pode construir sua própria API RESTful com Flask, personalizando conforme suas necessidades e requisitos.