Aprenda FastAPI em um Projeto
Crie uma aplicação web completa com FastAPI! Do básico à autenticação, bancos de dados e upload de mídia. Guia passo a passo em um projeto real.
Este artigo descreve o processo de desenvolvimento do backend de um aplicativo para troca de fotos e vídeos, utilizando o framework FastAPI. O projeto abrange o ciclo completo de criação de uma API, incluindo operações básicas com dados, conexão a um banco de dados, processamento de upload de arquivos e implementação de autenticação de usuários. Assume-se que o leitor tenha experiência básica com a linguagem Python.
Introdução
O objetivo do projeto é criar uma API completa para um aplicativo que permita aos usuários carregar e visualizar fotos e vídeos. Durante o desenvolvimento, serão abordados conceitos-chave de aplicações web e APIs, bem como aspectos práticos de implementação com ferramentas modernas.
Conceitos Fundamentais de Aplicações Web e APIs
URLs, Caminhos e Endpoints
URL (Uniform Resource Locator) é o endereço de um recurso na rede. Ele é composto por vários componentes:
- Esquema: Protocolo de transferência de dados (por exemplo,
http,https). - Domínio: Nome do servidor ou endereço IP (por exemplo,
example.com). - Caminho (Path): Indica um recurso ou página específica no servidor (por exemplo,
/users/profile). O caminho define o endpoint — o ponto de entrada da API ao qual o cliente se conecta.
Parâmetros de Consulta (Query Parameters)
Parâmetros de consulta são adicionados ao URL após o ponto de interrogação (?) e são usados para filtrar ou refinar dados. Eles representam pares chave-valor, separados pelo ampersand (&).
Exemplo: /posts?category=technology&sort=date
Estrutura de Requisição e Resposta
A interação entre o cliente (por exemplo, um navegador web ou um aplicativo móvel) e o servidor ocorre através de requisições e respostas.
Requisição (Request):
- Método (HTTP Method): Define a ação que o cliente deseja executar em um recurso. Métodos principais:
GET: Obter dados.POST: Criar um novo recurso.PUT/PATCH: Atualizar um recurso existente.DELETE: Excluir um recurso.
- Caminho (Path): O endpoint da API.
- Cabeçalho (Headers): Contém metadados da requisição, como tipo de conteúdo, informações de autenticação (por exemplo, token JWT).
- Corpo (Body): Contém os dados enviados ao servidor (por exemplo, dados de formulário, objeto JSON). Usado com os métodos
POST,PUT,PATCH.
Resposta (Response):
- Código de Status (Status Code): Um número de três dígitos que indica o resultado do processamento da requisição. Os mais comuns:
200 OK: Requisição bem-sucedida.201 Created: Recurso criado com sucesso.204 No Content: Requisição bem-sucedida, mas sem corpo de resposta.400 Bad Request: Requisição inválida do cliente.401 Unauthorized: Autenticação necessária.403 Forbidden: Acesso negado.404 Not Found: Recurso não encontrado.500 Internal Server Error: Erro no lado do servidor.
- Cabeçalho (Headers): Metadados da resposta, como tipo de conteúdo.
- Corpo (Body): Dados retornados pelo servidor (frequentemente no formato JSON).
Configuração do Projeto e Instalação de Dependências
Para começar, é necessário inicializar o projeto e instalar as bibliotecas necessárias. Recomenda-se o uso do gerenciador de pacotes uv (ou pip).
-
Inicialização do projeto:
uv init .Este comando cria o arquivo
pyproject.tomlpara gerenciar as dependências do projeto. -
Instalação de dependências:
uv add fastapi uvicorn python-dotenv sqlalchemy fastapi-users imagekit-io aiosqlitefastapi: O framework principal.uvicorn: Servidor ASGI para executar aplicativos FastAPI.python-dotenv: Para carregar variáveis de ambiente de um arquivo.env.sqlalchemy: ORM para trabalhar com bancos de dados.fastapi-users: Biblioteca para implementação rápida de autenticação de usuários.imagekit-io: SDK para integração com o serviço ImageKit para processamento de arquivos de mídia.aiosqlite: Driver assíncrono para trabalhar com SQLite.
-
Variáveis de ambiente: Crie um arquivo
.envna raiz do projeto para armazenar dados confidenciais, como chaves de API do ImageKit.IMAGEKIT_PRIVATE_KEY=sua_chave_privada IMAGEKIT_PUBLIC_KEY=sua_chave_publica IMAGEKIT_URL_ENDPOINT=seu_endpoint_urlÉ necessário registrar-se no ImageKit e obter as chaves correspondentes.
Fundamentos do FastAPI
Criação de uma Instância de Aplicativo
O arquivo principal do aplicativo (por exemplo, app/main.py ou app/app.py) começa importando FastAPI e criando uma instância do aplicativo.
# app/app.py
from fastapi import FastAPI
app = FastAPI()
Definição de Endpoints
Endpoints são definidos usando decoradores correspondentes aos métodos HTTP.
# app/app.py
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
async def read_root():
return {"message": "Hello, World!"}
@app.get("/items/{item_id}")
async def read_item(item_id: int, q: str | None = None):
return {"item_id": item_id, "q": q}
@app.get("/"): Define um endpoint GET no caminho raiz.@app.get("/items/{item_id}"): Define um endpoint GET com um parâmetro de caminhoitem_id. O FastAPI converte automaticamenteitem_idparainte realiza a validação.q: str | None = None: Define um parâmetro de consulta opcionalqdo tipostr.
Execução do Aplicativo
O aplicativo é executado usando o servidor ASGI uvicorn. Crie um arquivo main.py para iniciar o servidor.
# main.py
import uvicorn
from app.app import app # Importa a instância FastAPI de app/app.py
if __name__ == "__main__":
uvicorn.run(app, host="0.0.0.0", port=8000, reload=True)
Execução:
uvicorn main:app --reload
ou
uv run main.py
Documentação Automática
O FastAPI gera automaticamente documentação interativa da API com base no código.
- Swagger UI:
/docs - ReDoc:
/redoc
Criação da API: Funcionalidade Principal
Modelos de Dados e Schemas (Pydantic)
Pydantic é usado para definir esquemas de dados que garantem a validação de dados de entrada e saída.
# app/schemas.py
from pydantic import BaseModel
from typing import Optional
class PostBase(BaseModel):
title: str
content: str
class PostCreate(PostBase):
pass
class Post(PostBase):
id: int # Ou UUID, se usado
class Config:
orm_mode = True # Para trabalhar com modelos SQLAlchemy
Parâmetros de Caminho e Consulta
- Parâmetros de Caminho: Segmentos dinâmicos do URL.
@app.get("/posts/{post_id}") async def get_post(post_id: int): # Lógica para obter o post pelo ID return {"post_id": post_id} - Parâmetros de Consulta: Parâmetros opcionais ou obrigatórios após o
?.@app.get("/posts") async def get_posts(limit: int = 10, skip: int = 0): # Lógica para obter a lista de posts com filtragem return {"limit": limit, "skip": skip}
Corpo da Requisição (Request Body)
Para enviar dados no corpo da requisição (por exemplo, ao criar um post), usa-se um schema Pydantic.
# app/app.py
from fastapi import FastAPI
from app.schemas import PostCreate, Post
from typing import List
app = FastAPI()
# Armazenamento temporário de dados (será substituído pelo banco de dados)
posts_db = {}
post_id_counter = 1
@app.post("/posts", response_model=Post)
async def create_post(post: PostCreate):
global post_id_counter
new_post = Post(id=post_id_counter, title=post.title, content=post.content)
posts_db[post_id_counter] = new_post
post_id_counter += 1
return new_post
Tipagem de Saída
Especificar o tipo de retorno melhora a documentação e a validação.
# app/app.py
from app.schemas import PostCreate, Post
from typing import List
# ... (código anterior)
@app.post("/posts", response_model=Post)
async def create_post(post: PostCreate):
# ... (lógica de criação do post)
return new_post
@app.get("/posts", response_model=List[Post])
async def get_all_posts():
return list(posts_db.values())
Integração com Banco de Dados (SQLAlchemy & AsyncIO)
Para armazenamento persistente de dados, utiliza-se um banco de dados SQLite com acesso assíncrono.
Configuração do Banco de Dados
Crie um arquivo app/db.py para configurar a conexão e os modelos de dados.
# app/db.py
from sqlalchemy import create_engine, Column, Integer, String, Text, DateTime, ForeignKey, Boolean
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.ext.asyncio import async_sessionmaker
from datetime import datetime
import uuid
from fastapi import Depends # Necessário para get_user_db
DATABASE_URL = "sqlite+aiosqlite:///./test.db"
# Criação do engine assíncrono
engine = create_async_engine(DATABASE_URL, echo=True)
# Criação da fábrica de sessões assíncronas
AsyncSessionLocal = async_sessionmaker(
autocommit=False,
autoflush=False,
class_=AsyncSession
)
# Classe base para modelos declarativos
Base = declarative_base()
# Modelo de dados para post
class Post(Base):
__tablename__ = "posts"
id = Column(Integer, primary_key=True, index=True) # Ou UUID
title = Column(String, index=True)
content = Column(Text)
created_at = Column(DateTime, default=datetime.utcnow)
user_id = Column(Integer, ForeignKey("users.id")) # Relação com o usuário
file_url = Column(String) # URL do arquivo no ImageKit
file_type = Column(String) # Tipo do arquivo (image/video)
file_name = Column(String) # Nome do arquivo no ImageKit
user = relationship("User", back_populates="posts")
# Modelo de dados para usuário (para FastAPI-Users)
class User(Base):
__tablename__ = "users"
id = Column(Integer, primary_key=True, index=True) # Ou UUID
email = Column(String, unique=True, index=True)
hashed_password = Column(String)
is_active = Column(Boolean, default=True)
is_superuser = Column(Boolean, default=False)
is_verified = Column(Boolean, default=False)
posts = relationship("Post", back_populates="user")
# Função para obter uma sessão assíncrona
async def get_async_session() -> AsyncSession:
async with AsyncSessionLocal() as session:
yield session
# Função para criar tabelas
async def create_db_tables():
async with engine.begin() as conn:
await conn.run_sync(Base.metadata.create_all)
# Para FastAPI-Users
from fastapi_users.db import SQLAlchemyUserDatabase
async def get_user_db(session: AsyncSession = Depends(get_async_session)):
yield SQLAlchemyUserDatabase(session, User)
Integração com FastAPI
Use lifespan para criar tabelas automaticamente ao iniciar o aplicativo.
# app/app.py
from fastapi import FastAPI, Depends, HTTPException, File, UploadFile, Form
from app.schemas import PostCreate, Post, UserCreate, UserRead, UserUpdate, PostWithUser # Importa esquemas de usuário e post expandido
from app.db import Post as PostModel, User as UserModel, get_async_session, create_db_tables, get_user_db # Importa modelos de BD
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.orm import Session
from sqlalchemy import select
from contextlib import asynccontextmanager
from typing import List, Optional
import shutil
import os
import uuid
# Import para ImageKit
from imagekitio import ImageKit
from imagekitio.models.models import UploadFileRequestOptions
from dotenv import load_dotenv
load_dotenv() # Carrega variáveis de ambiente
# Inicialização do ImageKit
imagekit = ImageKit(
private_key=os.getenv("IMAGEKIT_PRIVATE_KEY"),
public_key=os.getenv("IMAGEKIT_PUBLIC_KEY"),
url_endpoint=os.getenv("IMAGEKIT_URL_ENDPOINT")
)
# --- Autenticação de Usuários (FastAPI-Users) ---
from fastapi_users import FastAPIUsers, BaseUserManager, UUID_ID
from fastapi_users.authentication import (
AuthenticationBackend,
BearerTransport,
JWTStrategy,
)
from fastapi_users.db import SQLAlchemyUserDatabase
# Chave secreta para JWT (deve ser forte e armazenada em .env)
SECRET = os.getenv("JWT_SECRET_KEY", "sua_chave_super_secreta_aqui") # Recomenda-se gerar uma chave aleatória
# Gerenciador de usuários
class UserManager(BaseUserManager[UUID_ID, UserModel]):
reset_password_token_secret = SECRET
verification_token_secret = SECRET
async def get_user_manager(user_db: SQLAlchemyUserDatabase = Depends(get_user_db)):
yield UserManager(user_db)
# Transporte para tokens (Bearer Token)
bearer_transport = BearerTransport(tokenUrl="auth/jwt/login")
# Estratégia JWT
def get_jwt_strategy() -> JWTStrategy:
return JWTStrategy(secret=SECRET, lifetime_seconds=3600) # Token válido por 1 hora
# Backend de autenticação
auth_backend = AuthenticationBackend(
name="jwt",
transport=bearer_transport,
get_strategy=get_jwt_strategy,
)
fastapi_users = FastAPIUsers[UserModel, UUID_ID](
get_user_manager, auth_backend
)
# Obtenção do usuário ativo atual
current_active_user = fastapi_users.current_user(active=True)
# --- Gerenciador de contexto para o ciclo de vida do aplicativo ---
@asynccontextmanager
async def lifespan(app: FastAPI):
await create_db_tables() # Cria tabelas ao iniciar
yield
app = FastAPI(lifespan=lifespan)
# --- Inclusão de rotas de autenticação ---
app.include_router(
fastapi_users.get_auth_router(auth_backend), prefix="/auth/jwt", tags=["auth"]
)
app.include_router(
fastapi_users.get_register_router(UserRead, UserCreate), prefix="/auth", tags=["auth"]
)
app.include_router(
fastapi_users.get_reset_password_router(), prefix="/auth", tags=["auth"]
)
app.include_router(
fastapi_users.get_verify_router(), prefix="/auth", tags=["auth"]
)
app.include_router(
fastapi_users.get_users_router(), prefix="/users", tags=["users"]
)
# --- Endpoints da API ---
# Obtenção do usuário atual (endpoint protegido)
@app.get("/users/me", response_model=UserRead)
async def read_users_me(current_user: UserModel = Depends(current_active_user)):
return current_user
# Obtenção de todos os posts (endpoint protegido)
@app.get("/feed", response_model=List[PostWithUser])
async def get_feed(
session: AsyncSession = Depends(get_async_session),
current_user: UserModel = Depends(current_active_user) # Autenticação necessária
):
# Consulta de posts com informações do usuário
stmt = select(PostModel).order_by(PostModel.created_at.desc())
result = await session.execute(stmt)
posts = result.scalars().all()
# Formatação da resposta com informações do usuário e status de proprietário
posts_data = []
for post in posts:
is_owner = (post.user_id == current_user.id)
posts_data.append(PostWithUser(
id=post.id,
title=post.title,
content=post.content,
created_at=post.created_at,
user_id=post.user_id,
file_url=post.file_url,
file_type=post.file_type,
file_name=post.file_name,
is_owner=is_owner,
user_email=post.user.email if post.user else "Unknown"
))
return posts_data
# Upload de arquivo (foto/vídeo) e criação de post (endpoint protegido)
@app.post("/upload", response_model=PostWithUser)
async def upload_file(
file: UploadFile = File(...),
caption: str = Form(...),
session: AsyncSession = Depends(get_async_session),
current_user: UserModel = Depends(current_active_user) # Autenticação necessária
):
# Geração de nome de arquivo único
file_extension = os.path.splitext(file.filename)[1]
unique_filename = f"{uuid.uuid4()}{file_extension}"
# Upload do arquivo para o ImageKit
try:
upload_result = imagekit.upload_file(
file=file.file,
file_name=unique_filename,
options=UploadFileRequestOptions(
use_unique_file_name=True,
tags=["backend_upload"],
folder="uploads" # Opcional: pasta no ImageKit
)
)
file_url = upload_result.url
file_type = "video" if file.content_type.startswith("video/") else "image"
file_name = upload_result.name
# Criação de um novo post no banco de dados
new_post = PostModel(
title=caption, # Usa caption como título
content=caption, # Ou pode adicionar um campo separado para conteúdo
user_id=current_user.id,
file_url=file_url,
file_type=file_type,
file_name=file_name
)
session.add(new_post)
await session.commit()
await session.refresh(new_post)
# Retorna os dados do post, incluindo URL e informações do usuário
return PostWithUser(
id=new_post.id,
title=new_post.title,
content=new_post.content,
created_at=new_post.created_at,
user_id=new_post.user_id,
file_url=new_post.file_url,
file_type=new_post.file_type,
file_name=new_post.file_name,
is_owner=True, # Novo post sempre pertence ao usuário atual
user_email=current_user.email
)
except Exception as e:
raise HTTPException(status_code=500, detail=f"Falha no upload do arquivo: {e}")
# Exclusão de post (endpoint protegido)
@app.delete("/posts/{post_id}", response_model=dict)
async def delete_post(
post_id: int,
session: AsyncSession = Depends(get_async_session),
current_user: UserModel = Depends(current_active_user) # Autenticação necessária
):
# Obtém o post do banco de dados
stmt = select(PostModel).where(PostModel.id == post_id)
result = await session.execute(stmt)
post = result.scalars().first()
if not post:
raise HTTPException(status_code=404, detail="Post não encontrado")
# Verificação de permissão: apenas o autor do post pode excluí-lo
if post.user_id != current_user.id:
raise HTTPException(status_code=403, detail="Você não tem permissão para excluir este post")
# Exclusão do post do banco de dados
await session.delete(post)
await session.commit()
return {"message": "Post excluído com sucesso"}
# --- Esquemas adicionais para usuários ---
# Estes esquemas herdam dos esquemas padrão do FastAPI-Users,
# mas podem ser expandidos conforme necessário.
from fastapi_users import schemas
class UserRead(schemas.BaseUser[uuid.UUID]):
email: str
is_active: bool = True
is_superuser: bool = False
is_verified: bool = False
id: uuid.UUID # Garanta que o ID corresponda ao tipo no modelo de BD
class UserCreate(schemas.BaseUserCreate):
password: str
email: str
is_active: bool = True
is_superuser: bool = False
is_verified: bool = False
class UserUpdate(schemas.BaseUserUpdate):
password: Optional[str] = None
email: Optional[str] = None
is_active: Optional[bool] = None
is_superuser: Optional[bool] = None
is_verified: Optional[bool] = None
# Atualização do modelo Post para incluir informações do usuário e status de proprietário
class PostWithUser(Post): # Herda de Post (que é a classe Pydantic baseada no SQLAlchemy PostModel)
user_id: Optional[int] # Ou UUID
file_url: str
file_type: str
file_name: str
is_owner: bool
user_email: str
# Atualização do endpoint get_feed para retornar PostWithUser
@app.get("/feed", response_model=List[PostWithUser])
async def get_feed(
session: AsyncSession = Depends(get_async_session),
current_user: UserModel = Depends(current_active_user)
):
stmt = select(PostModel).order_by(PostModel.created_at.desc())
result = await session.execute(stmt)
posts = result.scalars().all()
posts_data = []
for post in posts:
is_owner = (post.user_id == current_user.id)
posts_data.append(PostWithUser(
id=post.id,
title=post.title,
content=post.content,
created_at=post.created_at,
user_id=post.user_id,
file_url=post.file_url,
file_type=post.file_type,
file_name=post.file_name,
is_owner=is_owner,
user_email=post.user.email if post.user else "Unknown"
))
return posts_data
# Atualização do endpoint upload_file para retornar PostWithUser
@app.post("/upload", response_model=PostWithUser)
async def upload_file(
file: UploadFile = File(...),
caption: str = Form(...),
session: AsyncSession = Depends(get_async_session),
current_user: UserModel = Depends(current_active_user)
):
file_extension = os.path.splitext(file.filename)[1]
unique_filename = f"{uuid.uuid4()}{file_extension}"
try:
upload_result = imagekit.upload_file(
file=file.file,
file_name=unique_filename,
options=UploadFileRequestOptions(
use_unique_file_name=True,
tags=["backend_upload"],
folder="uploads"
)
)
file_url = upload_result.url
file_type = "video" if file.content_type.startswith("video/") else "image"
file_name = upload_result.name
new_post = PostModel(
title=caption,
content=caption,
user_id=current_user.id,
file_url=file_url,
file_type=file_type,
file_name=file_name
)
session.add(new_post)
await session.commit()
await session.refresh(new_post)
return PostWithUser(
id=new_post.id,
title=new_post.title,
content=new_post.content,
created_at=new_post.created_at,
user_id=new_post.user_id,
file_url=new_post.file_url,
file_type=new_post.file_type,
file_name=new_post.file_name,
is_owner=True, # Novo post sempre pertence ao usuário atual
user_email=current_user.email
)
except Exception as e:
raise HTTPException(status_code=500, detail=f"Falha no upload do arquivo: {e}")
# Atualização do modelo Post para incluir ForeignKey e relationship
# Em app/db.py:
# Adicionar à classe Post:
# user_id = Column(Integer, ForeignKey("users.id"))
# user = relationship("User", back_populates="posts")
# Adicionar à classe User:
# posts = relationship("Post", back_populates="user")
# Certifique-se de que User e Post herdam de Base e tenham os campos correspondentes.
# Também é necessário atualizar os esquemas Pydantic (PostCreate, Post, UserRead, UserCreate, UserUpdate)
# e garantir que eles correspondam aos modelos SQLAlchemy.
Upload de Arquivos com ImageKit
A integração com o ImageKit permite gerenciar facilmente arquivos de mídia.
-
Inicialização do ImageKit: Em
app/app.py, importe e inicialize o cliente ImageKit usando as chaves do.env. -
Processamento de Upload: O endpoint
/uploadrecebeUploadFileecaptionde um formulário. O arquivo é carregado para o ImageKit, e a URL recebida é salva no banco de dados junto com as informações do post e do usuário.# Em app/app.py from fastapi import File, UploadFile, Form # ... (outras importações) @app.post("/upload", response_model=PostWithUser) async def upload_file( file: UploadFile = File(...), caption: str = Form(...), session: AsyncSession = Depends(get_async_session), current_user: UserModel = Depends(current_active_user) ): # ... (lógica de upload para ImageKit e salvamento no BD) pass
Transformações de Mídia
O ImageKit permite aplicar transformações em imagens e vídeos diretamente através da URL. Por exemplo, redimensionamento, adição de texto, aplicação de efeitos.
Exemplo de URL com transformações:
https://ik.imagekit.io/sua_chave_publica/seu_nome_arquivo.jpg?tr=w-300,h-200,fo-auto
Autenticação e Autorização (FastAPI-Users)
O FastAPI-Users simplifica a implementação de autenticação de usuários usando JWT (JSON Web Tokens).
Conceito de JWT
JWT é um padrão para transferência segura de informações entre partes na forma de um objeto JSON. Ele consiste em três partes: cabeçalho, payload e assinatura. O token é assinado com uma chave secreta do servidor, o que permite verificar sua autenticidade.
Configuração do FastAPI-Users
- Modelos de Usuário: Defina o modelo
Useremapp/db.py, que herda deSQLAlchemyUserTablee inclui os campos necessários (email, senha, papéis). - Esquemas de Usuário: Crie os esquemas
UserRead,UserCreate,UserUpdateemapp/schemas.py. - Gerenciador de Usuário e Backend de Autenticação: Configure
UserManager,BearerTransport,JWTStrategyeAuthenticationBackendemapp/app.py. - Inclusão de Rotas: Use
app.include_router()para adicionar as rotas padrão de autenticação (registro, login, recuperação de senha).
Proteção de Endpoints
Para proteger endpoints, adicione a dependência Depends(current_active_user) às funções do endpoint. Se o usuário não estiver autenticado, a requisição será rejeitada.
# app/app.py
from fastapi_users import FastAPIUsers, BaseUserManager, UUID_ID
from fastapi_users.authentication import (
AuthenticationBackend,
BearerTransport,
JWTStrategy,
)
from fastapi_users.db import SQLAlchemyUserDatabase
# ... (definição de modelos e esquemas)
# Obtenção do usuário ativo atual
current_active_user = fastapi_users.current_user(active=True)
@app.get("/protected-route")
async def protected_route(current_user: UserModel = Depends(current_active_user)):
return {"message": f"Olá, {current_user.email}!"}
Autorização (Verificação de Permissões)
Ao excluir um post, é necessário garantir que o usuário atual seja o autor do post.
# app/app.py
@app.delete("/posts/{post_id}", response_model=dict)
async def delete_post(
post_id: int,
session: AsyncSession = Depends(get_async_session),
current_user: UserModel = Depends(current_active_user)
):
# ... (obtenção do post)
if post.user_id != current_user.id:
raise HTTPException(status_code=403, detail="Você não tem permissão para excluir este post")
# ... (exclusão do post)
Frontend (Streamlit)
Para demonstrar o funcionamento da API, um frontend simples pode ser criado usando a biblioteca Streamlit. O Streamlit permite criar rapidamente aplicativos web interativos em Python.
-
Instalação do Streamlit:
uv add streamlit -
Criação do arquivo de frontend: Crie um arquivo
frontend.pycom código que interage com a API (envia requisições de autenticação, upload de arquivos, obtenção do feed). O código do frontend geralmente inclui:- Gerenciamento de estado da sessão (armazenamento do token JWT).
- Funções para enviar requisições HTTP com o token no cabeçalho.
- Interfaces para registro, login, upload de arquivos, exibição do feed.
-
Execução do Streamlit:
uv run streamlit run frontend.py
Conclusão
O aplicativo desenvolvido demonstra uma abordagem abrangente para a criação de uma API web moderna usando FastAPI. Ele inclui o processamento de requisições, interação com banco de dados, autenticação segura de usuários e integração com serviços externos para processamento de arquivos de mídia. A API resultante serve como base para a criação de aplicações web escaláveis e confiáveis.
Visão Geral do Vídeo
Visão geral do vídeo e demonstração do projeto finalizado.
- Demonstração de aplicação de fotos/vídeos.
- Capacidade de login, visualização do feed, upload de conteúdo.
- Uso de Streamlit para o frontend.
Arquitetura e Teoria da Aplicação Web
Explicação da arquitetura da aplicação web e conceitos teóricos fundamentais.
- Conceitos de URL, domínio, caminho (endpoint).
- Papel dos parâmetros de consulta (query parameters).
- Estrutura de requisição (request) e resposta (response).
- Métodos HTTP: GET, POST, PUT, DELETE.
- Status HTTP (200, 404, etc.).
Configuração do Projeto e Instalação
Configuração do ambiente de desenvolvimento e instalação das dependências necessárias.
- Uso de
uvpara gerenciamento de dependências. - Instalação de
fastapi,python-dotenv,fastapi-users,sqlalchemy,imagekitio,uvicorn. - Criação de arquivo
.envpara armazenamento de chaves.
Configuração do FastAPI e Fundamentos
Criação básica da aplicação FastAPI e configuração do primeiro endpoint.
- Criação de uma instância
FastAPI. - Definição do endpoint
/hello-worldcom método GET. - Retorno de uma resposta JSON.
- Execução do servidor usando
uvicorn. - Uso de
/docspara documentação automática.
GET e Obtenção de Posts
Trabalho com endpoints para obter dados, incluindo parâmetros de caminho e de consulta.
- Criação do endpoint
/postspara obter todos os posts. - Uso de parâmetros de caminho (path parameters) (ex:
/post/{id}) para obter um post específico. - Tratamento de erros (HTTPException 404).
- Uso de parâmetros de consulta (query parameters) (ex:
limit) para filtragem.
Request Body e POST
Implementação do endpoint POST para criar novas entradas usando modelos Pydantic.
- Definição do esquema de dados usando Pydantic (
PostCreate). - Recebimento de dados via corpo da requisição (request body).
- Validação automática de dados do FastAPI.
- Criação de um novo post e retorno dele.
Conexão com Banco de Dados
Conexão com um banco de dados SQLite e definição de modelos de dados.
- Uso de SQLAlchemy para ORM.
- Configuração do engine assíncrono
create_async_engine. - Definição do modelo
Postcom camposid,caption,url,file_type,file_name,created_at. - Configuração do ciclo de vida da aplicação (
lifespan) para criar tabelas.
Upload de Imagens e Vídeos (ImageKit)
Implementação do upload de arquivos (imagens e vídeos) usando ImageKit.
- Integração com ImageKit para armazenamento e processamento de mídia.
- Criação de arquivos temporários para upload.
- Uso de
upload_filedoimagekitio. - Armazenamento do URL do arquivo e metadados no banco de dados.
- Tratamento de erros de upload.
Exclusão de Posts
Implementação da funcionalidade de exclusão de entradas do banco de dados.
- Criação do endpoint DELETE
/post/{post_id}. - Obtenção do ID do post a partir do parâmetro de caminho.
- Busca do post no banco de dados.
- Exclusão do post e confirmação da operação.
Autenticação de Usuários e Tokens JWT
Configuração da autenticação de usuários usando JWT e FastAPI Users.
- Uso de
fastapi-userspara gerenciamento de usuários. - Configuração da estratégia JWT e do backend de autenticação.
- Definição dos modelos
Usere relacionamentos comPost. - Criação de endpoints para registro, login, logout.
Proteção de Endpoints
Proteção de endpoints da API para que apenas usuários autenticados tenham acesso.
- Uso de
Depends(current_active_user)para proteger endpoints. - Verificação de permissões ao excluir um post.
- Exibição de informações do usuário no feed.
- Uso de Streamlit para o frontend.
Frontend em Streamlit
Criação de uma interface de usuário simples usando Streamlit para interagir com a API.
- Uso de Streamlit para criar a UI.
- Gerenciamento do token JWT na sessão.
- Implementação da lógica de login, registro, upload de arquivos e exibição do feed.
- Aplicação de ImageKit para exibir imagens com transformações.
