Flask: Resumo Completo

Por

O minimalismo do Flask é uma feature, não uma limitação, mas significa que você é responsável por cada decisão de arquitetura, desde conexões com banco de dados até organização de rotas. Esta referência cobre os padrões principais que aparecem na construção de APIs Flask em produção, do setup de ambiente até a integração com MongoDB.

TL;DR: Configure uma API Flask completa com rotas, conexão com banco via Peewee ORM, casos de uso, repositórios, documentação Swagger e integração com MongoDB.
Stack: Python, Flask, Flask-CORS, Peewee ORM, PostgreSQL, MongoDB, python-dotenv, Swagger
Nível: Intermediário
Tempo de leitura: ~12 min

Flask é a ferramenta certa quando você precisa de uma API leve sem o peso do Django, especialmente útil para microsserviços e endpoints de inferência de AI onde o controle sobre a stack importa mais que a convenção.

Instalar Flask e CORS

pip install flask
pip install flask-cors
pip install python-dotenv

Primeira rota

from flask import Flask
from flask_cors import CORS

app = Flask(__name__)
CORS(app)

@app.route("/")
def hello():
    return "Olá com cors"

Instalar Peewee e drivers

pip install peewee
pip install psycopg
pip install psycopg-binary

Conexão Singleton (infra/repositories/singleton_connection.py)

O singleton garante que o seu app abra exatamente uma conexão com o banco por ciclo de vida do processo, fundamental em produção para evitar esgotamento do pool de conexões.

from peewee import PostgresqlDatabase
import os
from dotenv import load_dotenv

load_dotenv()

db = PostgresqlDatabase(
    os.getenv('DB_NAME', 'djangopoc'),
    user=os.getenv('DB_USER', 'admin'),
    password=os.getenv('DB_PASSWORD', '123456'),
    host=os.getenv('DB_HOST', 'localhost'),
    port=int(os.getenv('DB_PORT', 5432))
)

class SingletonConnection:
    _instance = None

    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance._connection = db
            try:
                cls._instance._connection.connect()
                print("Conexão com banco bem-sucedida!")
            except Exception as e:
                print(f"Falha na conexão: {e}")
        return cls._instance

    def get_connection(self):
        return self._connection

singleton_connection = SingletonConnection()

Configurar rotas

from flask import jsonify
from application.use_cases.list_positions.list_positions import ListPositions
from infra.repositories.position_repository_postgre import PositionRepositoryPostgre

def positions_route(app):
    @app.route("/list-positions", methods=['GET'])
    def list_positions():
        try:
            use_case = ListPositions(PositionRepositoryPostgre())
            positions = use_case.execute()
            result_list = [{'name': p.name, 'id': p.id} for p in positions.items]
            return jsonify(result_list), 200
        except Exception as e:
            return jsonify({'error': str(e)}), 500

Casos de uso, repositórios e testes

A arquitetura segue o mesmo padrão em toda parte: a rota cuida do HTTP, o caso de uso cuida da lógica de negócio, e o repositório abstrai o banco. Cada camada é testável de forma isolada. Troque a implementação concreta do repositório sem tocar nos casos de uso, e mocke o repositório para testar a lógica do caso de uso sem uma conexão real com o banco.

Swagger

pip install flasgger

# configurar no app.py
from flasgger import Swagger
swagger = Swagger(app)

MongoDB

pip install pymongo

Mesmo padrão singleton do PostgreSQL, só troca o driver. O repositório MongoDB usa o aggregation pipeline para consultas agrupadas, substituindo o GROUP BY do SQL.

O que você construiu

Uma referência completa de Flask cobrindo toda a stack: setup de ambiente, integração com banco via Peewee ORM, arquitetura limpa com casos de uso e protocolos de repositório, padrões de teste, documentação Swagger e conectividade com MongoDB. Essa estrutura escala de projeto pessoal até API em produção sem precisar reescrever.

Próximos passos

  • Adicione autenticação: integre Flask-JWT-Extended ou um middleware de API key para proteger seus endpoints.
  • Containerize: empacote esse setup em um Dockerfile e conecte a um pipeline de CI/CD.
  • Adicione observabilidade: conecte logging estruturado e o rastreamento do AWS X-Ray para ter visibilidade nas requisições em produção.

Dúvidas ou feedback? Me encontre no LinkedIn ou GitHub.

Deixe um comentário