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': '[e-mail]'},
    {'id': 2, 'name': 'Bob', 'email': '[e-mail]'}
]

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.