La creación de una API REST suele ser una tarea mecánica, que implica mucho diseño repetitivo y programación de memoria. Afortunadamente, herramientas como FastAPI pueden aliviar muchos de los tediosos detalles.
Con FastAPI, puede crear rápidamente una API REST completa y eficiente para su aplicación CRUD. Con MongoDB como fuente de datos, este tutorial lo guiará para configurar su propia API en poco tiempo.
¿Qué es FastAPI?
API rápida es un marco web de Python rápido y de código abierto para crear API. Proporciona soporte integrado para solicitudes asincrónicas, validación automática de datos y documentación automática de puntos finales de API.
Las ventajas de FastAPI sobre otros frameworks de Python
- FastAPI es relativamente más rápido que otros marcos como Django y Flask. Esto se debe a que FastAPI se basa en asyncio, una biblioteca de E/S asíncrona para Python que puede procesar solicitudes simultáneas con mayor rapidez.
- FastAPI proporciona una forma limpia y sencilla de crear API con un esfuerzo mínimo, ya que requiere menos código que Flask o Django.
- Finalmente, FastAPI facilita la generación de documentación para puntos finales. Utiliza Swagger para producir documentación que puede usar para probar los puntos finales mediante la ejecución de solicitudes y la visualización de respuestas.
Configurar una base de datos MongoDB
Para empezar, necesitarás configurar la base de datos MongoDB localmente. Alternativamente, puede optar por la opción más fácil de configurar un clúster de MongoDB en la nube.
A continuación, utilizando la herramienta de interfaz gráfica de usuario MongoDB instalada, Compass, cree una conexión de base de datos. Haga clic en el Nueva conexión y proporcione el URI de conexión para establecer una conexión con el servidor MongoDB que se ejecuta localmente.
Finalmente, cree una nueva base de datos y una colección para almacenar los datos de su API de prueba.
Configurar un servidor FastAPI
Usando una terminal, cree una carpeta de proyecto e ingrese ese nuevo directorio.
Puedes encontrar el código de este proyecto en su repositorio GitHub.
A continuación, verifique que esté ejecutando la versión 3.6+ de Python. Si no, instale la última Pitón versión.
python --versiónLuego, instale Virtualenv para crear un entorno de desarrollo virtual aislado. Esto es muy recomendable porque le permite evitar conflictos, especialmente si está utilizando diferentes versiones de paquetes para diferentes proyectos.
pip instalar virtualenvA continuación, cree un entorno virtual llamado "venv" dentro de su directorio actual:
entorno virtual venvFinalmente, active el entorno virtual.
# En Unix o MacOS:
fuente venv/bin/activar
# En Windows:
.\venv\Scripts\activar
Una vez que haya configurado el entorno virtual, instale los paquetes FastAPI, PyMongo y Uvicorn.
pip instalar fastapi pymongo uvicornioPyMongo es una biblioteca basada en Python para trabajar con la base de datos MongoDB. Proporciona una API que admite todas las características de MongoDB y le permite interactuar con MongoDB sin tener que escribir consultas de MongoDB sin procesar.
Uvicorn, por otro lado, es un servidor web asíncrono basado en el módulo asyncio de Python. Su característica principal es la recarga en caliente de sus servidores FastAPI sobre la marcha. Usar Uvicorn, es similar a trabajando con nodemon.
Crear el servidor FastAPI
Finalmente, cree un servidor FastAPI simple que escuche las solicitudes provenientes de la ruta principal. En el directorio raíz de la carpeta de su proyecto, cree un archivo server.py y agregue el código a continuación.
de fastapi importar API rápida
aplicación = FastAPI()
@aplicación.get("/")
asíncronodefinitivamentehogar():
devolver {"mensaje": "Hola Mundo"}
Por último, ejecute el siguiente comando para activar el servidor de desarrollo. Uvicorn atenderá su aplicación en el puerto 8000.
servidor uvicon: aplicación --recargarContinúe y vea la respuesta del servidor en su navegador en http://localhost: 8000.
Crear la API REST con operaciones CRUD
Ahora cree la API REST que implementa los métodos CRUD (crear, leer, actualizar y eliminar). En el directorio raíz de la carpeta de su proyecto, cree cuatro carpetas: configuración, modelos, rutas y esquemas.
├── configuración
├── modelos
├── rutas
├── esquemas
└── servidor.py1. Configurar la conexión de la base de datos
En el directorio de configuración, cree un nuevo archivo, db.py, y agregue el código a continuación.
de pymongo importar MongoCliente
conexión_bd = MongoClient("mongodb://host local: 27017")
db = conexión_bd.nombre_base_datos
colección = db["nombre_colección"]- Utilice el método MongoClient() para crear una conexión a una base de datos MongoDB. Toma una cadena URI de conexión como argumento que especifica el host y el puerto del servidor MongoDB.
- Las dos variables especifican a qué base de datos y colección en su servidor MongoDB debe acceder el servidor.
2. Definir un modelo de datos
Este modelo definirá la estructura de sus datos en la base de datos, incluidos los campos y tipos de datos.
En el directorio del modelo, cree un nuevo archivo, user_model.py, y agregue el código a continuación.
de pydantico importar Modelo base
claseUsuario(Modelo base):
nombre: calle
rol: calle
- El código anterior crea una clase llamada Usuario, que es una subclase de la clase BaseModel de la biblioteca Pydantic. La clase Usuario tiene dos campos, nombre y función con sus tipos de datos establecidos en cadenas.
- Puede usar la biblioteca Pydantic con FastAPI para crear modelos de datos. También puede usarlo para validar datos, serializarlos (JSON a Python) y deserializarlos (Python a JSON).
3. Definir un esquema de datos
Desde el modelo de datos creado, puede definir el esquema para sus datos. En el directorio de esquemas, cree un nuevo archivo: user_schema.py y agregue el código a continuación.
definitivamenteserializador_usuario(usuario) -> dictado:
devolver {
'identificación':str (usuario["_identificación"]),
'nombre':usuario["nombre"],
'role':usuario["role"]
}
definitivamenteusuarios_serializador(usuarios) -> lista:
devolver [user_serializer (usuario) para usuario en usuarios]
4. Definir las rutas API
Finalmente, defina las rutas para las diferentes operaciones CRUD.
En el directorio de rutas, cree un nuevo archivo: user_routes.py y agregue el código a continuación.
Agregar datos con el método de publicación
Cree la ruta de publicación para agregar datos.
de fastapi importar Enrutador API
de modelos.user_model importar Usuario
de esquemas.user_schema importar usuarios_serializador
de bson importar ID de objeto
de config.db importar recopilaciónusuario = APIRouter()
@usuario.post("/")
asíncronodefinitivamentecrear usuario(usuario: Usuario):
_id = colección.insertar_uno (dict (usuario))
usuario = usuarios_serializador (colección.find({"_identificación": _id.inserted_id}))
devolver {"estado": "De acuerdo","datos": usuario}
- FastAPI proporciona el método APIRouter() que define un objeto de enrutador que proporciona una interfaz para realizar solicitudes de API a un servidor.
- Especifique una ruta posterior que cree un nuevo objeto de usuario en la base de datos insertando los datos en la colección después de serializarlos. A continuación, almacene y pase inserted_id para encontrar los datos asociados en la colección y, finalmente, devuelva un estado de "Ok" con los datos en la respuesta, si la solicitud de publicación es exitosa.
- Los métodos insert_one y find están definidos por el cliente PyMongo.
Ahora, agregue el siguiente código a server.py para inicializar las rutas.
de rutas.rutas_usuario importar usuario
app.include_router (usuario)Continúe y pruebe la ruta de publicación en su navegador utilizando la herramienta Swagger UI API proporcionada por FastAPI.
Leer datos con el método Get
Después de definir la ruta posterior e inicializar las rutas, defina el resto de las otras rutas.
@usuario.get("/")
asíncronodefinitivamenteencontrar_todos_los_usuarios():
usuarios = usuarios_serializador (colección.buscar())
devolver {"estado": "De acuerdo","datos": usuarios}
@usuario.get("/{id}")
asíncronodefinitivamenteobtener_un_usuario(id: cadena):
usuario = usuarios_serializador (colección.find({"_identificación": ID de objeto (id)}))
devolver {"estado": "De acuerdo","datos": usuario}Defina dos rutas de obtención que recuperen todos los datos de la colección y recuperen datos específicos de la colección en función del ID.
Actualizar datos con el método Put
Cree la ruta put para actualizar los datos almacenados en la base de datos.
@usuario.put("/{id}")
asíncronodefinitivamenteactualizar_usuario(id: str, usuario: Usuario):
colección.encontrar_uno_y_actualizar(
{
"_identificación": ID de objeto (id)
},
{
"$establecer": dict (usuario)
})
usuario = usuarios_serializador (colección.find({"_identificación": ID de objeto (id)}))
devolver {"estado": "De acuerdo","datos": usuario}El método put usa el ID para encontrar los datos específicos en la colección y actualiza el valor de los campos en el documento con los nuevos datos pasados desde la API. A continuación, puede buscar los datos actualizados por ID y devolverlos en la respuesta de la API.
Eliminar datos con el método de eliminación
Cree la ruta de eliminación para eliminar los datos almacenados en la base de datos.
@usuario.delete("/{id}")
asíncronodefinitivamenteborrar usuario(id: cadena):
colección.encontrar_uno_y_eliminar({"_identificación": ID de objeto (id)})
usuarios = usuarios_serializador (colección.buscar())
devolver {"estado": "De acuerdo","datos": []} La ruta de eliminación toma el ID del documento específico que desea eliminar de la colección.
Cree API REST con FastAPI
FastAPI proporciona una excelente manera de construir convenientemente las API web de Python de back-end. Sus herramientas integradas para la integración de bases de datos y la producción automática de API hacen que el proceso sea simple.
Incluso puede llevar esto un paso más allá y crear aplicaciones completas. Intente integrar un cliente front-end utilizando tecnologías populares como React, Angular o Vue.
