🛍️ 🌮 🧟 Por qué debería comenzar a usar FastAPI ahora mismo 🤷🏽 🥕 👨🏾‍🍳

¡Hola, Khabrovites! La víspera del inicio de las clases en los grupos de cursos básicos y avanzados "Python Developer" , hemos preparado otra traducción útil para ti.

Python siempre ha sido popular para desarrollar aplicaciones web ligeras gracias a marcos impresionantes como Flask, Django, Falcon y más. Debido a la posición de liderazgo de Python como lenguaje de aprendizaje automático, es especialmente útil para empaquetar modelos y proporcionarlos como un servicio.

Durante años, Flask ha sido la herramienta principal para tales tareas, pero en caso de que aún no lo haya escuchado, ha surgido un nuevo competidor en su lugar. FastAPI es un framework Python relativamente nuevo inspirado en sus predecesores. Mejora su funcionalidad y corrige muchas fallas. FastAPI se creó sobre Starlette y tiene un montón de características increíbles.

Recientemente, ha ganado mucha popularidad, y después de los últimos 8 meses que he estado trabajando con él todos los días, puedo decir con confianza que todo el bombo a su alrededor está totalmente justificado. Si aún no lo ha probado, he reunido cinco razones por las que aún debería conocerlo.

Agradable interfaz simple

Todos los marcos están obligados a equilibrar la funcionalidad y la libertad para el desarrollador. Django es poderoso, pero demasiado terco. Flask, por otro lado, es lo suficientemente alto como para proporcionar libertad de acción, pero queda mucho para el usuario. FastAPI está más cerca de Flask en este sentido, pero logra un equilibrio aún más saludable.

Por ejemplo, veamos cómo FastAPI define un punto final.

from fastapi import FastAPI
from pydantic import BaseModel


class User(BaseModel):
    email: str
    password: str


app = FastAPI()


@app.post("/login")
def login(user: User):
    # ...
    # do some magic
    # ...
    return {"msg": "login successful"}

Utiliza Pydantic para definir el esquema, que es una biblioteca de Python igualmente impresionante para la validación de datos. Parece bastante simple, pero están sucediendo muchas cosas bajo el capó. La responsabilidad de validar los datos de entrada se delega a FastAPI. Si se envía una solicitud incorrecta, por ejemplo, el campo de correo electrónico contiene un valor de tipo int, se devolverá el código de error correspondiente, pero la aplicación no se bloqueará, arrojando un Error interno del servidor (500). Y todo es casi gratis.

Aplicación de ejemplo simple con uvicorn:

uvicorn main:app

La aplicación ahora puede aceptar solicitudes. En este caso, la solicitud se verá así:

curl -X POST "http://localhost:8000/login" -H  "accept: application/json" -H  "Content-Type: application/json" -d "{\"email\":\"string\",\"password\":\"string\"}"

La guinda del pastel es la generación automática de documentación según OpenAPI utilizando la interfaz interactiva Swagger.

Interfaz Swagger para la aplicación FastAPI

Async

Uno de los mayores inconvenientes de los marcos web Python WSGI en comparación con sus contrapartes en Node.js o Go fue la incapacidad de procesar solicitudes de forma asincrónica. Desde la introducción de ASGI, esto ya no es un problema y FastAPI implementa completamente esta capacidad. Todo lo que tiene que hacer es simplemente declarar los puntos finales usando la palabra clave async como esta:

@app.post("/")
async def endpoint():
    # ...
    # call async functions here with `await`
    # ...
    return {"msg": "FastAPI is awesome!"}

Inyección de dependencia

FastAPI tiene una forma genial de administrar dependencias. Aunque los desarrolladores no están obligados a utilizar la inyección integrada para manejar las dependencias en los puntos finales, esto es muy recomendable.

Por ejemplo, creemos un punto final donde los usuarios puedan comentar artículos específicos.

from fastapi import FastAPI, Depends
from pydantic import BaseModel


class Comment(BaseModel):
    username: str
    content: str


app = FastAPI()


database = {
    "articles": {
        1: {
            "title": "Top 3 Reasons to Start Using FastAPI Now",
            "comments": []
        }
    }
}


def get_database():
    return database


@app.post("/articles/{article_id}/comments")
def post_comment(article_id: int, comment: Comment, database = Depends(get_database)):
    database["articles"][article_id]["comments"].append(comment)
    return {"msg": "comment posted!"}

FastAPI get_database en tiempo de ejecución al llamar al punto final, para que pueda usar el valor de retorno como mejor le parezca. Hay (al menos) dos buenas razones para ello.

Puede anular dependencias globalmente modificando el diccionario app.dependency_overrides. Esto hará que probar objetos sea más fácil y burlón.
La dependencia (en nuestro caso get_database) puede realizar comprobaciones más complejas y le permite desacoplarlas de la lógica empresarial. El asunto se simplifica enormemente. Por ejemplo, para que pueda implementar fácilmente la autenticación de usuario.

Fácil integración con bases de datos

Independientemente de lo que elija, ya sea SQL, MongoDB, Redis o cualquier otra cosa, FastAPI no lo obligará a construir su aplicación alrededor de una base de datos. Si alguna vez ha trabajado con MongoDB a través de Django, sabe lo doloroso que puede ser. Con FastAPI, no necesita hacer un enlace adicional, ya que agregar la base de datos a la pila es lo más sencillo posible. (O más exactamente, la cantidad de trabajo será dictada por la base de datos que elija, no por la complejidad que viene con el uso de un marco en particular). En

serio, mire la belleza.

from fastapi import FastAPI, Depends

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker


engine = create_engine("sqlite:///./database.db")
Session = sessionmaker(bind=engine)


def get_db():
    return Session()


app = FastAPI()


@app.get("/")
def an_endpoint_using_sql(db = Depends(get_db)):
    # ...
    # do some SQLAlchemy
    # ...
    return {"msg": "an exceptionally successful operation!"}

¡Voila! Ya puedo verte escribiendo

pip install fastapi

en el terminal de su computadora.

Soporte GraphQL

Cuando trabaja con un modelo de datos complejo, REST puede ser un gran obstáculo. No es muy bueno cuando el más mínimo cambio en el frente requiere una actualización del esquema del punto final. En tales casos, GraphQL lo salva. Si bien la compatibilidad con GraphQL no es nada nuevo para los marcos web de Python, Graphene y FastAPI funcionan bien juntos. No es necesario instalar ninguna extensión adicional, por ejemplo graphene_djangopara Django, todo funcionará desde el principio.

+1: excelente documentación

Por supuesto, un marco no puede ser excelente si tiene una documentación deficiente. Django, Flask y otros lo han hecho bien en esto, y FastAPI se mantiene al día con ellos. Por supuesto, dado que es mucho más joven, todavía no hay un solo libro sobre él, pero es solo cuestión de tiempo.

Si desea ver FastAPI en acción, tengo una gran guía para usted. ¡Escribí un tutorial detallado con el que puedes implementar tu modelo de aprendizaje automático en Docker, Docker Compose y GitHub Actions!

En resumen, ya sea que esté buscando un marco rápido y ligero para trabajar con su modelo de aprendizaje profundo o algo más complejo, FastAPI es su opción. Estoy bastante seguro de que funcionará para ti.

Por qué debería comenzar a usar FastAPI ahora mismo