Saltar al contenido principal
InicioTutorialesPython

Tutorial de FastAPI: Introducción al uso de FastAPI

Explore el marco FastAPI y descubra cómo puede utilizarlo para crear API en Python.
may 2024  · 13 min leer

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.

Un diseño sencillo de la arquitectura de la API

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:

Terminal de mando

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

API ejecutándose en localhost en el navegador

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.

Documentación automatizada creada por FastAPI

Imagen del autor

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

Documentación automatizada creada por FastAPI 2

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:

Documentación automatizada creada por FastAPI 3

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. 

 

Django

Frasco

FastAPI

Comunidad

Big. 

66K estrellas GitHub

Big. 

61K estrellas GitHub

Big. 

50.000 estrellas GitHub

Rendimiento

Django es enorme. No es el mejor en términos de rendimiento.

Flask es un micro framework web. Funciona mejor que Django.

FastAPI es uno de los frameworks web más rápidos con soporte nativo async que se suma a la eficiencia del framework. 

Soporte asíncrono

Sí, con latencia limitada.

No. 

Necesidades Asyncio

FastAPI proporciona soporte asíncrono nativo.

Facilidad de uso

Django es masivo y por lo tanto un poco complicado de aprender.

Flask es fácil de aprender y su uso es bastante sencillo.

FastAPI es la más sencilla de las tres.

Documentación interactiva

No interactivo

No

Sí (OpenAI, Redoc)

Verificación de datos

No

No


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. 

API Parámetros de rendimiento

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’)

```

Conjunto de datos de muestra

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')

```

Salida de la función de configuración de PyCaret

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.

Preprocesamiento para el aprendizaje automático en Python

¿Le interesa saber más sobre cómo preparar sus datos depurados para la modelización? Realice nuestro curso Preprocessing for Machine Learning in Python.

Empezar Ahora
```

best = compare_models()

```

Salida de la función compare_models de PyCaret

Imagen del autor

En base a esto, el modelo con mejores resultados es `Gradient Boosting Regressor`. Si lo deseamos, podemos analizar el modelo a través de la visualización e intentar mejorar el rendimiento mediante el ajuste de hiperparámetros o el ensamblaje de modelos, pero no lo haremos en este tutorial. 

Nos meteremos de lleno en la construcción de la API del mejor modelo para servir predicciones en producción utilizando FastAPI. Recuerda que PyCaret tiene integración con FastAPI, por lo que puede crear automáticamente una API REST a partir del modelo utilizando la función `create_api`.

```

create_api (best, 'insurance_prediction_model')

```

API creada con éxito

Ahora, para ejecutar esta API, abra el terminal de comandos y navegue hasta la carpeta donde se encuentra su Notebook y ejecute el siguiente comando `python insurance_prediction_model.py`. 

Línea de comandos

Dirígete a `http://127.0.0.1:8000/docs` y verás la misma interfaz de usuario que has visto anteriormente en este tutorial

API en http:::127.0.0.1:8000:docs

Imagen del autor

API en http:::127.0.0.18000:docs

Imagen del autor

También puede consultar documentación interactiva alternativa en `http://127.0.0.1:8000/redoc'.

API on http:::127.0.0.1:8000:docs3

Imagen del autor

Recuerde que tanto la documentación interactiva por defecto como la de redoc funcionan con los estándares OpenAPI. 

Si quieres ver el archivo que PyCaret creó cuando usaste la función `create_api` puedes ver el archivo en la misma carpeta que tu Notebook. Se parece a esto:

```

import pandas as pd

from pycaret.regression import load_model, predict_model

from fastapi import FastAPI

import uvicorn




# Create the app

app = FastAPI()




# Load trained Pipeline

model = load_model('my_lr_api')




# Define predict function

@app.post('/predict')

def predict(age, sex, bmi, children, smoker, region):

    data = pd.DataFrame([[age, sex, bmi, children, smoker, region]])

    data.columns = ['age', 'sex', 'bmi', 'children', 'smoker', 'region']

    predictions = predict_model(model, data=data) 

    return {'prediction': list(predictions['Label'])}




if __name__ == '__main__':

    uvicorn.run(app, host='127.0.0.1', port=8000)




```

Conclusión

El artículo aborda la idea de API y por qué se utilizan. La API es importante en la arquitectura moderna porque permite a distintos programas de software compartir datos y funcionalidades. Esto permite crear sistemas complejos más fiables y fáciles de mantener.

A continuación, profundizaremos en un framework relativamente nuevo en Python llamado FastAPI. FastAPI es una nueva API diseñada para ser fácil de usar y eficiente. Es una gran opción para los desarrolladores que desean crear una API de forma rápida y sencilla.

Historial de estrellas de GitHub - creado con star-history.com

Historial de estrellas de GitHub - creado con star-history.com

Si también quieres aprender a crear una API sencilla a partir de un modelo de aprendizaje automático en Python utilizando Flask, echa un vistazo a este tutorial fácil de seguir, Turning Machine Learning Models into APIs in Python.

Preguntas frecuentes sobre FastAPI

¿Es FastAPI asíncrona?

FastAPI soporta código asíncrono desde el primer momento utilizando las palabras clave async/await de Python.

¿Está FastAPI listo para la producción?

FastAPI está totalmente preparado para la producción, con una excelente documentación, soporte y una interfaz fácil de usar.

¿En qué se diferencia FastAPI de Flask?

FastAPI admite llamadas asíncronas. Es ligero, más rápido y más fácil de aprender que Flask. Tanto Flask como FastAPI cuentan con enormes comunidades.

¿Tiene FastAPI también un servidor de desarrollo integrado?

No, FastAPI no tiene un servidor de desarrollo integrado. Para ello hay que utilizar `uvicorn`.

¿Es compatible FastAPI con Python 2?

No, FastAPI sólo está disponible en Python 3.6+.

¿Está FastAPI disponible sólo en Python?

¿Es FastAPI más rápido que el lenguaje de programación Go?

No. Según techempower, Golang Fiber es la 50ª API más rápida del mundo. FastAPI ocupa el puesto 183.

¿Es compatible FastAPI con Pydantic?

FastAPI es totalmente compatible con (y se basa en) Pydantic.

Temas

Cursos de Python

Course

Preprocessing for Machine Learning in Python

4 hr
45K
Learn how to clean and prepare your data for machine learning!
See DetailsRight Arrow
Start Course
Ver másRight Arrow
Relacionado

blog

Cómo aprender Python desde cero en 2024: Guía del experto

Descubre cómo aprender Python, sus aplicaciones y la demanda de conocimientos de Python. Comienza hoy tu andadura en Python ​con nuestra guía completa.
Matt Crabtree's photo

Matt Crabtree

19 min

tutorial

APIs Web, Peticiones en Python y Realización de una Petición HTTP en el Tutorial de Python

Conoce los fundamentos de HTTP y también la biblioteca de peticiones en Python para realizar distintos tipos de peticiones.
Kurtis Pykes 's photo

Kurtis Pykes

15 min

tutorial

Tutorial de Python: Streamlit

Este tutorial sobre Streamlit está pensado para ayudar a los científicos de datos o ingenieros de machine learning que no son desarrolladores web y no están interesados en pasar semanas aprendiendo a utilizar estos marcos para crear aplicaciones web.
Nadia mhadhbi's photo

Nadia mhadhbi

18 min

tutorial

Tutorial de funciones de Python

Un tutorial sobre funciones en Python que cubre cómo escribir funciones, cómo invocarlas y mucho más.
Karlijn Willems's photo

Karlijn Willems

14 min

tutorial

Tutorial de SQLAlchemy con ejemplos

Aprende a acceder y ejecutar consultas SQL en todo tipo de bases de datos relacionales utilizando objetos Python.
Abid Ali Awan's photo

Abid Ali Awan

13 min

tutorial

Tutorial de list index() de Python

En este tutorial, aprenderás exclusivamente sobre la función index().
Sejal Jaiswal's photo

Sejal Jaiswal

6 min

See MoreSee More