Construindo APIs REST com FastAPI: Um Guia Completo para Iniciantes

Introdução

FastAPI é um poderoso framework para construção de APIs com Python, que se destaca pela sua velocidade e facilidade de uso. Neste artigo, exploraremos como iniciar um projeto com FastAPI e construir uma API RESTful básica, abordando suas principais funcionalidades e boas práticas.

Contexto ou Teoria

Com a crescente necessidade de aplicações web e sistemas que se comunicam de forma eficaz, o desenvolvimento de APIs se tornou um aspecto fundamental. FastAPI combina diversas vantagens, como tipagem automática, validação de dados e documentação interativa, tornando-o uma excelente escolha para desenvolvedores que buscam eficiência e simplicidade.

Demonstrações Práticas

Vamos criar uma API REST simples para gerenciar um banco de dados de usuários. Para isso, vamos utilizar FastAPI e SQLAlchemy como ORM (Object Relational Mapper).

Instalação do FastAPI

Para começarmos, você precisará instalar o FastAPI e o Uvicorn, que é um servidor ASGI. Execute os seguintes comandos no seu terminal:

pip install fastapi uvicorn
  

Estrutura do Projeto

Vamos criar a seguinte estrutura de diretórios:

/meu_projeto
│
├── main.py
├── models.py
└── schemas.py
  

Definindo o Modelo de Dados

No arquivo models.py, definimos nosso modelo de dados utilizando o SQLAlchemy. Aqui está um exemplo de modelo de usuário:

from sqlalchemy import Column, Integer, String
from sqlalchemy.ext.declarative import declarative_base

Base = declarative_base()

class User(Base):
    __tablename__ = "users"
    
    id = Column(Integer, primary_key=True, index=True)
    username = Column(String, unique=True, index=True)
    email = Column(String, unique=True, index=True)
  

Definindo os Schemas

Os schemas são usados para validar os dados que entram e saem da nossa API. No arquivo schemas.py, definimos os nossos schemas da seguinte forma:

from pydantic import BaseModel

class UserBase(BaseModel):
    username: str
    email: str
    
class UserCreate(UserBase):
    pass
    
class User(UserBase):
    id: int
    
    class Config:
        orm_mode = True
  

Implementando as Rotas da API

No arquivo main.py, importamos as dependências necessárias e implementamos as rotas.

from fastapi import FastAPI, HTTPException
from sqlalchemy.orm import sessionmaker
from sqlalchemy import create_engine
from models import Base, User
from schemas import UserCreate, User
from fastapi.middleware.cors import CORSMiddleware

app = FastAPI()

# Configuração do banco de dados (use o URL do seu banco)
SQLALCHEMY_DATABASE_URL = "sqlite:///./test.db"
engine = create_engine(SQLALCHEMY_DATABASE_URL)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

# Adicionando CORS
app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"])

# Criar o banco de dados
Base.metadata.create_all(bind=engine)

@app.post("/users/", response_model=User)
def create_user(user: UserCreate):
    db = SessionLocal()
    db_user = User(username=user.username, email=user.email)
    db.add(db_user)
    db.commit()
    db.refresh(db_user)
    db.close()
    return db_user

@app.get("/users/{user_id}", response_model=User)
def read_user(user_id: int):
    db = SessionLocal()
    user = db.query(User).filter(User.id == user_id).first()
    db.close()
    if user is None:
        raise HTTPException(status_code=404, detail="User not found")
    return user
  

Executando a API

Após configurar tudo, você pode rodar a aplicação com o comando:

uvicorn main:app --reload
  

Acesse http://127.0.0.1:8000/docs para ver a documentação gerada automaticamente pela FastAPI, onde você poderá testar as rotas.

Dicas ou Boas Práticas

• Utilize a tipagem estática do Python para melhores validações.
• Mantenha a documentação atualizada e explore a UI interativa gerada pelo FastAPI.
• Implemente autenticação e autorização onde necessário.
• Teste suas APIs com ferramentas como Postman ou Insomnia.

Conclusão com Incentivo à Aplicação

Agora você tem uma base sólida para começar a desenvolver suas próprias APIs REST com FastAPI. Explore mais sobre as funcionalidades avançadas, como dependências e autenticação, para criar APIs robustas e seguras. A prática constante e a exploração de novos recursos são essenciais para se tornar um desenvolvedor mais habilidoso!

Está desenvolvendo um projeto digital e precisa de um site moderno, performático e bem estruturado?
Eu posso te ajudar a transformar essa ideia em uma solução completa — com foco em performance, design e funcionalidade.
Acesse yurideveloper.com.br ou chame no WhatsApp: (37) 99670-7290. Vamos criar algo incrível juntos!

Resumo: Aprenda a criar uma API RESTful com FastAPI, desde a configuração do projeto até a implementação de rotas e boas práticas.

FastAPI, API REST, Python, SQLAlchemy, desenvolvimento web, frameworks, programação, tecnologias web, desenvolvimento de software, backend
Back-end