Si te estás adentrando en el mundo del desarrollo web moderno, es probable que hayas oído hablar de FastAPI. Es uno de los frameworks de más rápido crecimiento para construir APIs en Python. En esta entrada de blog, vamos a explorar cómo usar FastAPI para crear y manejar peticiones POST. Tanto si eres un desarrollador experimentado como si estás empezando, esta guía te ayudará a comprender los conceptos básicos y más allá.
¿Qué es FastAPI?
FastAPI es un framework web moderno, rápido (de alto rendimiento) para construir APIs con Python 3.7+ basado en indicaciones de tipo estándar de Python. Está diseñado para ser fácil de usar y para proporcionar un alto rendimiento a la par con Node.js y Go. El framework también es muy intuitivo y directo, lo que lo convierte en una excelente opción tanto para principiantes como para expertos.
¿Por qué usar FastAPI?
Hay varias razones por las que los desarrolladores están eligiendo FastAPI sobre otros frameworks:
- Velocidad: FastAPI es rápido. De hecho, es uno de los frameworks web más rápidos disponibles en la actualidad.
- Facilidad de uso: Con la documentación interactiva automática (gracias a Swagger UI y ReDoc), es increíblemente fácil probar tus APIs.
- Validación de datos: FastAPI aprovecha Pydantic para la validación de datos, lo que garantiza que los datos que recibe tu API sean válidos.
- Listo para Async: Soporta la programación asíncrona de fábrica, lo que lo hace adecuado para aplicaciones web modernas de alto rendimiento.
Configurando FastAPI
Antes de sumergirnos en las peticiones POST, vamos a configurar rápidamente FastAPI. Necesitarás Python instalado en tu sistema. Luego, puedes instalar FastAPI y un servidor ASGI, como Uvicorn, usando pip:
pip install fastapi uvicorn
Una vez que tengas FastAPI instalado, puedes crear una aplicación FastAPI simple. Empecemos creando un archivo llamado main.py:
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"Hello": "World"}
Para ejecutar la aplicación, usa Uvicorn:
uvicorn main:app --reload
Abre tu navegador y navega a http://127.0.0.1:8000. Deberías ver una respuesta JSON: {"Hello": "World"}.
Creando un Endpoint POST
Ahora que tenemos una aplicación FastAPI básica en ejecución, vamos a añadir un endpoint POST. Las peticiones POST se utilizan para enviar datos para ser procesados a un recurso especificado. Para manejar una petición POST en FastAPI, se utiliza el decorador @app.post.
Aquí tienes un ejemplo sencillo de cómo manejar una petición POST:
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
class Item(BaseModel):
name: str
description: str = None
price: float
tax: float = None
@app.post("/items/")
def create_item(item: Item):
return item
En este ejemplo:
- Definimos una instancia de
FastAPI. - Creamos un modelo Pydantic
Itemque describe la estructura de datos del cuerpo de la petición. - Usamos el decorador
@app.postpara definir un endpoint POST/items/. - La función
create_itemtoma un objetoItemcomo entrada y lo devuelve.
Para probar esto, puedes usar un cliente API como apidog o simplemente usar la interfaz de usuario interactiva de Swagger proporcionada por FastAPI en http://127.0.0.1:8000/docs.
Manejo de datos y validaciones
FastAPI valida automáticamente los datos de la petición con el modelo Pydantic. Si los datos no se ajustan al modelo, FastAPI devuelve un código de estado 422 con detalles sobre los errores de validación.
Por ejemplo, si envías una petición POST a /items/ con el siguiente cuerpo JSON:
{
"name": "Item name",
"price": 25.5
}
FastAPI aceptará esta petición porque cumple con los requisitos del modelo Item. Sin embargo, si omites el campo price, FastAPI rechazará la petición y devolverá un error.
Usando Apidog para probar tu petición POST de FastAPI
Apidog es una herramienta poderosa para probar APIs. Te permite crear y guardar peticiones API, organizarlas en colecciones y compartirlas con tu equipo.
Aquí te mostramos cómo puedes usar Apidog para probar tu petición POST:
- Abre Apidog y crea una nueva petición.
2. Establece el método de petición a POST.
3. Introduce la URL del recurso que quieres actualizar. Añade cualquier encabezado o parámetro adicional que quieras incluir y luego haz clic en el botón "Enviar" para enviar la petición.
4. Verifica que la respuesta sea la que esperabas.
Peticiones POST avanzadas
Ahora, vamos a explorar algunos escenarios más avanzados. FastAPI te permite hacer mucho más con las peticiones POST. Por ejemplo, puedes:
- Manejar subidas de archivos: Usa
FileyUploadFiledefastapi. - Procesar datos de formulario: Usa
Formdefastapi. - Usar parámetros de ruta: Combina
parámetros de rutacon peticiones POST.
Manejo de subidas de archivos
Aquí tienes un ejemplo de cómo manejar subidas de archivos con FastAPI:
from fastapi import FastAPI, File, UploadFile
app = FastAPI()
@app.post("/uploadfile/")
async def create_upload_file(file: UploadFile):
return {"filename": file.filename}
Este endpoint aceptará un archivo y devolverá el nombre del archivo. Puedes probar esto con apidog o Swagger UI.
Procesando datos de formulario
Para procesar datos de formulario, usa la clase Form de FastAPI:
from fastapi import FastAPI, Form
app = FastAPI()
@app.post("/login/")
def login(username: str = Form(...), password: str = Form(...)):
return {"username": username}
Este ejemplo crea un endpoint de inicio de sesión que acepta datos de formulario. Puedes probar esto usando un envío de formulario en tu navegador o una herramienta de prueba de API.
Usando parámetros de ruta
También puedes combinar parámetros de ruta con peticiones POST:
from fastapi import FastAPI
app = FastAPI()
@app.post("/users/{user_id}/items/")
def create_item_for_user(user_id: int, item: Item):
return {"user_id": user_id, "item": item}
Este endpoint crea un elemento para un usuario específico, identificado por el parámetro de ruta user_id.
Conclusión
FastAPI es un framework poderoso que facilita la construcción de APIs robustas con Python. Su soporte para la validación de datos, la documentación interactiva y el alto rendimiento lo convierten en una excelente opción para el desarrollo web moderno.
En esta entrada de blog, hemos cubierto cómo configurar una aplicación FastAPI y manejar peticiones POST. También hemos explorado temas más avanzados como la subida de archivos, el procesamiento de datos de formulario y la combinación de parámetros de ruta con peticiones POST. A estas alturas, deberías tener una sólida comprensión de cómo usar FastAPI para crear y manejar peticiones POST.
Recuerda, tanto si estás construyendo una API simple como una aplicación compleja, FastAPI tiene las herramientas que necesitas para tener éxito. ¡Feliz codificación!
