Python a toujours été populaire pour développer des applications Web légères grâce à des frameworks impressionnants tels que Flask, Django, Falcon, etc. En raison de la position de leader de Python en tant que langage d'apprentissage automatique, il est particulièrement utile pour empaqueter des modèles et les fournir en tant que service.
Pendant des années, Flask a été l'outil principal pour de telles tâches, mais au cas où vous ne l'auriez pas encore entendu, un nouveau concurrent a émergé à sa place. FastAPI est un framework Python relativement nouveau inspiré de ses prédécesseurs. Il améliore leurs fonctionnalités et corrige de nombreuses failles. FastAPI a été construit sur Starlette et possède une tonne de fonctionnalités impressionnantes.
Récemment, il a acquis une grande popularité, et après les 8 derniers mois, j'ai travaillé avec lui tous les jours, je peux dire avec confiance que tout le battage médiatique autour de lui est pleinement justifié. Si vous ne l'avez pas encore essayé, j'ai rassemblé cinq raisons pour lesquelles vous devriez toujours le connaître.
Belle interface simple
Tous les frameworks sont obligés d'équilibrer fonctionnalité et liberté pour le développeur. Django est puissant, mais trop têtu. Flask, en revanche, est suffisamment haut niveau pour offrir une liberté d'action, mais il en reste beaucoup à l'utilisateur. FastAPI est plus proche de Flask à cet égard, mais parvient à atteindre un équilibre encore plus sain.
Par exemple, voyons comment FastAPI définit un point de terminaison.
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"}Pour définir le schéma, Pydantic est utilisé, qui est une bibliothèque Python tout aussi impressionnante pour la validation des données. Cela semble assez simple, mais il se passe beaucoup de choses sous le capot. La responsabilité de la validation des données d'entrée est déléguée à FastAPI. Si une demande incorrecte est envoyée, par exemple, le champ de courrier électronique contient une valeur du type
int, le code d'erreur correspondant sera renvoyé, mais l'application ne plantera pas, générant une erreur de serveur interne (500). Et tout est presque gratuit.
Exemple d'application simple avec
uvicorn:
uvicorn main:appL'application peut désormais accepter les demandes. Dans ce cas, la demande ressemblera à ceci:
curl -X POST "http://localhost:8000/login" -H "accept: application/json" -H "Content-Type: application/json" -d "{\"email\":\"string\",\"password\":\"string\"}"La cerise sur le gâteau est la génération automatique de documentation selon OpenAPI à l'aide de l'interface interactive Swagger.
Interface Swagger pour l'application FastAPI
Async
L'un des plus gros inconvénients des frameworks Web Python WSGI par rapport à leurs homologues dans Node.js ou Go était l'incapacité de traiter les demandes de manière asynchrone. Depuis l'introduction de l'ASGI, ce n'est plus un problème et FastAPI met pleinement en œuvre cette capacité. Tout ce que vous avez à faire est simplement de déclarer les points de terminaison en utilisant le mot clé async comme ceci:
@app.post("/")
async def endpoint():
# ...
# call async functions here with `await`
# ...
return {"msg": "FastAPI is awesome!"}Injection de dépendance
FastAPI a un moyen vraiment cool de gérer les dépendances. Bien que les développeurs ne soient pas obligés d'utiliser l'injection intégrée pour gérer les dépendances sur les points de terminaison, cela est fortement recommandé.
Par exemple, créons un point de terminaison où les utilisateurs peuvent commenter des articles spécifiques.
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 au moment de l'exécution lors de l'appel du point de terminaison, vous pouvez donc utiliser la valeur de retour comme bon vous semble. Il y a (au moins) deux bonnes raisons à cela.
- Vous pouvez remplacer globalement les dépendances en modifiant le dictionnaire
app.dependency_overrides. Cela rendra les tests plus faciles et les objets moqueurs. - La dépendance (dans notre cas
get_database) peut effectuer des vérifications plus complexes et vous permet de les découpler de la logique métier. La question est grandement simplifiée. Par exemple, si vous pouvez facilement mettre en œuvre l' authentification des utilisateurs.
Intégration facile avec les bases de données
Quoi que vous choisissiez, que ce soit SQL, MongoDB, Redis ou quoi que ce soit d'autre, FastAPI ne vous obligera pas à construire votre application autour d'une base de données. Si vous avez déjà travaillé avec MongoDB via Django, vous savez à quel point cela peut être douloureux. Avec FastAPI, vous n'avez pas besoin de faire un hook supplémentaire, car l'ajout de la base de données à la pile est aussi simple que possible. (Ou plus précisément, la quantité de travail sera dictée par la base de données que vous choisissez, et non par la complexité associée à l'utilisation d'un cadre particulier.)
Sérieusement, regardez la beauté.
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! Je peux déjà te voir taper
pip install fastapidans le terminal de votre ordinateur.
Prise en charge de GraphQL
Lorsque vous travaillez avec un modèle de données complexe, REST peut être un obstacle majeur. Ce n'est pas très cool quand le moindre changement sur le front nécessite une mise à jour du schéma de point de terminaison. Dans de tels cas, GraphQL vous sauve. Bien que la prise en charge de GraphQL ne soit pas nouvelle pour les frameworks Web Python, Graphene et FastAPI fonctionnent bien ensemble. Il n'est pas nécessaire d'installer en plus des extensions, par exemple
graphene_djangopour Django, tout fonctionnera depuis le tout début.
+1: Excellente documentation
Bien sûr, un framework ne peut pas être excellent s'il a une documentation médiocre. Django, Flask et d'autres ont bien réussi dans ce domaine et FastAPI les suit. Bien sûr, puisqu'il est beaucoup plus jeune, il n'y a pas encore un seul livre sur lui, mais ce n'est qu'une question de temps.
Si vous voulez voir FastAPI en action, j'ai un excellent guide pour vous. J'ai écrit un tutoriel détaillé avec lequel vous pouvez déployer votre modèle ML sur Docker, Docker Compose et GitHub Actions!
Pour résumer, que vous recherchiez un cadre rapide et léger pour travailler avec votre modèle d'apprentissage en profondeur ou quelque chose de plus complexe, FastAPI est votre option. Je suis sûr que cela fonctionnera pour vous.