martes 16 julio 2024

Cómo crear un proyecto FastAPI con Python

Instalación
Primeros Pasos
Ejecutar la Aplicación
Manejo de Parámetros
Documentación Automática
Ejemplo Completo
Despliegue
Conclusión

Instalación

Primero, necesitas instalar FastAPI y un servidor ASGI como uvicorn:

pip install fastapi uvicorn

Primeros Pasos

Vamos a crear una aplicación simple con FastAPI. Comienza creando un archivo llamado main.py y añade el siguiente código:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"Hello": "World"}

@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

En este código:

FastAPI() crea una nueva instancia de la aplicación.
@app.get("/") define una ruta GET para el endpoint raíz (/).
@app.get("/items/{item_id}") define una ruta GET para el endpoint /items/{item_id}, donde item_id es un parámetro de ruta.

Ejecutar la Aplicación

Para ejecutar la aplicación, utiliza el servidor uvicorn:

uvicorn main:app --reload

Este comando indica a uvicorn que utilice el objeto app definido en el archivo main.py. La opción --reload hace que el servidor se reinicie automáticamente cuando detecta cambios en el código.

Manejo de Parámetros

FastAPI permite manejar parámetros de manera sencilla. Los parámetros pueden ser de ruta, consulta o cuerpo.

Parámetros de Ruta

Ya hemos visto un ejemplo de parámetro de ruta:

@app.get("/items/{item_id}")
def read_item(item_id: int):
    return {"item_id": item_id}

Parámetros de Consulta

Para agregar parámetros de consulta, simplemente añádelos como argumentos de la función:

@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

En este ejemplo, q es un parámetro de consulta opcional.

Parámetros del Cuerpo

Para recibir datos en el cuerpo de una solicitud, usa los modelos de Pydantic:

from pydantic import BaseModel

class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None

@app.post("/items/")
def create_item(item: Item):
    return item

Aquí, Item es un modelo de Pydantic que define la estructura esperada del JSON en el cuerpo de la solicitud.

Documentación Automática

Una de las características más destacadas de FastAPI es la generación automática de documentación interactiva. Una vez que ejecutas tu aplicación, puedes acceder a la documentación en las siguientes URLs:

Documentación Swagger: http://127.0.0.1:8000/docs
Documentación ReDoc: http://127.0.0.1:8000/redoc

Ejemplo Completo

Aquí tienes un ejemplo completo que combina los conceptos anteriores:

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None

@app.get("/")
def read_root():
    return {"Hello": "World"}

@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

@app.post("/items/")
def create_item(item: Item):
    return item

Despliegue

Para desplegar tu aplicación FastAPI en producción, puedes utilizar diversos servicios como Docker, Heroku, o servicios de nube como AWS y GCP. Aquí hay un ejemplo básico de un Dockerfile para tu aplicación:

FROM tiangolo/uvicorn-gunicorn-fastapi:python3.8

COPY ./app /app

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "80"]

Conclusión

FastAPI es un framework potente y eficiente para construir APIs en Python. Con su facilidad de uso, rendimiento y características avanzadas como la documentación automática, es una excelente opción para desarrolladores que buscan construir aplicaciones web modernas y rápidas.

Etiquetas:

python fastapi desarrollo web

Creado por:

Jorge García

Fullstack developer