Si vous vous lancez dans le monde du développement web moderne, il y a de fortes chances que vous ayez entendu parler de FastAPI. C'est l'un des frameworks qui connaît la croissance la plus rapide pour la création d'API en Python. Dans cet article de blog, nous allons explorer comment utiliser FastAPI pour créer et gérer des requêtes POST. Que vous soyez un développeur chevronné ou que vous débutiez, ce guide vous aidera à comprendre les bases et au-delà.
Qu'est-ce que FastAPI ?
FastAPI est un framework web moderne, rapide (haute performance), pour la création d'API avec Python 3.7+ basé sur les indications de type Python standard. Il est conçu pour être facile à utiliser et pour offrir des performances élevées, comparables à celles de Node.js et Go. Le framework est également très intuitif et simple, ce qui en fait un excellent choix pour les débutants comme pour les experts.
Pourquoi utiliser FastAPI ?
Il existe plusieurs raisons pour lesquelles les développeurs choisissent FastAPI plutôt que d'autres frameworks :
- Vitesse : FastAPI est rapide. En fait, c'est l'un des frameworks web les plus rapides disponibles aujourd'hui.
- Facilité d'utilisation : Grâce à la documentation interactive automatique (grâce à Swagger UI et ReDoc), il est incroyablement facile de tester vos API.
- Validation des données : FastAPI utilise Pydantic pour la validation des données, ce qui garantit que les données que votre API reçoit sont valides.
- Prêt pour Async : Il prend en charge la programmation asynchrone prête à l'emploi, ce qui le rend adapté aux applications web modernes et performantes.
Configuration de FastAPI
Avant de nous plonger dans les requêtes POST, configurons rapidement FastAPI. Vous devrez avoir Python installé sur votre système. Ensuite, vous pouvez installer FastAPI et un serveur ASGI, tel que Uvicorn, en utilisant pip :
pip install fastapi uvicorn
Une fois que vous avez installé FastAPI, vous pouvez créer une simple application FastAPI. Commençons par créer un fichier nommé main.py :
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"Hello": "World"}
Pour exécuter l'application, utilisez Uvicorn :
uvicorn main:app --reload
Ouvrez votre navigateur et accédez à http://127.0.0.1:8000. Vous devriez voir une réponse JSON : {"Hello": "World"}.
Création d'un point de terminaison POST
Maintenant que nous avons une application FastAPI de base en cours d'exécution, ajoutons un point de terminaison POST. Les requêtes POST sont utilisées pour soumettre des données à traiter vers une ressource spécifiée. Pour gérer une requête POST dans FastAPI, vous utilisez le décorateur @app.post.
Voici un exemple simple de la façon de gérer une requête POST :
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
class Item(BaseModel):
name: str
description: str = None
price: float
tax: float = None
@app.post("/items/")
def create_item(item: Item):
return item
Dans cet exemple :
- Nous définissons une instance
FastAPI. - Nous créons un modèle Pydantic
Itemqui décrit la structure de données du corps de la requête. - Nous utilisons le décorateur
@app.postpour définir un point de terminaison POST/items/. - La fonction
create_itemprend un objetItemen entrée et le renvoie.
Pour tester cela, vous pouvez utiliser un client API comme apidog ou simplement utiliser l'interface utilisateur interactive Swagger fournie par FastAPI à l'adresse http://127.0.0.1:8000/docs.
Gestion des données et validations
FastAPI valide automatiquement les données de la requête par rapport au modèle Pydantic. Si les données ne sont pas conformes au modèle, FastAPI renvoie un code d'état 422 avec des détails sur les erreurs de validation.
Par exemple, si vous envoyez une requête POST à /items/ avec le corps JSON suivant :
{
"name": "Item name",
"price": 25.5
}
FastAPI acceptera cette requête car elle répond aux exigences du modèle Item. Cependant, si vous omettez le champ price, FastAPI rejettera la requête et renverra une erreur.
Utilisation d'Apidog pour tester votre requête POST FastAPI
Apidog est un outil puissant pour tester les API. Il vous permet de créer et d'enregistrer des requêtes API, de les organiser en collections et de les partager avec votre équipe.
Voici comment vous pouvez utiliser Apidog pour tester votre requête POST :
- Ouvrez Apidog et créez une nouvelle requête.
2. Définissez la méthode de requête sur POST.
3. Entrez l'URL de la ressource que vous souhaitez mettre à jour. Ajoutez tous les en-têtes ou paramètres supplémentaires que vous souhaitez inclure, puis cliquez sur le bouton « Envoyer » pour envoyer la requête.
4. Vérifiez que la réponse est celle que vous attendiez.
Requêtes POST avancées
Maintenant, explorons des scénarios plus avancés. FastAPI vous permet de faire beaucoup plus avec les requêtes POST. Par exemple, vous pouvez :
- Gérer les téléchargements de fichiers : Utilisez
FileetUploadFiledefastapi. - Traiter les données de formulaire : Utilisez
Formdefastapi. - Utiliser les paramètres de chemin : Combinez les
paramètres de cheminavec les requêtes POST.
Gestion des téléchargements de fichiers
Voici un exemple de gestion des téléchargements de fichiers avec FastAPI :
from fastapi import FastAPI, File, UploadFile
app = FastAPI()
@app.post("/uploadfile/")
async def create_upload_file(file: UploadFile):
return {"filename": file.filename}
Ce point de terminaison acceptera un fichier et renverra le nom du fichier. Vous pouvez tester cela avec apidog ou Swagger UI.
Traitement des données de formulaire
Pour traiter les données de formulaire, utilisez la classe Form de FastAPI :
from fastapi import FastAPI, Form
app = FastAPI()
@app.post("/login/")
def login(username: str = Form(...), password: str = Form(...)):
return {"username": username}
Cet exemple crée un point de terminaison de connexion qui accepte les données de formulaire. Vous pouvez tester cela en utilisant une soumission de formulaire dans votre navigateur ou un outil de test d'API.
Utilisation des paramètres de chemin
Vous pouvez également combiner les paramètres de chemin avec les requêtes POST :
from fastapi import FastAPI
app = FastAPI()
@app.post("/users/{user_id}/items/")
def create_item_for_user(user_id: int, item: Item):
return {"user_id": user_id, "item": item}
Ce point de terminaison crée un élément pour un utilisateur spécifique, identifié par le paramètre de chemin user_id.
Conclusion
FastAPI est un framework puissant qui facilite la création d'API robustes avec Python. Sa prise en charge de la validation des données, de la documentation interactive et des hautes performances en fait un excellent choix pour le développement web moderne.
Dans cet article de blog, nous avons vu comment configurer une application FastAPI et gérer les requêtes POST. Nous avons également exploré des sujets plus avancés comme les téléchargements de fichiers, le traitement des données de formulaire et la combinaison des paramètres de chemin avec les requêtes POST. À ce stade, vous devriez avoir une bonne compréhension de la façon d'utiliser FastAPI pour créer et gérer les requêtes POST.
N'oubliez pas que, que vous construisiez une API simple ou une application complexe, FastAPI dispose des outils dont vous avez besoin pour réussir. Bon codage !
