Aula 05: Integrando Banco de Dados (SQLAlchemy) ao FastAPI no Curso de FastAPI

Neste tutorial, vamos aprender como integrar um banco de dados utilizando SQLAlchemy ao nosso projeto FastAPI. O SQLAlchemy é uma biblioteca popular em Python, usada para interagir com bancos de dados relacionais de forma eficiente e fácil.

Antes de começarmos, certifique-se de ter o FastAPI e o SQLAlchemy instalados. Você pode instalar o FastAPI utilizando o pip:

pip install fastapi

E o SQLAlchemy:

pip install sqlalchemy

Também será necessário instalar o driver do banco de dados que você irá utilizar. Por exemplo, se você estiver utilizando o MySQL:

pip install pymysql

Com tudo configurado, vamos criar um novo arquivo chamado main.py e começar a integrar o banco de dados ao nosso projeto:

from fastapi import FastAPI
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

# Criando uma instância do FastAPI
app = FastAPI()

# Configuração do banco de dados
SQLALCHEMY_DATABASE_URL = "sqlite:///./test.db"

# Criando uma conexão com o banco de dados
engine = create_engine(SQLALCHEMY_DATABASE_URL)

# Criando uma sessão do SQLAlchemy
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

# Criando uma classe base para nossos modelos
Base = declarative_base()

# Rota para testar a conexão com o banco de dados
@app.get("/")
async def test_db_connection():
    # Testando a conexão com o banco de dados
    try:
        db = SessionLocal()
        db.execute("SELECT 1")
        return {"message": "Conexão com o banco de dados bem-sucedida"}
    except Exception as e:
        return {"message": "Erro ao conectar ao banco de dados"}

Neste código, criamos uma instância do FastAPI, configuramos a URL do banco de dados (no caso, estamos utilizando um banco de dados SQLite) e criamos uma classe base para nossos modelos. Também criamos uma rota de teste para verificar a conexão com o banco de dados.

Agora vamos criar alguns modelos e definir a estrutura do banco de dados. Vamos adicionar estas linhas ao nosso arquivo main.py:

from sqlalchemy import Column, Integer, String

# Definindo um modelo de usuário
class User(Base):
    __tablename__ = "users"

    id = Column(Integer, primary_key=True, index=True)
    name = Column(String, unique=True)
    age = Column(Integer)

# Criando as tabelas no banco de dados
Base.metadata.create_all(bind=engine)

Neste código, definimos um modelo de usuário com três colunas: id, name e age. Em seguida, criamos as tabelas no banco de dados utilizando o método create_all da classe Base.

Agora, vamos adicionar rotas para criar, ler, atualizar e excluir usuários do banco de dados. Adicione o seguinte código ao seu arquivo main.py:

from fastapi import Depends

# Rota para criar um novo usuário
@app.post("/users/")
async def create_user(user: User):
    db = SessionLocal()
    db.add(user)
    db.commit()
    db.refresh(user)
    return user

# Rota para consultar um usuário pelo ID
@app.get("/users/{user_id}")
async def read_user(user_id: int):
    db = SessionLocal()
    user = db.query(User).filter(User.id == user_id).first()
    return user

# Rota para atualizar um usuário pelo ID
@app.put("/users/{user_id}")
async def update_user(user_id: int, user: User):
    db = SessionLocal()
    user_in_db = db.query(User).filter(User.id == user_id).first()
    user_in_db.name = user.name
    user_in_db.age = user.age
    db.commit()
    db.refresh(user_in_db)
    return user_in_db

# Rota para excluir um usuário pelo ID
@app.delete("/users/{user_id}")
async def delete_user(user_id: int):
    db = SessionLocal()
    user = db.query(User).filter(User.id == user_id).first()
    db.delete(user)
    db.commit()
    return {"message": "Usuário excluído com sucesso"}

Neste código, criamos rotas para criar, consultar, atualizar e excluir usuários do banco de dados. Para cada operação, criamos uma instância da sessão do SQLAlchemy, realizamos a operação desejada e comitamos as mudanças no banco de dados.

Com todos os passos concluídos, basta executar o seu projeto FastAPI utilizando o comando:

uvicorn main:app --reload

Agora você tem um projeto FastAPI integrado com o SQLAlchemy, permitindo interagir com um banco de dados de forma fácil e eficiente. Você pode adaptar este exemplo para adicionar mais modelos e operações ao seu projeto, conforme necessário. Espero que este tutorial seja útil e esclarecedor.