Forem

jandersonsiqueira
jandersonsiqueira

Posted on

2

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
Enter fullscreen mode Exit fullscreen mode

2. Estrutura do Projeto

Nosso projeto terá a seguinte estrutura:

/api_flask
│
├── app.py
└── requirements.txt
Enter fullscreen mode Exit fullscreen mode

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'}
]
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

5. Rodando a API

Agora, basta rodar nossa aplicação:

if __name__ == '__main__':
    app.run(debug=True)
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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
Enter fullscreen mode Exit fullscreen mode

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())
Enter fullscreen mode Exit fullscreen mode

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.

Sentry image

See why 4M developers consider Sentry, “not bad.”

Fixing code doesn’t have to be the worst part of your day. Learn how Sentry can help.

Learn more

Top comments (0)

Image of Docusign

🛠️ Bring your solution into Docusign. Reach over 1.6M customers.

Docusign is now extensible. Overcome challenges with disconnected products and inaccessible data by bringing your solutions into Docusign and publishing to 1.6M customers in the App Center.

Learn more

👋 Kindness is contagious

Explore a sea of insights with this enlightening post, highly esteemed within the nurturing DEV Community. Coders of all stripes are invited to participate and contribute to our shared knowledge.

Expressing gratitude with a simple "thank you" can make a big impact. Leave your thanks in the comments!

On DEV, exchanging ideas smooths our way and strengthens our community bonds. Found this useful? A quick note of thanks to the author can mean a lot.

Okay