Crea una Aplicación con FastAPI para Python

FastAPI es un web framework rápido y ligero para construir modernas interfaces de programación de aplicaciones utilizando Python 3.6 y  versiones superiores. En este tutorial, repasaremos los fundamentos de la construcción de una aplicación con FastAPI, y podrás hacerte una idea de por qué ha sido nominado como uno de los mejores frameworks de código abierto de 2021.

Una vez que estés preparado para desarrollar tus propias aplicaciones FastAPI, no tendrás que buscar mucho para encontrar un lugar donde alojarlas. Los servicios de Alojamiento de Aplicaciones y Alojamiento de Bases de Datos de Kinsta proporcionan una Plataforma como Servicio que es fuerte en Python.

Primero aprendamos lo básico.

Ventajas de FastAPI

A continuación se exponen algunas de las ventajas que el framework FastAPI FastAPI aporta a un proyecto.

• La velocidad: Como su nombre indica, FastAPI es un framework muy rápido. Su velocidad es comparable a la de Go y Node.js, que generalmente se consideran entre las opciones más rápidas para construir APIs.
• Fácil de aprender y codificar: FastAPI ya ha resuelto casi todo lo que necesitarás para crear una API lista para la producción. Como desarrollador que utiliza FastAPI, no necesitas codificar todo desde cero. Con sólo unas pocas líneas de código, puedes tener una API RESTful lista para su despliegue.
• Documentación exhaustiva: FastAPI utiliza los estándares de documentación de OpenAPI, por lo que la documentación puede generarse dinámicamente. Esta documentación proporciona información detallada sobre los puntos finales, las respuestas, los parámetros y los códigos de retorno de FastAPI.
• API con menos errores: FastAPI admite la validación de datos personalizada, lo que permite a los desarrolladores construir APIs con menos errores. Los desarrolladores de FastAPI se jactan de que el marco de trabajo da lugar a menos errores inducidos por el ser humano, hasta un 40% menos.
• Type hints: El módulo de tipos se introdujo en Python 3.5. Esto te permite declarar el type de una variable. Cuando se declara el tipo de una variable, los IDE son capaces de proporcionar un mejor soporte y predecir los errores con mayor precisión.

Cómo Empezar con FastAPI

Para seguir este tutorial y empezar a utilizar FastAPI, tendrás que hacer primero algunas cosas.

Asegúrate de que tienes un editor de texto/IDE de programador, como Visual Studio Code. Otras opciones son Sublime Text y Espresso.

Es una práctica habitual tener tus aplicaciones de Python y sus instancias funcionando en entornos virtuales. Los entornos virtuales permiten que se ejecuten simultáneamente diferentes conjuntos de paquetes y configuraciones, y evitan conflictos debidos a versiones de paquetes incompatibles.

Para crear un entorno virtual, abre tu terminal y ejecuta este comando

$ python3 -m venv env

También tendrás que activar el entorno virtual. El comando para hacerlo variará en función del sistema operativo y del shell que estés utilizando. Aquí tienes algunos ejemplos de activación CLI para varios entornos:

# On Unix or MacOS (bash shell): 
/path/to/venv/bin/activate

# On Unix or MacOS (csh shell):
/path/to/venv/bin/activate.csh

# On Unix or MacOS (fish shell):
/path/to/venv/bin/activate.fish

# On Windows (command prompt):
pathtovenvScriptsactivate.bat

# On Windows (PowerShell):
pathtovenvScriptsActivate.ps1


(Algunos IDEs compatibles con Python también pueden configurarse para activar el entorno virtual actual.)

Ahora, instala FastAPI:

$ pip3 install fastapi

FastAPI es un marco para construir APIs, pero para probar tus APIs necesitarás un servidor web local. Uvicorn es un servidor web de interfaz de puerta de enlace de servidor asíncrono (ASGI) para Python, muy rápido, que es ideal para el desarrollo. Para instalar Uvicorn, ejecuta este comando:

$ pip3 install "uvicorn[standard]"

Tras la instalación, crea un archivo llamado main.py en el directorio de trabajo de tu proyecto. Este archivo será el punto de entrada de tu aplicación.

Un Ejemplo Rápido de FastAPI

Para probar tu instalación de FastAPI, configura rápidamente un endpoint de ejemplo. En tu archivo main.py, pega el siguiente código y guarda el archivo:

# main.py
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
async def root():
 return {"greeting":"Hello world"}


El fragmento anterior crea un endpoint FastAPI básico. A continuación te mostramos un resumen de lo que hace cada línea:

• from fastapi import FastAPI: La funcionalidad de tu API la proporciona la clase FastAPI de Python.
• app = FastAPI(): Esto crea una instancia de FastAPI.
• @app.get("/"): Se trata de un decorador python que especifica a FastAPI que la función que hay debajo es la encargada de gestionar las peticiones.
• @app.get("/"): Este es un decorador que especifica la ruta. Esto crea un método GET en la ruta del sitio. El resultado es devuelto por la función envuelta.
• Otras posibles operaciones que se utilizan para comunicarse son @app.post(), @app.put(), @app.delete(), @app.options(), @app.head(), @app.patch() y @app.trace().

En el directorio de archivos, ejecuta el siguiente comando en tu terminal para iniciar el servidor API:

$ uvicorn main:app --reload

En este comando, main es el nombre de tu módulo. El objeto app es una instancia de tu aplicación, y se importa en el servidor ASGI. La bandera --reload indica al servidor que se recargue automáticamente cuando hagas algún cambio.

Deberías ver algo así en tu terminal:

 $ uvicorn main:app --reload
INFO: Will watch for changes in these directories: ['D:\WEB DEV\Eunit\Tests\fast-api']
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO: Started reloader process [26888] using WatchFiles
INFO: Started server process [14956]
INFO: Waiting for application startup.
INFO: Application startup complete.


En tu navegador, navega hasta http://localhost:8000 para confirmar que tu API está funcionando. Deberías ver «Hello»: «World» como objeto JSON en la página. Esto ilustra lo fácil que es crear una API con FastAPI. Lo único que has tenido que hacer es definir una ruta y devolver tu diccionario Python, como se ve en la línea seis del fragmento anterior.

Utiliza Type Hints

Si utilizas Python, estás acostumbrado a anotar variables con tipos de datos básicos como int, str, float y bool. Sin embargo, a partir de la versión 3.9 de Python, se introdujeron estructuras de datos avanzadas. Esto te permite trabajar con estructuras de datos como dictionaries, tuples, y lists. Con los type hints de FastAPI, puedes estructurar el esquema de tus datos utilizando modelos pydánticos y luego, utilizar los modelos pydánticos para hacer sugerencias de tipo y beneficiarte de la validación de datos que se proporciona.

En el siguiente ejemplo, se demuestra el uso de type hints en Python con una sencilla calculadora de precios de comidas, calculate_meal_fee:

def calculate_meal_fee(beef_price: int, meal_price: int) -> int:
 total_price: int = beef_price + meal_price
 return total_price
print("Calculated meal fee", calculate_meal_fee(75, 19))


Ten en cuenta que los type hints no cambian la forma en que se ejecuta tu código.

Documentación Interactiva de la API de FastAPI

FastAPI utiliza Swagger UI para proporcionar documentación interactiva automática de la API. Para acceder a ella, navega a http://localhost:8000/docs y verás una pantalla con todos tus endpoints, métodos y esquemas.

Esta documentación automática de la API basada en el navegador la proporciona FastAPI, y no necesitas hacer nada más para aprovecharla.

Una documentación alternativa de la API basada en el navegador, también proporcionada por FastAPI, es Redoc. Para acceder a Redoc, navega a http://localhost:8000/redoc, donde se te presentará una lista de tus puntos finales, los métodos y sus respectivas respuestas.

Configurar Rutas en FastAPI

El decorador @app te permite especificar el método de la ruta, como @app.get o @app.post, y admite GET, POST, PUT y DELETE, así como las opciones menos comunes, HEAD, PATCH
Source link