Partager:
){kind=small}
Tonya est une ancienne conseillère des développeurs Python chez Vonage.
Le face-à-face ultime : Flask vs. FastAPI
Choisir un cadre n'est pas facile, et c'est pourquoi je suis ici pour vous aider à vous débarrasser de ce casse-tête.
Pourquoi devrions-nous même comparer Flask et FastAPI?
Ils sont similaires. Tous deux sont des microfabriques Python dépouillées, sans les cloches et les sifflets, ce qui signifie un temps de développement plus rapide et une plus grande flexibilité. Ils sont également utilisés pour la création d'API et d'applications web.
Ils sont également différents. Flask est plus éprouvé, donc légèrement plus fiable, et il est largement utilisé. FastAPI est un framework plus récent et plus moderne connu pour sa rapidité avec beaucoup de support intégré comme Pydantic et SwaggerUI.
Maintenant que vous avez une meilleure compréhension de chaque cadre, commençons notre confrontation !
Parfois, la partie la plus difficile de l'apprentissage de quelque chose de nouveau est de commencer. C'est pourquoi nous commencerons par l'installation.
Il est relativement simple d'installer Flask et FastAPI à l'aide de l'installateur préféré de Python, pip. C'est également une bonne pratique d'installer les deux dans un environnement virtuel, un environnement isolé pour chacun de vos projets Python qui élimine les erreurs de collision.
$ pip install flask
$ pip install fastapi uvicornConclusion: Notez que vous installez FastAPI avec Uvicorn. Considérez Uvicorn comme un serveur rapide comme l'éclair qui permet à vos Applications d'être plus performantes.
Si vous n'avez écrit qu'une seule ligne de code dans toute votre vie, je parie que c'était quelque chose comme ça :
print(“Hello World”)
C'est un peu comme si vous appreniez une autre langue, disons le mandarin. Il existe un système appelé Pinyin, qui transcrit les caractères chinois en anglais afin que les gens puissent les prononcer. Ce système est conçu pour vous permettre d'être rapidement opérationnel, tout comme une application Hello World.
Voyons à quoi ressemble une application hello world à la fois en Flask et en FastAPI.
# inside of a Python .py file
from flask import Flask
app = Flask(__name__)
@app.route("/", methods=\[“GET”])
def home():
return {"Hello": "World"}
if __name__ == "__main__":
app.run()
from flask import Flask
app = Flask(__name__)
@app.get("/")
def home():
return {"Hello": "World"}
if __name__ == "__main__":
app.run()
# inside of a Python .py file
import uvicorn
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def home():
return {"Hello": "World"}
if __name__ == "__main__":
uvicorn.run("main:app")Conclusion: Dans les versions les plus récentes de Flask, vous pouvez utiliser les boutons @app.get() et @app.post() comme raccourcis pour le routage. L'ancienne façon d'utiliser @app.route() vous obligeait à passer vos verbes HTTP dans une liste de méthodes comme suit : methods=\[“GET”, “POST”].
Remarque : Flask utilise une méthode
GETpar défaut, il n'est donc pas nécessaire de le spécifier dans la liste des méthodes.
Ces méthodes sont également fournies dans FastAPI avec la prise en charge des routes décorées suivantes pour chaque méthode HTTP :
@app.get()@app.post()@app.put()@app.delete()
Une fois que vous aurez écrit votre application "Hello World", vous voudrez d'abord l'exécuter en développement - ou localement sur votre machine - avant de la mettre en production pour que le monde entier puisse la voir. Si votre application ne fonctionne pas comme prévu, les gens vont certainement paniquer. Vous voulez minimiser cette panique.
Dans votre terminal, exécutez donc les commandes suivantes :
$ export FLASK_APP=app.py
$ export FLASK_ENV=development
$ flask run
$ uvicorn main:app --reloadConclusion: FastAPI utilise le rechargement à chaud, qui permet à l'application de continuer à fonctionner pendant que vous apportez des modifications au code. Ainsi, vous n'avez pas besoin de redémarrer constamment le serveur de développement. Avec Flask, vous avez besoin d'une commande de terminal supplémentaire : export FLASK_ENV=developmentFlask, qui vous permet d'apporter des modifications au code sans redémarrer votre serveur de développement.
Dans l'exemple Hello World, nous avons vu à quoi ressemble un GET dans Flask et FastAPI, alors regardons maintenant de plus près la méthode POST.
@app.route("/teams", methods=["POST"])
def create_team():
team = {
"team_name": "Phoenix Suns",
"players": [
{
"name": "Chris Paul",
"age": 36
}
]
}
teams.append(team)
return (jsonify(teams))
@app.post("/teams")
def create_team():
team = {
"team_name": "Phoenix Suns",
"players": [
{
"name": "Chris Paul",
"age": 36
}
]
}
teams.append(team)
return (jsonify(teams))
@app.post("/teams")
def create_team():
team = {
"team_name": "Phoenix Suns",
"players": [
{
"name": "Chris Paul",
"age": 36
}
]
}
teams.append(team)
return {'teams':teams}Conclusion: Flask 2.0 et FastAPI se ressemblent beaucoup lorsqu'on utilise la méthode POST. L'astuce est de voir comment les nouvelles données sont créées.
Avec Flask, vous devrez utiliser un outil comme Postman agissant en tant que client, afin que vous puissiez voir vos requêtes POST et les données que vous avez créées au format JSON.
FastAPI est livré avec Pydantic et SwaggerUI, ce qui vous permet d'utiliser la documentation automatique pour interagir avec vos requêtes depuis le navigateur, y compris les requêtes POST.
Flask peut également utiliser la documentation automatique, mais vous devrez l'installer à l'aide de flask-swagger. Il y a aussi beaucoup de configuration à faire pour que cela fonctionne. Voyons comment voir vos requêtes POST dans FastAPI dans la section suivante.
Si vous croyez à la magie, vous aimerez certainement Automatic Documentation.
FastAPI est basé sur Pydantic, un cadre permettant de modéliser et de valider facilement des objets. Il est fourni dans la boîte, il n'est donc pas nécessaire de l'installer. Pydantic élimine la douleur d'écrire des constructeurs, et vous obtenez toutes les méthodes magiques. Pydantic fait également de la validation de données qui affiche des erreurs plus conviviales et utilise les indices de type de Python, réduisant ainsi le temps de débogage. Pour accéder à votre documentation automatique, assurez-vous que votre serveur de développement est en cours d'exécution, puis allez sur votre localhost et sur le port sur lequel tourne votre application :
http://127.0.0.1:8000/docsVous verrez votre requête POST comme dans l'exemple ci-dessous ; si vous utilisez d'autres méthodes HTTP, celles-ci seront également visibles.
FastAPI Python automatic documentation POST request using Pydantic
Faisons quelque chose de beaucoup plus cool pour voir la beauté de la documentation automatique. Disons que nous avons ce code dans FastAPI :
from pydantic import BaseModel
app = FastAPI()
class Player(BaseModel):
player_name: str
player_team: str
player_age: int
@app.post("/teams")
def create_team(request: Player):
return {'teams':request}Notez que pour utiliser Pydantic, vous devez importer le fichier BaseModel dont la classe Player héritera. Nous déclarons également des variables en tant qu'indices de type dans notre classe et nous renvoyons un dictionnaire dans notre requête POST.
Lorsque vous consultez votre documentation automatique, vous voyez un schéma. Ce schéma est un squelette de votre modèle avec des variables, où vous pouvez voir quels champs sont obligatoires et quels champs sont facultatifs.
FastAPI Python automatic documentation with Pydantic POST request and schema
Vous pouvez également "l'essayer" et tester votre point d'accès à l'API en passant des valeurs pour les variables. Ici, par exemple, nous passons “Michael Jordan” pour la variable player_name de type String.
FastAPI Python automatic documentation with Pydantic POST request and request body
Ensuite, lorsque vous cliquez sur Exécuter, vous obtenez le corps de la réponse. Il n'est pas nécessaire d'utiliser un outil supplémentaire comme Postman.
FastAPI Python automatic documentation with Pydantic POST request and response body
Votre documentation interactive génère également une commande curl pour vous, ce qui vous évite d'en écrire une à partir de zéro :
FastAPI Python automatic documentation with Pydantic POST request and Curl
Conclusion: Puisque la Documentation Automatique est livrée avec FastAPI ainsi que Pydantic et Swagger UI, ces fonctionnalités vont certainement accélérer votre temps de développement. Vous n'avez pas besoin d'installer des outils externes pour tester vos requêtes.
Comme notre ami Pydantic est livré avec FastAPI lors de l'installation, il vous donnera des messages d'erreur assez sympathiques lorsque vous rencontrerez des problèmes avec votre code.
from pydantic import BaseModel
from typing import Optional
class Login(BaseModel):
username: str
password: str
agree_to_terms: Optional\[bool]
@app.post("/login")
def login(request: Login):
if request.username == "janedoe" and request.password == "password12345":
return {"message": "Success"}
return {"message": "Authentication Failed"}Ici, nous créons une classe Login qui hérite du Pydantic BaseModel avec des variables de type à l'intérieur. Nous vérifions d'abord si la variable username est janedoe et si la variable password est passworld12345puis nous renvoyons un message de succès ou d'échec en conséquence.
Nous nous tournons vers la documentation automatique et testons notre corps de requête en passant dans None au nom d'utilisateur :
FastAPI Python automatic documentation with Pydantic POST request and change request body
Pydantic va opérer sa magie, et vous obtiendrez un message amical vous indiquant exactement la nature de l'erreur. Dans ce cas, il renvoie l'erreur Expecting Valuece qui est tout à fait exact puisque nous avons passé None à l'élément username.
FastAPI Python automatic documentation with Pydantic error message
Conclusion: Flask n'a pas de support interne pour la validation des données. Vous pouvez utiliser le puissant paquet Pydantic pour la validation des données en l'installant avec Flask-Pydantic.
Un chemin d'accès ou un paramètre URL permet de récupérer un seul élément. Supposons que nous voulions obtenir un seul joueur. Le joueur dont l'identifiant correspond à celui que nous indiquons dans l'URL sera renvoyé à l'utilisateur.
Supposons que nous disposions d'une liste de dictionnaires et que nous souhaitions extraire un lecteur de ce fichier JSON :
players = [
{
"player_id": 1,
"name": "Giannis"
},
{
"player_id": 2,
"name": "Luka"
}
]
@app.get('/players/<int:player_id>')
def get_player_details(player_id):
for player in players:
if player["player_id"] == player_id:
return jsonify(player)
Ici, nous transmettons notre route à localhost sur le port 5000 avec un identifiant de 2, et nous obtenons en retour le lecteur avec un identifiant de 2.
Flask Python url or path parameters running on localhost returning JSON as response body
@app.get("/player/{player_id}")
def get_player_details(player_id: int):
for player in players:
if player['player_id'] == player_id:
return {'player':player['name']}Ici, nous transmettons notre route à localhost sur le port 8000 avec un identifiant de 1, et nous obtenons en retour le lecteur avec un identifiant de 1.
FastAPI Python url or path parameters running on localhost returning JSON as response body
Conclusion: Avec FastAPI, puisqu'il utilise le type hinting de Python, vous pouvez porter votre code vers d'autres frameworks, comme Django. Avec Flask, ce n'est pas portable car nous utilisons un type hinting spécifique au framework, et non un type hinting Python.
Le dossier Applications stocke vos fichiers HTML lorsque vous construisez une application web en Flask ou FastAPI, et vous devez utiliser Jinja pour afficher vos variables en HTML. Jinja est un moteur de template qui vous permet d'écrire du code similaire à Python pour afficher du HTML.
Par défaut, Flask recherche des modèles dans un dossier "templates". Il vous suffit d'en créer un dans votre structure de fichiers.
Flask Python templates folder in file structure to render HTML files
Flask Python templates folder in file structure to render HTML files
Vous pouvez ensuite utiliser Jinja pour afficher vos variables en les entourant de doubles accolades :
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Players</title>
</head>
<body>
<h1>Display Players</h1>
{{ player.name }}
{{ player.jersey_number }}
</body>
</html>
Conclusion: Jijnja est livré avec Flask lors de l'installation, ce qui est un énorme avantage. Dans FastAPI, vous devez installer Jinja et définir le dossier templates dans votre code.
À un moment donné, vous voudrez déployer votre application et la montrer au monde entier.
Flask utilise un serveur web appelé WSGI, qui signifie Web Server Gateway Interface et qui est la norme Python depuis de nombreuses années. L'inconvénient est qu'il est synchrone. Cela signifie que si vous avez plusieurs requêtes, elles doivent attendre que la file d'attente se termine.
FastAPI utilise un serveur web appelé ASGI (Asynchronous Server Gateway Interface), qui est très rapide parce qu'il est - vous l'avez deviné - asynchrone. Ainsi, si plusieurs demandes arrivent, elles n'ont pas besoin d'attendre que les autres soient terminées avant d'être traitées.
Conclusion: ASGI permet d'accélérer les performances de vos applications web car il traite les requêtes de manière asynchrone.
Roulement de tambour, s'il vous plaît.
Le gagnant est... eh bien, cela dépend.
C'est ainsi que vous pouvez choisir.
Utilisation Flasque si vous le souhaitez :
Un cadre qui a fait ses preuves, puisqu'il existe depuis longtemps
Développer un prototype rapide
Faire du développement d'applications web
Utiliser FastAPI si vous le souhaitez :
Vitesse, en termes de temps de développement et de performance
Pour réduire le nombre de bogues et d'erreurs dans votre code
Pour créer des API à partir de zéro
Ok, vous avez vu Flask et FastAPI en action. Vous avez maintenant une meilleure compréhension des deux, et vous avez déterminé lequel serait le mieux adapté à votre prochain projet.
Quel cadre avez-vous choisi ? Tweetez-nous @VonageDev ou @tonyasims.