Comment utiliser FastAPI pour construire des services API haute performance
Comment utiliser FastAPI pour construire des services API haute performance
FastAPI est un cadre Web moderne et rapide (efficace), conçu pour construire des API. Il est basé sur les annotations de type Python et prend en charge la programmation asynchrone, permettant aux développeurs de créer des services API haute performance, hautement disponibles et à faible latence. Cet article vous expliquera en détail comment utiliser FastAPI pour construire des services API haute performance, en procédant étape par étape pour vous aider à réaliser l'ensemble du processus, de la configuration de l'environnement au déploiement.
Étape 1 : Préparation de l'environnement
Vous devez vous assurer que Python 3.6+ est installé dans votre environnement de développement. Si ce n'est pas le cas, vous pouvez visiter le site officiel de Python pour le télécharger et l'installer.
Installer FastAPI et Uvicorn
FastAPI lui-même ne fournit pas de service, il nécessite un serveur ASGI pour fonctionner. Ici, nous utilisons Uvicorn, un serveur ASGI haute performance. Vous pouvez installer FastAPI et Uvicorn avec la commande suivante :
pip install fastapi uvicornÉtape 2 : Construire une API de base
Créons une simple application FastAPI.
Créer le fichier d'application
Dans votre répertoire de projet, créez un fichier Python, par exemple main.py, puis écrivez le code suivant :
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
async def read_root():
return {"message": "Hello, World!"}Dans le code ci-dessus, nous avons d'abord importé FastAPI et créé une instance app. Ensuite, nous avons défini une route GET qui renvoie une simple réponse JSON lorsque l'on accède au chemin racine /.
Démarrer le serveur
Démarrez votre serveur FastAPI avec la commande suivante :
uvicorn main:app --reloadmain: fait référence au nom du fichier, sans l'extension .py.app: fait référence à l'instance FastAPI.--reload: en mode développement, le serveur redémarre automatiquement lors des modifications de fichiers.
Étape 3 : Définir des routes et des modèles de données
Pour établir des API complexes, vous devez utiliser Pydantic pour définir des modèles de données.
Créer un modèle de données
Ajoutez le contenu suivant dans main.py :
from pydantic import BaseModel
class Item(BaseModel):
name: str
price: float
is_available: bool = TrueCe code utilise Pydantic pour créer un modèle de données Item, qui contient trois attributs : le nom de l'article, le prix et la disponibilité.
Ajouter une nouvelle route
Ensuite, nous pouvons définir une nouvelle route POST pour recevoir des données de type Item :
@app.post("/items/")
async def create_item(item: Item):
return {"item_name": item.name, "item_price": item.price}Dans cette route, FastAPI validera automatiquement les données entrantes et les mappera au modèle Item.
Étape 4 : Génération automatique de documentation
Un des plus grands avantages de FastAPI est sa capacité à générer automatiquement la documentation de l'API. Vous pouvez la consulter en accédant aux adresses suivantes :
- Swagger UI :
http://127.0.0.1:8000/docs - ReDoc :
http://127.0.0.1:8000/redoc
Dans cette documentation générée, vous pouvez tester l'API de manière interactive et voir le format des requêtes et des réponses pour chaque route.
Étape 5 : Ajouter une authentification
Dans les applications réelles, l'authentification est un aspect important. Ajoutons une authentification simple basée sur les rôles.
Ajouter des dépendances de sécurité
Utilisez la méthode Depends de FastAPI et OAuth2PasswordBearer pour mettre en œuvre l'authentification :
from fastapi import Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer
oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
async def fake_decode_token(token):
return {"sub": token}
async def get_current_user(token: str = Depends(oauth2_scheme)):
user = fake_decode_token(token)
if user is None:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid authentication credentials")
return userProtéger les routes
Ensuite, vous pouvez ajouter l'authentification aux routes qui nécessitent une protection :
@app.get("/users/me")
async def read_users_me(current_user: dict = Depends(get_current_user)):
return current_userÉtape 6 : Déployer l'application FastAPI
Une fois le développement terminé, vous devrez peut-être déployer l'application sur un serveur cloud. Vous pouvez choisir de déployer avec Docker.
Créer un Dockerfile
Dans le répertoire du projet, créez un fichier nommé Dockerfile et entrez le contenu suivant :
FROM tiangolo/uvicorn-gunicorn-fastapi:python3.8
COPY ./app /appConstruire l'image Docker
Dans votre terminal, utilisez la commande suivante pour construire l'image Docker :
docker build -t myfastapiapp .Exécuter le conteneur Docker
Exécutez votre application FastAPI :
docker run -d --name fastapi -p 80:80 myfastapiappConclusion
Dans cet article, nous avons expliqué en détail comment utiliser FastAPI pour construire des services API haute performance, depuis la préparation de l'environnement jusqu'à la création d'une API de base, la définition de routes et de modèles de données, puis l'ajout d'authentification et le déploiement. FastAPI offre de nombreuses fonctionnalités puissantes, rendant la construction d'API modernes simple et efficace. Vous pouvez explorer davantage de fonctionnalités et de caractéristiques dans la documentation officielle. Nous espérons que cet article vous aidera à vous familiariser plus rapidement avec FastAPI et à améliorer l'efficacité de votre développement de projet !
