Treinamento de FastAPI – Utilizando SQLAlchemy para Banco de Dados e Gerenciando Migrações com Alembic | Módulo 04

Neste curso de FastAPI, vamos abordar o uso de banco de dados com SQLAlchemy e como gerenciar migrações com Alembic. Aula 04 abrange a criação de modelos de dados, relacionamentos entre tabelas e consultas básicas no banco de dados.

O FastAPI é um framework web de alto desempenho para construção de APIs usando Python 3.6+ com suporte a Type Hints. Ele é rápido, fácil de usar e altamente escalável. SQLAlchemy é uma biblioteca Python popular para interagir com bancos de dados relacionais de forma eficiente e flexível. Alembic é uma ferramenta de migração de banco de dados que permite controlar e gerenciar as alterações na estrutura do banco de dados de maneira precisa e segura.

Para começar, é necessário ter o Python e o pip instalados em seu sistema. Você pode instalar o FastAPI, SQLAlchemy e Alembic usando o pip:

pip install fastapi sqlalchemy alembic

Em seguida, crie um novo projeto FastAPI e crie um arquivo main.py com o seguinte código:

from fastapi import FastAPI
from sqlalchemy import create_engine, Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker

app = FastAPI()

SQLALCHEMY_DATABASE_URL = "sqlite:///./test.db"

engine = create_engine(SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False})

SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

Base = declarative_base()

class User(Base):
    __tablename__ = "users"

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

Base.metadata.create_all(bind=engine)

Este código cria um aplicativo FastAPI com um banco de dados SQLite usando SQLAlchemy. Define um modelo de dados de usuário com colunas de id, nome e email. Em seguida, cria a tabela de usuário no banco de dados usando Base.metadata.create_all(bind=engine).

Agora, para gerenciar migrações com Alembic, crie um arquivo alembic.ini com o seguinte conteúdo:

[alembic]
script_location = alembic
sqlalchemy.url = sqlite:///./test.db

[logger_root]
level = WARN

Em seguida, execute o comando Alembic para inicializar o ambiente de migração:

alembic init alembic

Isso criará os diretórios necessários para armazenar as migrações. Em seguida, abra o arquivo alembic/env.py e configure a variável target_metadata para:

target_metadata = Base.metadata

Agora, crie uma migração inicial executando o comando:

alembic revision --autogenerate -m "initial"

Isso criará um arquivo de migração com as alterações necessárias para criar a tabela de usuários no banco de dados. Para aplicar a migração, execute o comando:

alembic upgrade head

Isso aplicará a migração que você acabou de gerar, criando a tabela de usuários no banco de dados.

Para testar o banco de dados e os modelos criados, você pode adicionar rotas ao seu aplicativo FastAPI para criar, listar e buscar usuários. Por exemplo:

from fastapi import FastAPI, Depends
from sqlalchemy.orm import Session
from . import models, schemas, crud
from .database import SessionLocal, engine

models.Base.metadata.create_all(bind=engine)

app = FastAPI()

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

@app.post("/users/")
def create_user(user: schemas.UserCreate, db: Session = Depends(get_db)):
    return crud.create_user(db=db, user=user)

@app.get("/users/")
def read_users(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
    users = crud.get_users(db=db, skip=skip, limit=limit)
    return users

@app.get("/users/{user_id}")
def read_user(user_id: int, db: Session = Depends(get_db)):
    user = crud.get_user(db=db, user_id=user_id)
    return user

Isso cria três rotas para criar, listar e buscar usuários no banco de dados. O código depende de modelos, esquemas e operações de CRUD que você precisa implementar conforme necessário.

Com este tutorial, você aprendeu como usar o FastAPI, SQLAlchemy e Alembic para criar um aplicativo web escalável com banco de dados relacionais e migrações controladas. Experimente modificar e expandir este projeto para criar suas próprias APIs e aplicativos web com Python.