En el mundo actual impulsado por la tecnología, construir APIs rápidas, eficientes y escalables es crucial para los desarrolladores. Una combinación poderosa que está ganando popularidad es usar FastAPI con MongoDB. FastAPI, como su nombre indica, es un framework web moderno de alto rendimiento para construir APIs con Python 3.7+ que es rápido de codificar y ejecutar. Mientras tanto, MongoDB es una base de datos NoSQL conocida por su escalabilidad y flexibilidad. Juntos, proporcionan una solución robusta para crear APIs que pueden manejar cualquier cosa, desde un pequeño proyecto hasta una aplicación a gran escala.
Entonces, ¿por qué deberías considerar este dúo para tu próximo proyecto? ¡Vamos a sumergirnos!
Empezando: Configurando tu Entorno
Antes de que empecemos a construir nuestra API, configuremos nuestro entorno. Necesitarás Python instalado en tu sistema, junto con pip para gestionar los paquetes.
Paso 1: Instala FastAPI y Uvicorn
Primero, instalemos FastAPI. Abre tu terminal y ejecuta el siguiente comando:
pip install fastapi
A continuación, instalaremos Uvicorn, una implementación de servidor ASGI para Python, que servirá nuestra aplicación FastAPI:
pip install uvicorn
Paso 2: Instala Motor
Motor es el driver asíncrono para MongoDB que funciona perfectamente con FastAPI. Para instalarlo, ejecuta:
pip install motor
¡Genial! Ahora tenemos todo lo que necesitamos para empezar a codificar.
Creando tu Primera Aplicación FastAPI
Ahora, creemos una aplicación FastAPI básica y conectémosla a MongoDB.
Paso 1: Inicializa la App FastAPI
Crea un nuevo archivo Python (llamémoslo main.py) y empieza importando FastAPI e inicializando la app:
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
async def read_root():
return {"message": "¡Bienvenido al tutorial de FastAPI con MongoDB!"}
Este código configura una aplicación FastAPI básica con un único endpoint.
Paso 2: Conecta a MongoDB
A continuación, conectemos nuestra aplicación FastAPI a MongoDB usando Motor. Crearemos un nuevo archivo llamado database.py para gestionar nuestra conexión a la base de datos.
from motor.motor_asyncio import AsyncIOMotorClient
MONGO_DETAILS = "mongodb://localhost:27017"
client = AsyncIOMotorClient(MONGO_DETAILS)
database = client.mydatabase
En este ejemplo, nos conectamos a una instancia de MongoDB que se ejecuta localmente. Asegúrate de que MongoDB esté instalado y ejecutándose en tu sistema.
Paso 3: Define Modelos Pydantic
Los modelos Pydantic son una excelente manera de definir estructuras de datos y asegurar la validación de datos en FastAPI. Crea un archivo models.py:
from pydantic import BaseModel
class Item(BaseModel):
name: str
description: str
price: float
available: bool = True
Este modelo define la estructura de un elemento en nuestro inventario.
Creando Endpoints de la API
Con la configuración básica fuera del camino, creemos algunos endpoints de la API para interactuar con nuestra base de datos MongoDB.
Paso 1: Crea la Colección de Items
Primero, necesitamos una colección en nuestra base de datos MongoDB para almacenar items. En main.py, creemos un endpoint para añadir nuevos items a la base de datos:
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 crear nuevos items en la colección MongoDB. Observa cómo convertimos el ID insertado a una cadena para una mejor legibilidad.
Paso 2: Recupera Items
A continuación, crearemos un endpoint para recuperar todos los items de la base de datos:
@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 obtiene todos los items de la colección items y convierte sus IDs a cadenas.
Paso 3: Recupera un Item Individual
Para recuperar un solo item por su ID, añadiremos otro 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 no encontrado")
Este endpoint obtiene un item por su ID y lo devuelve, o lanza un error 404 si el item no se encuentra.
Paso 4: Actualiza un Item
Actualizar un item es sencillo con FastAPI y Motor. Añade el siguiente código para actualizar un item por su 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 no encontrado")
Este endpoint actualiza un item por su ID y devuelve el item actualizado.
Paso 5: Elimina un Item
Finalmente, añadamos un endpoint para eliminar un item por su 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 eliminado"}
raise HTTPException(status_code=404, detail="Item no encontrado")
Este endpoint elimina un item y devuelve un mensaje de éxito o un error 404 si el item no se encuentra.
Cómo Conectar a la Base de Datos MongoDB a Apidog
- Haz clic en "Operación de Procesadores" en la API y selecciona "Operaciones de Base de Datos".
2. Haz clic en "Gestionar Conexión de Base de Datos" en el cuadro desplegable debajo de "Conexión de Base de Datos", luego haz clic en el botón "Nuevo" en la esquina superior derecha.
3. Selecciona el tipo de base de datos MongoDB, luego rellena la información de conexión correspondiente.
Operar la Base de Datos MongoDB
MongoDB almacena datos en formato de documento BSON. Para la conveniencia de los hábitos de uso de la mayoría de los usuarios, al modificar las bases de datos MongoDB en Apidog, envía archivos en formato JSON. El sistema mapeará automáticamente cada campo al tipo de datos BSON correspondiente basándose en el contenido real del JSON.
Entre ellos, el campo _id es relativamente especial. De acuerdo con las especificaciones de MongoDB, cada documento debe tener un campo _id como clave primaria, y el tipo de datos predeterminado de este campo es ObjectId en lugar de String.
Si necesitas declarar un campo _id de tipo ObjectId, puedes usar el formato de cadena convencional. Si el contenido de la cadena se ajusta al formato ObjectId, Apidog lo mapeará automáticamente al tipo ObjectId en BSON.
Supongamos que hay un documento BSON en MongoDB ahora:
{ _id: ObjectId('6569a36afcf5ee79c08d2f94'), name: "Apidog"}Entonces, al usar Apidog para consultar el documento a través de _id, el valor JSON que necesita ser ingresado en las "Condiciones de Consulta" es:
{ "_id": "6569a36afcf5ee79c08d2f94" }Operaciones Comunes
Para las operaciones CRUD comunes, se admite a través de operaciones visuales de la API. No es necesario escribir ningún código JavaScript, solo especifica la acción en el "Tipo de Operación", luego especifica el "Nombre de la Colección" y luego escribe el contenido correspondiente en JSON en "Condiciones de Consulta".
Por ejemplo, para la operación de consulta mencionada anteriormente, puedes ver el documento consultado en la consola después de ingresar el comando y habilitar "Registro de Consola".
Comandos Avanzados
Si necesitas operaciones más avanzadas, también puedes ejecutar directamente comandos de la base de datos. En "Tipo de Operación", selecciona "Ejecutar Comando de Base de Datos" y luego ingresa el comando de la base de datos en formato JSON. Ten en cuenta que el comando de la base de datos no se refiere a llamadas de método como db.collection.findOne(), sino a datos JSON en un formato específico.
Por ejemplo, para consultar el número de documentos en la colección de usuarios, puedes usar el comando de base de datos count:
{ "count": "users"}Después de ingresar el comando, puedes ver el resultado en la consola.
Probando tu API
Para probar tu API, puedes usar herramientas como Postman o Apidog. Estas herramientas te permiten enviar peticiones a tus endpoints y ver las respuestas, facilitando la depuración y asegurando que todo está funcionando correctamente.
Usando Apidog para Pruebas
Apidog es una poderosa herramienta de desarrollo y prueba de APIs que simplifica el proceso de crear, probar y gestionar APIs. Aquí te mostramos cómo puedes usar Apidog para probar tu aplicación FastAPI MongoDB:
- Crea un Nuevo Proyecto: Abre el Cliente Apidog y Crea un nuevo proyecto en Apidog.
2 Añade Endpoints: Añade los endpoints que has creado (/items/, /items/{item_id}, etc.) al proyecto.
3. Envía Peticiones: Usa la herramienta para enviar peticiones GET, POST, PUT y DELETE a tus endpoints y observa las respuestas.
4. Valida las Respuestas: Asegúrate de que las respuestas coinciden con las salidas esperadas, y usa los mensajes de error detallados para solucionar cualquier problema.
Conclusión
En este tutorial, hemos cubierto los conceptos básicos de la configuración de una aplicación FastAPI con MongoDB. Creamos una API de inventario simple que te permite crear, recuperar, actualizar y eliminar items. La velocidad y facilidad de uso de FastAPI, combinadas con la flexibilidad y escalabilidad de MongoDB, las convierten en una pareja perfecta para construir APIs robustas.
Al aprovechar herramientas como Apidog, puedes optimizar el proceso de desarrollo y prueba, asegurando que tus APIs sean fiables y tengan un buen rendimiento.
Entonces, ¿a qué estás esperando? ¡Sumérgete en FastAPI y MongoDB, y empieza a construir APIs increíbles hoy mismo!
