No mundo tecnológico de hoje, construir APIs rápidas, eficientes e escaláveis é crucial para os desenvolvedores. Uma combinação poderosa que está ganhando popularidade é usar FastAPI com MongoDB. FastAPI, como o próprio nome sugere, é um framework web moderno e de alto desempenho para construir APIs com Python 3.7+ que é rápido para codificar e rodar. Enquanto isso, MongoDB é um banco de dados NoSQL conhecido por sua escalabilidade e flexibilidade. Juntos, eles fornecem uma solução robusta para criar APIs que podem lidar com tudo, desde um pequeno projeto até uma aplicação de grande escala.
Então, por que você deveria considerar essa dupla para seu próximo projeto? Vamos mergulhar!
Começando: Configurando Seu Ambiente
Antes de começarmos a construir nossa API, vamos configurar nosso ambiente. Você precisará do Python instalado em seu sistema, juntamente com o pip para gerenciar pacotes.
Passo 1: Instalar FastAPI e Uvicorn
Primeiro, vamos instalar FastAPI. Abra seu terminal e execute o seguinte comando:
pip install fastapi
Em seguida, vamos instalar o Uvicorn, uma implementação de servidor ASGI para Python, que servirá nossa aplicação FastAPI:
pip install uvicorn
Passo 2: Instalar Motor
Motor é o driver assíncrono para MongoDB que funciona perfeitamente com FastAPI. Para instalá-lo, execute:
pip install motor
Ótimo! Agora temos tudo o que precisamos para começar a codificar.
Criando Sua Primeira Aplicação FastAPI
Agora, vamos criar uma aplicação FastAPI básica e conectá-la ao MongoDB.
Passo 1: Inicializar Aplicativo FastAPI
Crie um novo arquivo Python (vamos nomeá-lo main.py) e comece importando o FastAPI e inicializando o aplicativo:
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
async def read_root():
return {"message": "Bem-vindo ao tutorial FastAPI com MongoDB!"}
Este código configura uma aplicação FastAPI básica com um único endpoint.
Passo 2: Conectar ao MongoDB
Em seguida, vamos conectar nossa aplicação FastAPI ao MongoDB usando o Motor. Vamos criar um novo arquivo chamado database.py para gerenciar nossa conexão com o banco de dados.
from motor.motor_asyncio import AsyncIOMotorClient
MONGO_DETAILS = "mongodb://localhost:27017"
client = AsyncIOMotorClient(MONGO_DETAILS)
database = client.mydatabase
Neste exemplo, nos conectamos a uma instância do MongoDB que está rodando localmente. Certifique-se de que o MongoDB esteja instalado e em execução em seu sistema.
Passo 3: Definir Modelos Pydantic
Os modelos Pydantic são uma ótima maneira de definir estruturas de dados e garantir a validação de dados no FastAPI. Crie um arquivo models.py:
from pydantic import BaseModel
class Item(BaseModel):
name: str
description: str
price: float
available: bool = True
Este modelo define a estrutura de um item em nosso inventário.
Criando Endpoints de API
Com a configuração básica resolvida, vamos criar alguns endpoints de API para interagir com nosso banco de dados MongoDB.
Passo 1: Criar Coleção de Itens
Primeiro, precisamos de uma coleção em nosso banco de dados MongoDB para armazenar itens. Em main.py, vamos criar um endpoint para adicionar novos itens ao banco de dados:
from fastapi import FastAPI, HTTPException
from database import database
from models import Item
from bson import ObjectId
app = FastAPI()
@app.post("/items/")
async def create_item(item: Item):
item_dict = item.dict()
result = await database["items"].insert_one(item_dict)
item_dict["_id"] = str(result.inserted_id)
return item_dict
Este endpoint nos permite criar novos itens na coleção MongoDB. Note como convertimos o ID inserido em uma string para melhor legibilidade.
Passo 2: Recuperar Itens
Em seguida, vamos criar um endpoint para recuperar todos os itens do banco de dados:
@app.get("/items/")
async def get_items():
items = await database["items"].find().to_list(1000)
for item in items:
item["_id"] = str(item["_id"])
return items
Este endpoint busca todos os itens da coleção items e converte seus IDs em strings.
Passo 3: Recuperar um Único Item
Para recuperar um único item pelo seu ID, vamos adicionar outro endpoint:
@app.get("/items/{item_id}")
async def get_item(item_id: str):
item = await database["items"].find_one({"_id": ObjectId(item_id)})
if item:
item["_id"] = str(item["_id"])
return item
raise HTTPException(status_code=404, detail="Item não encontrado")
Este endpoint busca um item pelo seu ID e o retorna, ou levanta um erro 404 se o item não for encontrado.
Passo 4: Atualizar um Item
Atualizar um item é simples com FastAPI e Motor. Adicione o seguinte código para atualizar um item pelo seu ID:
@app.put("/items/{item_id}")
async def update_item(item_id: str, item: Item):
result = await database["items"].update_one(
{"_id": ObjectId(item_id)}, {"$set": item.dict()}
)
if result.modified_count == 1:
updated_item = await database["items"].find_one({"_id": ObjectId(item_id)})
updated_item["_id"] = str(updated_item["_id"])
return updated_item
raise HTTPException(status_code=404, detail="Item não encontrado")
Este endpoint atualiza um item pelo seu ID e retorna o item atualizado.
Passo 5: Deletar um Item
Finalmente, vamos adicionar um endpoint para deletar um item pelo seu ID:
@app.delete("/items/{item_id}")
async def delete_item(item_id: str):
result = await database["items"].delete_one({"_id": ObjectId(item_id)})
if result.deleted_count == 1:
return {"message": "Item deletado"}
raise HTTPException(status_code=404, detail="Item não encontrado")
Este endpoint deleta um item e retorna uma mensagem de sucesso ou um erro 404 se o item não for encontrado.
Como Conectar ao Banco de Dados MongoDB ao Apidog
- Clique em "Operação de Processadores" na API e selecione "Operações de Banco de Dados".
2. Clique em "Gerenciar Conexão com o Banco de Dados" na caixa suspensa sob "Conexão com o Banco de Dados", em seguida, clique no botão "Novo" no canto superior direito.
3. Selecione o tipo de banco de dados MongoDB, em seguida, preencha as informações de conexão correspondentes.
Operar Banco de Dados MongoDB
MongoDB armazena dados no formato de documento BSON. Para conveniência da maioria dos hábitos de uso dos usuários, ao modificar bancos de dados MongoDB no Apidog, envie arquivos no formato JSON. O sistema mapeará automaticamente cada campo para o tipo de dado BSON correspondente com base no conteúdo real do JSON.
Entre eles, o campo _id é relativamente especial. De acordo com as especificações do MongoDB, cada documento deve ter um campo _id como chave primária, e o tipo de dado padrão deste campo é ObjectId, não String.
Se você precisar declarar um campo _id do tipo ObjectId, você pode usar o formato de string convencional. Se o conteúdo da string estiver em conformidade com o formato ObjectId, o Apidog mapeará automaticamente para o tipo ObjectId no BSON.
Suponha que exista um documento BSON desse tipo no MongoDB agora:
{ _id: ObjectId('6569a36afcf5ee79c08d2f94'), name: "Apidog"}Então, ao usar Apidog para consultar o documento via _id, o valor JSON que precisa ser inserido nas "Condições de Consulta" é:
{ "_id": "6569a36afcf5ee79c08d2f94" }Operações Comuns
Para operações CRUD comuns, suporte via operações de API visuais. Não é necessário escrever nenhum código JavaScript, apenas especifique a ação em "Tipo de Operação", em seguida, especifique o "Nome da Coleção", e depois escreva o conteúdo correspondente em JSON nas "Condições de Consulta".
Por exemplo, para a operação de consulta mencionada acima, você pode visualizar o documento consultado no console após inserir o comando e habilitar "Console Log".
Comandos Avançados
Se você precisar de operações mais avançadas, também pode executar comandos de banco de dados diretamente. Em "Tipo de Operação", selecione "Executar Comando de Banco de Dados" e insira o comando de banco de dados no formato JSON. Observe que o comando de banco de dados não se refere a chamadas de método como db.collection.findOne(), mas a dados JSON em um formato específico.
Por exemplo, para consultar a quantidade de documentos na coleção de usuários, você pode usar o comando de banco de dados count:
{ "count": "users"}Depois de inserir o comando, você pode visualizar o resultado no console.
Testando Sua API
Para testar sua API, você pode usar ferramentas como Postman ou Apidog. Essas ferramentas permitem que você envie solicitações para seus endpoints e veja as respostas, facilitando a depuração e garantindo que tudo esteja funcionando corretamente.
Usando Apidog para Testes
Apidog é uma poderosa ferramenta de desenvolvimento e teste de API que simplifica o processo de criação, teste e gerenciamento de APIs. Aqui está como você pode usar o Apidog para testar sua aplicação FastAPI com MongoDB:
- Criar um Novo Projeto: Abra o Apidog Client e crie um novo projeto no Apidog.
2 Adicionar Endpoints: Adicione os endpoints que você criou (/items/, /items/{item_id}, etc.) ao projeto.
3. Enviar Solicitações: Use a ferramenta para enviar solicitações GET, POST, PUT e DELETE para seus endpoints e observe as respostas.
4. Validar Respostas: Certifique-se de que as respostas correspondam às saídas esperadas e use as mensagens de erro detalhadas para corrigir quaisquer problemas.
Conclusão
Neste tutorial, cobrimos o básico de configurar uma aplicação FastAPI com MongoDB. Criamos uma API de inventário simples que permite criar, recuperar, atualizar e deletar itens. A velocidade e facilidade de uso do FastAPI, combinadas com a flexibilidade e escalabilidade do MongoDB, fazem deles uma combinação perfeita para construir APIs robustas.
Ao aproveitar ferramentas como Apidog, você pode simplificar o processo de desenvolvimento e teste, garantindo que suas APIs sejam confiáveis e eficientes.
Então, o que você está esperando? Mergulhe no FastAPI e MongoDB e comece a construir APIs incríveis hoje!
