Tutorial de FastAPI: Introducción al uso de FastAPI

Las API (interfaces de programación de aplicaciones) son la columna vertebral de la arquitectura moderna porque permiten modular y desacoplar las aplicaciones. Esto significa que puede crear aplicaciones de forma rápida y sencilla, lo que le permite mantenerlas y actualizarlas fácilmente. 

Las API también son muy importantes en el aprendizaje automático porque permiten que distintas aplicaciones compartan datos y trabajen juntas, ahorrando tiempo y esfuerzo. Hay muchos frameworks diferentes para construir APIs en Python. Algunos de los frameworks más populares para crear APIs en Python son Django, Flask y FastAPI. Este tutorial es una inmersión profunda en uno de los frameworks llamado FastAPI.

¿Qué es una API?

API significa Interfaz de Programación de Aplicaciones. Una API es un intermediario de software que permite a dos aplicaciones comunicarse entre sí. Cuando utilizas una aplicación en tu teléfono, la aplicación se conecta a Internet y envía datos a un servidor. A continuación, el servidor procesa los datos y los envía de vuelta al teléfono. A continuación, la aplicación de tu teléfono interpreta los datos y te los presenta de forma legible. 

Una API es como un camarero en un restaurante. El camarero toma tu pedido y lo envía a la cocina. A continuación, la cocina prepara la comida y se la devuelve al camarero. A continuación, el camarero te trae la comida. 

Del mismo modo, una API recibe una solicitud de una aplicación y la envía a un servidor. A continuación, el servidor procesa la solicitud y devuelve los datos a la aplicación. A continuación, la aplicación interpreta los datos y los presenta al usuario.

Image Source: https://www.techfunnel.com/wp-content/uploads/2021/07/api.png

Si quieres aprender más sobre pipelines de machine learning, APIs y MLOps, puedes consultar nuestro Tutorial de Machine Learning, Pipelines, Deployment y MLOps.

Qué es FastAPI

FastAPI es un framework web de alto rendimiento para construir APIs con Python 3.7+ basado en sugerencias de tipos estándar de Python. Ayuda a los desarrolladores a crear aplicaciones de forma rápida y eficaz. FastAPI se basa en el servidor web Starlette e incluye funciones que facilitan la creación de aplicaciones web, como la validación automática de datos, la gestión de errores y la documentación interactiva de la API. 

En esta sección analizaremos todas estas características por separado. En primer lugar, veamos las características clave señaladas en la documentación original de FastAPI.

• Rendimiento: A la par con NodeJS y el lenguaje Go.
• Velocidad: Aumente la velocidad de revelado 2-3X.
• Fácil: Gran soporte de edición. Terminación en todas partes. Fácil de aprender y utilizar.
• Robusto: Código listo para producción con documentación interactiva automática.
• Basado en OpenAPI: Totalmente compatible con OpenAPI y JSON Schema.

Installing FastAPI

FastAPI requiere Python 3.7+. Puede instalarse mediante pip. Necesitarás instalar FastAPI y el servidor ASGI `uvicorn`.

``

# install fastapi

pip install fastapi




# install uvicorn
pip install uvicorn

``

Crear una API sencilla

Entremos directamente en la creación de una API de juguete muy sencilla. Estoy usando VS Code para implementar esto, pero puedes usar el editor que quieras.

```

from typing import Union

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: Union[str, None] = None):

    return {"item_id": item_id, "q": q}

```

(Ejemplo reproducido de la documentación original). Gracias a @tiangolo.

Ahora, utilizando un terminal de línea de comandos, ejecute esta API con el siguiente comando:

```

uvicorn main:app –reload

```

`main` es el nombre del archivo Python, y `app` es la variable que almacena la clase FastAPI. Puedes ponerles el nombre que quieras. Una vez que ejecute el comando anterior, verá algo como esto en su terminal:

Vaya al enlace en su navegador, y si ve una página que muestra "Hola Mundo", la API está funcionando.

Imagen del autor

Enhorabuena por crear su primera API. 

Documentación interactiva sobre la API

FastAPI genera un "esquema" con todas sus APIs utilizando el estándar OpenAPI para la definición de APIs. Un "esquema" es una definición o descripción de algo. No el código que lo implementa, sino una descripción abstracta. El esquema OpenAPI es el que alimenta los dos sistemas de documentación interactiva incluidos en FastAPI.

Para ver la documentación, basta con añadir `/docs` a la url (`http://127.0.0.1:8000/docs`). Este enlace mostrará la documentación interactiva automática de la API.

Imagen del autor

Haga clic en el botón "Probar" de la esquina superior derecha para probar la API.

Imagen del autor

Puedes ver que el cuerpo de la respuesta es un diccionario. Esta es la llamada de retorno de la función `read_item` definida en `main.py`. También puede ver la url de solicitud `http://127.0.0.1:8000/items/1?q=orange`. `1` y `naranja` fueron nuestras entradas a la API.

Existe una documentación automática interactiva alternativa disponible en FastAPI. Para comprobarlo, visite http://127.0.0.1:8000/redoc`. Esto es lo que parece:

Imagen del autor

Ejemplos más avanzados

Al construir una API, la "ruta" define la ruta o el punto final de la solicitud. Sin embargo, aquí tenemos que hacer una elección más: "Operación". La palabra `operación` se refiere aquí a uno de los "métodos" HTTP. Utilizando uno (o varios) de estos llamados "métodos", puede comunicarse con cada una de las diversas vías que admite el protocolo HTTP. Lo normal sería utilizar:

• POST: para crear datos.
• GET: para leer datos.
• PUT: para actualizar datos.
• BORRAR: para borrar datos.
• Y algunas otras avanzadas 

FastAPI admite todos los métodos http. 

El hecho de que FastAPI se base en sugerencias de tipo de Python es otro aspecto clave de este marco. Las sugerencias de tipo están soportadas en las versiones de Python 3.6 y posteriores. Las sugerencias de tipo son un tipo especializado de sintaxis que permite declarar el tipo de una variable. 

Declarar tipos para sus variables permite a los editores y otras herramientas ofrecerle una mejor asistencia. Veamos un ejemplo avanzado.

Modificaremos nuestro fichero `main.py` para incluir una nueva petición `PUT` que tomará múltiples entradas de diferentes tipos de datos. 

```

from typing import Union




from fastapi import FastAPI

from pydantic import BaseModel




app = FastAPI()




class Item(BaseModel):

    name: str

    price: float

    is_offer: Union[bool, None] = None




@app.get("")

def read_root():

    return {"Hello": "World"}




@app.get("/items/{item_id}")

def read_item(item_id: int, q: Union[str, None] = None):

    return {"item_id": item_id, "q": q}




@app.put("/items/{item_id}")

def update_item(item_id: int, item: Item):

    return {"item_name": item.name, "item_id": item_id}

```

(Ejemplo reproducido de la documentación original). Gracias a @tiangolo.

El cambio:

Se añade una petición `put` que toma dos entradas. El `item_id` es un entero y el tipo `item` apunta a la clase personalizada `Item` creada y que hereda el `BaseModel` de `pydantic`. La clase `Item` contiene tres atributos: `name`, `price`, `is_offer`, y todos ellos tienen diferentes tipos de datos.

FastAPI lo comprobará: 

• `nombre` es un `str`.
• El `precio` es un `float`.
• `is_offer` es un bool, si está presente.

La ventaja de usar sugerencias de tipo es que declaras una vez los tipos de parámetros, cuerpo, etc. como parámetros de función con Python estándar (3.6+). Usted recibirá:

• Compatibilidad con el editor, incluido el autocompletado y la comprobación tipográfica
• Validación de datos
• Conversión de los datos de entrada
• Conversión de los datos de salida
• Errores fáciles de entender.

Comparación de FastAPI con Django y Flask

Los tres son frameworks web de Python que puedes utilizar para desarrollar aplicaciones web. Cada uno tiene sus puntos fuertes y débiles.

Django es un framework completo que incluye todo lo necesario para empezar, incluyendo un ORM integrado y un panel de administración. Puede resultar un poco abrumador para los principiantes, pero su completa documentación facilita el aprendizaje.

Flask es un microframework ligero y fácil de usar. No incluye tantas características como Django, pero es perfecto para proyectos sencillos.

FastAPI es un nuevo marco diseñado para ser rápido y fácil de usar. Incluye funciones como la validación automática de datos y la documentación. 

Pruebas de rendimiento de FastAPI

Según los resultados de las pruebas realizadas por techempower, FastAPI es superior a todos los demás marcos en términos de rendimiento general. 

Fuente: https://www.techempower.com/benchmarks/

Por ejemplo: Creación de un canal de aprendizaje automático integral con PyCaret e implementación con FastAPI 

En esta sección, vamos a construir rápidamente una tubería de aprendizaje automático y luego crear una API para servir el modelo. Utilizaremos una biblioteca de Python de código bajo , PyCaret, para construir una canalización y crear una API. PyCaret tiene integración con FastAPI, lo que hace extremadamente fácil crear y servir modelos de aprendizaje automático como API.

PyCaret

PyCaret es una biblioteca de aprendizaje automático de código abierto y bajo nivel de código en Python que automatiza los flujos de trabajo de aprendizaje automático. Es una herramienta integral de aprendizaje automático y gestión de modelos que acelera exponencialmente el ciclo de experimentación y le hace más productivo.

```

pip install pycaret

```




```

import pycaret

pycaret.__version__

>>> 2.3.10

```

En este ejemplo utilizaremos el conjunto de datos `insurance`. Se trata de un caso de uso de regresión para predecir los gastos médicos en función de la edad, el sexo, el IMC y la región. 

```

from pycaret.datasets import get_data

data = get_data(‘insurance’)

```

Imagen del autor

A continuación inicializaremos la función `setup` de pycaret. Esta función inicializa el experimento en PyCaret y crea la tubería de transformación basada en todos los parámetros pasados en la función. 

El `setup` debe ejecutarse primero antes que cualquier otra función. Requiere dos parámetros para funcionar `data` y `target`. El resto de argumentos de `setup` son opcionales. La función `setup` se encarga de controlar la totalidad de los procedimientos de preprocesamiento de datos. Consulte la documentación de Py Caret para obtener un resumen completo de todos los procedimientos de preprocesamiento compatibles con PyCaret.

```

from pycaret.regression import *

s = setup(data, target = 'charges')

```

Imagen del autor Salida truncada.

Una vez finalizada la configuración, podemos iniciar el entrenamiento y la selección de modelos con una sola línea de código: `compare_models`. Mediante el uso de la validación cruzada, esta función entrena y evalúa el rendimiento del modelo de todos los estimadores de la biblioteca de modelos. El resultado de esta función es una tabla de puntuación que contiene las puntuaciones medias obtenidas de la validación cruzada.