¿Por qué FastAPI puede ser la mejor opción para el desarrollo de API eficiente y de alto rendimiento? Por Félix Gómez | enero, 2023
Maximizando su potencial de desarrollo: aprovechando el poder de la velocidad, la facilidad de uso y las funciones avanzadas de FastAPI
FastAPI es un marco web moderno y de alto rendimiento para crear API con Python 3.6+ basado en directivas de tipo estándar de Python. Una de las principales razones para usar FastAPI es su velocidad. es uno de ellos frameworks web de Python más rápidos disponible debido a su naturaleza asíncrona y al uso de tecnologías modernas como async/await y type tips. Esto significa que sus API podrán manejar una gran cantidad de solicitudes en un corto período de tiempo, lo que las hará adecuadas para aplicaciones de alto rendimiento.
Otra razón para usar FastAPI es su simplicidad y facilidad de uso. El marco está diseñado para que sea fácil de aprender y usar, incluso para desarrolladores nuevos en la creación de API. Tiene una API limpia y simple y la documentación está bien escrita y es fácil de entender. Además, proporciona una fácil integración con otras bibliotecas como SQLAlchemy y Motor para la gestión de bases de datos y Pydantic para la validación de datos. Esto facilita el inicio de la creación de una API y aumenta la velocidad de desarrollo.
FastAPI también proporciona soporte integrado para inyección de dependencia, lo que facilita la administración de dependencias en su código y la escritura de código comprobable. Esto permite aplicaciones más robustas y duraderas. También tiene una función de documentación automática que genera documentación OpenAPI y documentación interactiva con Swagger UI y ReDoc. Esto facilita la prueba, la depuración y la documentación de los puntos finales de su API, lo que permite que otros desarrolladores comprendan e interactúen rápidamente con su API.
Recientemente se ha vuelto muy popular debido a su simplicidad y facilidad de uso. Ahora le mostraré algunas características excelentes que puede obtener usando FastAPI para mejorar aún más su experiencia de desarrollo de API:
Una de las características más poderosas de FastAPI es su capacidad para validar automáticamente los datos pasados a los puntos finales de su API mediante sugerencias al estilo de Python. Esto significa que puede especificar los tipos de datos esperados para cada parámetro en su función de punto final, y FastAPI validará automáticamente que los datos entrantes coincidan con esos tipos.
Toda validación está bien establecida y gestionada por un sólido Paquete piramidal
Por ejemplo, si tiene un punto final que acepta el nombre y la edad de un usuario, puede definir el punto final de esta manera:
from fastapi import FastAPIapp = FastAPI()
@app.post("/users/")
def create_user(name: str, age: int):
return {"name": name, "age": age}
En este ejemplo, create_user la función acepta dos parámetros de solicitud, name y agey se definen como sus tipos str y int de acuerdo a. Cuando el cliente envía una solicitud a este punto final con un cuerpo JSON {"name": "John", "age": 30}FastAPI confirmará automáticamente name el campo es una cadena y age es un número entero y los pasará a la función de punto final. Si el cliente envía una solicitud con datos no válidos, por ejemplo, un valor incompleto para ageFastAPI devolverá un error de entidad no procesable 422.
Esta característica le evita escribir código de validación adicional y hace que su código sea más legible y autodocumentado. Las sugerencias de tipo aclaran qué tipos de datos espera una función de punto final, y esta información también se puede usar para generar automáticamente la documentación de la API.
Además, FastAPI también incluye soporte Autenticación avanzada usando Pydantic modelos y también le permite realizar validaciones más complejas y agregar valores predeterminados, descripciones, etc. a sus modelos. admite la capacidad de definir funciones de validación personalizadas que le permiten agregar información adicional, como
FastAPI tiene soporte incorporado para crear documentación API, una de las características más convenientes del marco. La documentación se genera automáticamente en función de sugerencias de tipo y comentarios en su código. No necesita escribir ningún código adicional para crear la documentación de su API.
Cuando define un punto final en su aplicación, FastAPI usa las sugerencias de tipo y la cadena de documento en la función de punto final para generar la documentación para ese punto final. Por ejemplo, podemos agregar una cadena de documento al último ejemplo:
from fastapi import FastAPIapp = FastAPI()
@app.post("/users/")
def create_user(name: str, age: int):
"""
Create a new user.
- **name**: The name of the user.
- **age**: The age of the user.
"""
return {"name": name, "age": age}
Él create_user tiene una cadena de documento que describe el punto final de la función y los parámetros que acepta. Cuando ejecute su aplicación, FastAPI generará automáticamente documentación para este punto final, incluida su descripción, los parámetros que acepta y sus tipos.
Los documentos generados son interactivos y fáciles de usar. Contiene una lista de todos los puntos finales de su aplicación, sus descripciones, los parámetros que aceptan y los tipos de esos parámetros. La documentación también incluye solicitudes y respuestas de muestra para cada punto final, lo que facilita la comprensión de cómo funciona y qué devuelve.
Además, FastAPI viene con ambos redoc o swagger-ui Para acceder a los documentos interactivos y elegantemente creados, irá /docs por jactarse y /redocpara redoc.
FastAPI admite la programación asíncrona, también es una característica poderosa que le permite manejar múltiples solicitudes al mismo tiempo. Esto es especialmente útil cuando una API necesita realizar tareas que consumen mucho tiempo, como realizar solicitudes a otra API o procesar grandes cantidades de datos.
La programación asíncrona es un método de escritura de código que puede ejecutar múltiples tareas simultáneamente, en lugar de esperar a que se complete una tarea antes de comenzar otra. En FastAPI puedes usar async palabra clave para definir funciones de punto final asincrónicas y await palabra clave para invocar operaciones asincrónicas dentro de estos puntos finales.
Por ejemplo, si necesita realizar una llamada API externa dentro de un punto final, puede usar aiohttp librería para hacer llamadas asincrónicas. Un ejemplo de una función de punto final asincrónica que realiza una llamada API externa y devuelve el resultado:
from fastapi import FastAPI
import aiohttpapp = FastAPI()
@app.get("/catfact")
async def get_random_cat_fact():
async with aiohttp.ClientSession(connector=aiohttp.TCPConnector(verify_ssl=False)) as session:
async with session.get(f"https://catfact.ninja/fact") as response:
data = await response.json()
return data
En este ejemplo, get_random_cat_fact la función se define como asíncrona async palabra clave y await palabra clave se utiliza para llamar session.get() y response.json() realiza funciones asíncronas. Esto permite que el punto final maneje múltiples solicitudes simultáneamente, en lugar de esperar a que una llamada API externa las complete antes de manejar la siguiente solicitud.
Esta característica es útil cuando su API necesita realizar tareas que consumen mucho tiempo, como enviar solicitudes a otra API o procesar grandes cantidades de datos. Mediante el uso de la programación asincrónica, la API puede gestionar varias solicitudes simultáneamente, lo que mejora en gran medida el rendimiento general y la capacidad de respuesta de su aplicación.
FastAPI tiene soporte incorporado para administrar bases de datos y puede integrarse fácilmente con cualquier biblioteca de asignación relacional de objetos (ORM), como SQLAlchemy para bases de datos SQL o Motor para MongoDB. Esto significa que puede definir fácilmente sus modelos de base de datos usando clases de Python y comunicarse con la base de datos usando métodos simples de Python.
Por ejemplo, con SQLAlchemy, puede definir y luego usar sus modelos de base de datos usando clases session objeto proporcionado por FastAPI para interactuar con la base de datos. puedes usar session.add(), session.commit(), session.query() y otros métodos para realizar operaciones CRUD en la base de datos.
from fastapi import FastAPI
from sqlalchemy.orm import Session
from sqlalchemy import Column, String, Integer
from sqlalchemy.ext.declarative import declarative_baseapp = FastAPI()
Base = declarative_base()
class Item(Base):
__tablename__ = "items"
id = Column(Integer, primary_key=True, index=True)
name = Column(String, index=True)
description = Column(String)
@app.post("/items/")
def create_item(item: Item, db: Session = Depends(get_db)):
db.add(item)
db.commit()
db.refresh(item)
return item
De manera similar, puede usar Motor para bases de datos que no sean SQL como MongoDB para interactuar con la base de datos.
from fastapi import FastAPI
from motor.motor_asyncio import AsyncIOMotorClientapp = FastAPI()
@app.get("/items/{item_id}")
async def read_item(item_id: str, client: AsyncIOMotorClient = Depends(get_client)):
db = client.db
item_collection = db["items"]
item = await item_collection.find_one({"_id": item_id
Esto permite a los desarrolladores centrarse en la lógica comercial de su aplicación y no preocuparse por los detalles de bajo nivel de la interacción con la base de datos.
FastAPI admite la inyección de dependencias, un patrón de diseño que le permite transferir rápidamente dependencias entre diferentes partes de su aplicación. Esto facilita la administración de dependencias en su código y la escritura de código comprobable.
La inyección de dependencia en FastAPI se logra mediante el uso de sugerencias de tipo en los argumentos de función. Por ejemplo, si desea pasar una conexión de base de datos a su punto final, puede definir una función que acepte una Session usar el objeto como argumento y para interactuar con la base de datos.
from fastapi import FastAPI, Depends
from sqlalchemy.orm import Sessionapp = FastAPI()
def get_db():
return ... # create a connection to the database
@app.post("/items/")
def create_item(item: Item, db: Session = Depends(get_db)):
db.add(item)
db.commit()
db.refresh(item)
return item
En este ejemplo, get_db() La función devuelve la conexión de la base de datos, que se pasa como argumento. create_item funcionar a través Depends. Esto le permite cambiar fácilmente la ejecución de una función para diferentes entornos (por ejemplo, pruebas) sin cambiar el resto del código.
Además, la inyección de dependencia también le permite escribir código fácilmente comprobable. Puede simular o reemplazar dependencias rápidamente en sus pruebas sin cambiar el código bajo prueba. Esto facilita probar diferentes escenarios y casos extremos sin crear una base de datos real u otras dependencias.
FastAPI es un marco excepcional para crear API con Python. Los fantásticos trucos que ofrece lo hacen aún más poderoso y fácil de usar, al tiempo que proporciona una forma eficiente y de alto rendimiento para desarrollar e implementar sus API.
Con la validación automática de datos, la documentación automática de API, el soporte asíncrono, la fácil integración con bases de datos y la inserción de dependencias, puede sacar mucho provecho de la creación de API y centrarse más en la creación de la lógica empresarial de su aplicación.
Además, la función de documentación automática que genera documentación de OpenAPI y documentación interactiva con la interfaz de usuario de Swagger y ReDoc facilita la prueba, la depuración y la documentación de sus puntos finales de API, lo que permite que otros desarrolladores comprendan e interactúen rápidamente con su API.
FastAPI es una excelente opción para crear API eficientes y de alto rendimiento con Python. Sus funciones avanzadas y su facilidad de uso lo convierten en una poderosa herramienta para desarrolladores de todos los niveles. Su naturaleza rápida y asíncrona lo hace perfecto para crear aplicaciones de alto rendimiento, escalables y fáciles de mantener.
Los grandes logros siempre ocurren dentro de las altas expectativas -Charles Kettering
