Construire des API REST avec FastAPI

Introduction

FastAPI est un framework web moderne et performant pour construire des API RESTful avec Python. En s’appuyant sur la programmation asynchrone et la validation automatique des données, FastAPI vous permet de créer des API évolutives rapidement et efficacement. Dans ce tutoriel, vous apprendrez à créer une API réelle qui fournit des données sur les produits dans le cadre d’un scénario de commerce électronique. Nous couvrirons la création de points d’extrémité, la validation des entrées à l’aide des modèles Pydantic, l’exécution et le test de l’API, et l’exploration des stratégies de déploiement pour une API de niveau production.

Importation des paquets requis

Pour organiser notre code et éviter les répétitions, nous commençons par importer les paquets nécessaires. Cela permet de s’assurer que tous les blocs de code suivants ont accès aux bibliothèques nécessaires.

#|label: import-packages
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

Création d’une application FastAPI de base avec des exemples de données réelles

Nous allons commencer par initialiser une application FastAPI et créer des points de terminaison. Dans notre exemple, l’API servira des données de produits pour un scénario de commerce électronique.

Exemple d’API de base

#|label: create-app
app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Welcome to the FastAPI Products API!"}

class Product(BaseModel):
    id: int
    name: str
    price: float
    category: str

# Exemple de données produit.
products = [
    {"id": 1, "name": "Wireless Mouse", "price": 29.99, "category": "Electronics"},
    {"id": 2, "name": "Bluetooth Headphones", "price": 59.99, "category": "Electronics"},
    {"id": 3, "name": "Coffee Maker", "price": 79.99, "category": "Home Appliances"},
    {"id": 4, "name": "Electric Kettle", "price": 39.99, "category": "Home Appliances"},
    {"id": 5, "name": "Smartphone Stand", "price": 19.99, "category": "Accessories"}
]

@app.get("/api/products", response_model=list[Product])
def get_products():
    return products

if __name__ == "__main__":
    # Exécuter l'application sur le port 8000 avec le débogage activé.
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

Exécuter et tester l’API

Pour exécuter votre API Flask, exécutez votre script en utilisant par exemple python api.py.

Note

Une fois que votre API fonctionne, vous pouvez y accéder en visitant http://localhost:5000/ dans votre navigateur web.

Tester votre API

Testez votre API en utilisant cURL ou Postman. Par exemple, vous pouvez exécuter les commandes suivantes dans votre terminal:

curl http://127.0.0.1:8000/
curl http://127.0.0.1:8000/api/products

Ces commandes devraient renvoyer des réponses JSON avec un message de bienvenue et les données du produit, respectivement.

Gestion des erreurs et validation des entrées

FastAPI utilise les modèles Pydantic pour valider les données d’entrée. En outre, une gestion appropriée des erreurs garantit que votre API répond de manière élégante aux demandes incorrectes.

Exemple : Point de terminaison amélioré avec validation

#|label: enhanced-endpoint
@app.get("/api/product/{product_id}", response_model=Product)
def get_product(product_id: int):
    for product in products:
        if product["id"] == product_id:
            return product
    raise HTTPException(status_code=404, detail="Product not found")

Ce point d’accès récupère un produit par son identifiant, et si le produit n’est pas trouvé, il génère une erreur 404.

Stratégies de déploiement

Pour un déploiement en production, considérez les stratégies suivantes:

Uvicorn avec Gunicorn:
Déployez votre application FastAPI en utilisant Gunicorn avec des travailleurs Uvicorn pour améliorer les performances:
```
gunicorn --workers 4 --worker-class uvicorn.workers.UvicornWorker --bind 0.0.0.0:8000 your_script:app
```
Conteneurisation:
Utilisez Docker pour conteneuriser votre application. Un exemple de fichier Docker est présenté ci-dessous.

Exemple de fichier Docker

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt requirements.txt
RUN pip install -r requirements.txt
COPY . .
CMD ["gunicorn", "--workers", "4", "--worker-class", "uvicorn.workers.UvicornWorker", "--bind", "0.0.0.0:8000", "your_script:app"]

Remplacez your_script par le nom de votre fichier Python contenant l’application FastAPI.

Exécution et test de l’API (récapitulatif)

Une fois l’API déployée, utilisez des outils tels que cURL, Postman ou des cadres de test automatisés pour vérifier vos points de terminaison et vous assurer que votre API se comporte comme prévu en production.

Conclusion

FastAPI fournit un cadre moderne, efficace et facile à utiliser pour construire des API RESTful en Python. En suivant ce guide, vous avez appris à créer une API réelle avec des données de produits, à mettre en œuvre la validation des entrées et la gestion des erreurs, et à explorer les stratégies de déploiement pour les applications de niveau production. Avec ces compétences, vous pouvez créer des API évolutives qui alimentent les applications Web modernes et les services axés sur les données.

Plus d’informations

Bon codage, et profitez de la construction et du déploiement de votre API RESTful avec FastAPI!

Explorer d’autres articles

Note

Voici d’autres articles de la même catégorie pour vous aider à approfondir le sujet.

Récupération de données sur le Web avec BeautifulSoup

Un guide pratique sur l'extraction de données à partir de sites web