Crie sua primeira API com Flask

Introdução

Criar uma API RESTful robusta é essencial para aplicativos web modernos, permitindo uma comunicação perfeita entre serviços e clientes. Neste guia abrangente, você aprenderá como construir, proteger e implantar sua primeira API usando Flask, uma estrutura web Python leve, mas poderosa. Criaremos uma API de exemplo do mundo real que fornece dados de produtos para um cenário de comércio eletrônico e abordaremos recursos avançados, como tratamento de erros, operações CRUD, integração de banco de dados, autenticação, modularização com Blueprints, documentação de API, testes e estratégias de implantação.

Importando pacotes necessários

Para manter nosso código organizado e evitar repetições, começamos importando os pacotes necessários. Isso garante que todos os blocos de código subsequentes tenham acesso às bibliotecas necessárias.

# Importe as bibliotecas necessárias para o desenvolvimento da API.
from flask import Flask, jsonify, request, abort

Criando uma API Flask básica com dados de exemplos reais

Criaremos uma API básica que fornece dados de produtos para um exemplo de comércio eletrônico. Isso inclui um endpoint de boas-vindas e um endpoint /api/products que retorna uma lista de produtos.

API básica Exemplo

# Inicialize o aplicativo Flask.
app = Flask(__name__)

# Defina o endpoint raiz.
@app.route("/")
def index():
    return jsonify({"message": "Welcome to the Products API"})

# Defina um ponto final para retornar uma lista de produtos.
@app.route("/api/products", methods=["GET"])
def get_products():
    # Exemplo de dados reais de produtos.
    products = [
        {"id": 1, "name": "Wireless Mouse", "price": 29.99, "category": "Electronics"},
        {"id": 2, "name": "Bluetooth Headphones", "price": 59.99, "category": "Electronics"},
        {"id": 3, "name": "Coffee Maker", "price": 79.99, "category": "Home Appliances"},
        {"id": 4, "name": "Electric Kettle", "price": 39.99, "category": "Home Appliances"},
        {"id": 5, "name": "Smartphone Stand", "price": 19.99, "category": "Accessories"}
    ]
    return jsonify({"products": products})

if __name__ == "__main__":
    # Execute o aplicativo na porta 5000 com a depuração ativada.
    app.run(debug=True, port=5000)

Executando e testando a API

Para executar sua API Flask, execute seu script usando, por exemplo, python api.py. Certifique-se de que sua API seja executada em uma porta específica (por exemplo, 5000) para manter a consistência. Por exemplo:

if __name__ == "__main__":
    app.run(debug=True, port=5000)

Este comando inicia o servidor de desenvolvimento Flask na porta 5000 com a depuração habilitada.

Nota

Depois que sua API estiver em execução, você poderá acessá-la visitando http://localhost:5000/ no seu navegador da web.

Testando sua API

Você pode testar sua API usando ferramentas como cURL ou Postman.

Usando cURL:

curl http://127.0.0.1:5000/
curl http://127.0.0.1:5000/api/products

Usando o Postman:
- Envie uma solicitação GET para http://127.0.0.1:5000/api/products para ver a resposta JSON com os dados do produto.

Tratamento de erros e validação de entrada

O tratamento robusto de erros é crucial para uma API de nível de produção. Aqui, adicionamos manipuladores de erros e validação de entrada para garantir que nossa API responda adequadamente a entradas e erros inesperados.

Exemplo de tratamento de erros

from flask import abort

@app.route("/api/divide", methods=["GET"])
def divide():
    try:
        a = float(request.args.get("a", ""))
        b = float(request.args.get("b", ""))
        if b == 0:
            abort(400, description="Division by zero is not allowed.")
        return jsonify({"result": a / b})
    except ValueError:
        abort(400, description="Invalid input. Please provide numeric values.")

@app.errorhandler(400)
def bad_request(error):
    response = jsonify({"error": error.description})
    response.status_code = 400
    return response

Operações CRUD

Gerenciar recursos por meio de operações CRUD (Criar, Ler, Atualizar, Excluir) é essencial. Abaixo está um exemplo simples usando um armazenamento de dados na memória para gerenciamento de produtos.

Exemplo de CRUD

# Armazenamento de dados na memória para produtos.
items = []

# Criar um novo produto.
@app.route("/api/items", methods=["POST"])
def create_item():
    data = request.get_json()
    items.append(data)
    return jsonify({"message": "Item created", "item": data}), 201

# Ler todos os produtos.
@app.route("/api/items", methods=["GET"])
def get_items():
    return jsonify({"items": items})

# Atualizar um produto.
@app.route("/api/items/<int:item_id>", methods=["PUT"])
def update_item(item_id):
    data = request.get_json()
    if item_id < 0 or item_id >= len(items):
        abort(404, description="Item not found")
    items[item_id].update(data)
    return jsonify({"message": "Item updated", "item": items[item_id]})

# Excluir um produto.
@app.route("/api/items/<int:item_id>", methods=["DELETE"])
def delete_item(item_id):
    if item_id < 0 or item_id >= len(items):
        abort(404, description="Item not found")
    deleted_item = items.pop(item_id)
    return jsonify({"message": "Item deleted", "item": deleted_item})

Integração com banco de dados

Para aplicativos de produção, integrar um banco de dados é essencial. O Flask pode se conectar facilmente a bancos de dados usando um ORM como o SQLAlchemy.

Exemplo de integração com SQLAlchemy

# Configure o banco de dados SQLite.
from flask_sqlalchemy import SQLAlchemy

app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///api.db'
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)

# Definir um modelo simples para produtos.
class Product(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(80), nullable=False)
    price = db.Column(db.Float, nullable=False)
    category = db.Column(db.String(80), nullable=False)

# Crie as tabelas do banco de dados.
with app.app_context():
    db.create_all()

# Endpoint para adicionar um produto ao banco de dados.
@app.route("/api/db/products", methods=["POST"])
def add_product():
    data = request.get_json()
    new_product = Product(name=data.get("name"), price=data.get("price"), category=data.get("category"))
    db.session.add(new_product)
    db.session.commit()
    return jsonify({"message": "Product added", "product": {"id": new_product.id, "name": new_product.name}}), 201

Autenticação e autorização

Proteger sua API é fundamental. Abaixo está um exemplo básico usando JWT para autenticação.

Exemplo de autenticação JWT

from flask_jwt_extended import JWTManager, create_access_token, jwt_required, get_jwt_identity

# Configurar JWT.
app.config["JWT_SECRET_KEY"] = "your-secret-key"
jwt = JWTManager(app)

@app.route("/api/login", methods=["POST"])
def login():
    username = request.json.get("username", None)
    password = request.json.get("password", None)
    # Para demonstração, use um nome de usuário e senha fixos.
    if username != "admin" or password != "password":
        abort(401, description="Invalid credentials")
    access_token = create_access_token(identity=username)
    return jsonify(access_token=access_token)

@app.route("/api/protected", methods=["GET"])
@jwt_required()
def protected():
    current_user = get_jwt_identity()
    return jsonify(logged_in_as=current_user)

Modularização com Blueprints

Para aplicativos maiores, organizar seu código em Blueprints ajuda a manter uma estrutura limpa. Os blueprints permitem agrupar endpoints relacionados.

Exemplo de blueprint

from flask import Blueprint

# Crie um plano para pontos finais relacionados ao produto.
products_bp = Blueprint('products', __name__)

@products_bp.route("/api/blueprint/products", methods=["GET"])
def blueprint_get_products():
    return jsonify({"products": items})

# Registre o Blueprint com o aplicativo Flask.
app.register_blueprint(products_bp)

Documentação da API

A documentação interativa da API é essencial para APIs de nível de produção. Ferramentas como Flasgger podem gerar automaticamente a documentação Swagger.

Exemplo de configuração do Flasgger

from flasgger import Swagger

# Inicialize o Swagger para documentação da API.
swagger = Swagger(app)

@app.route("/api/docs")
def api_docs():
    return jsonify({"message": "Visit /apidocs for the interactive API documentation."})

Teste e implantação

Testando a API

Testes automatizados garantem que sua API permaneça confiável. Por exemplo, usando pytest:

def test_index():
    response = app.test_client().get("/")
    assert response.status_code == 200
    assert b"Welcome" in response.data

Executando a API

Execute seu aplicativo Flask na porta 5000 incluindo o seguinte comando:

if __name__ == "__main__":
    app.run(debug=True, port=5000)

Estratégias de implantação

Para implantação em produção, considere as seguintes estratégias:

Use um servidor WSGI de produção:
Implemente seu aplicativo Flask usando Gunicorn:
```
gunicorn --bind 0.0.0.0:5000 your_script:app
```

Containerização:
Use o Docker para conteinerizar seu aplicativo. Por exemplo, crie um Dockerfile:

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
COPY . .
CMD ["gunicorn", "--bind", "0.0.0.0:5000", "your_script:app"]

Substitua your_script pelo nome do seu arquivo Python que contém o aplicativo Flask.

Orquestração:
Para dimensionamento e gerenciamento, considere o uso do Kubernetes ou ferramentas de orquestração semelhantes.

Fluxograma de implantação

flowchart LR
    A[Develop API] --> B[Write Tests]
    B --> C[Containerize with Docker]
    C --> D[Deploy with Gunicorn]
    D --> E[Orchestrate with Kubernetes]
    E --> F[Monitor & Scale]

Conclusão

Seguindo este guia abrangente, você aprendeu como criar uma API RESTful de nível de produção com o Flask usando dados de exemplos do mundo real. Abordamos a criação de API, o tratamento de erros, as operações CRUD, a integração de bancos de dados, a autenticação, a modularização com Blueprints, a documentação da API, os testes e as estratégias de implantação. Com essas técnicas, você pode criar APIs robustas, seguras e escaláveis para aplicativos do mundo real.

Leitura adicional

Boa programação e aproveite para criar e implantar sua API de nível de produção com Flask!

Explore mais artigos

Nota

Aqui estão mais artigos da mesma categoria para ajudá-lo a se aprofundar no tópico.

Web scraping com BeautifulSoup

Um guia prático sobre como extrair dados de sites