Comprendre les principes fondamentaux de FastAPI : un guide sur FastAPI, Uvicorn, Starlette, Swagger UI et Pydantic

FastAPI est un framework Web moderne et performant pour créer des API avec Python, permettant aux développeurs de créer des applications puissantes et efficaces avec un minimum d'effort. Il est conçu avec une programmation asynchrone à l'esprit, ce qui le rend extrêmement rapide et capable de gérer plusieurs requêtes simultanément. Les composants clés qui alimentent FastAPI incluent Uvicorn, Starlette, Swagger UI et Pydantic. Dans ce guide, nous explorerons chacun de ces composants et verrons comment ils s'assemblent dans FastAPI, avec des exemples de code pour démontrer les concepts clés.

---

1. Le cœur de FastAPI

FastAPI repose sur deux fondations majeures :

• Programmation asynchrone : en tirant parti des fonctions async et wait de Python, FastAPI peut gérer de nombreuses requêtes en même temps, ce qui le rend efficace pour les applications nécessitant une simultanéité.
• Annotations de type : FastAPI utilise les indications de type de Python pour valider et sérialiser automatiquement les données de requête et de réponse, ce qui rend le développement plus rapide et plus sûr.

Commençons par une simple application FastAPI pour avoir une idée de sa structure :

# main.py

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def read_root():
    return {"Hello": "World"}

Il s'agit d'une application FastAPI de base avec une seule route (/) qui renvoie une réponse JSON avec {"Hello": "World"}.

Pour exécuter cette application, vous utiliserez Uvicorn, un serveur ASGI conçu pour servir des applications Web asynchrones.

---

2. Uvicorn : Le serveur ASGI

Uvicorn est un serveur ASGI ultra-rapide, optimisé pour la gestion du code asynchrone. Il est essentiel pour exécuter des applications FastAPI car il gère les requêtes HTTP entrantes et gère le cycle de vie de ces requêtes.

Pour exécuter votre application FastAPI avec Uvicorn, utilisez la commande suivante :

uvicorn main:app --reload

• main:app spécifie qu'Uvicorn doit rechercher une instance d'application dans le fichier main.py.
• --reload permet le rechargement à chaud pendant le développement, de sorte que le serveur se recharge automatiquement chaque fois que vous enregistrez les modifications.

Lorsque vous exécutez cette commande, Uvicorn commencera à servir votre application FastAPI et vous pourrez y accéder à l'adresse http://127.0.0.1:8000.

---

3. Starlette : la fondation Web Framework de FastAPI

FastAPI est construit sur Starlette, un framework ASGI léger qui gère les opérations HTTP de base, y compris la prise en charge du routage, du middleware et des WebSockets. Starlette fournit les outils de bas niveau que FastAPI utilise pour gérer les requêtes HTTP, ce qui en fait une base stable et performante pour la création d'applications Web.

FastAPI exploite le système de routage de Starlette pour définir les points de terminaison de l'API. Par exemple :

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    return {"item_id": item_id}

Dans cet exemple :

• @app.get("/items/{item_id}") définit une route avec un paramètre de chemin item_id.
• FastAPI gère ce type de paramètre de chemin (int ici) en intégrant le système de routage de Starlette avec sa vérification et sa validation de type.

Starlette permet également d'ajouter un middleware pour diverses opérations, comme la gestion du CORS (Cross-Origin Resource Sharing), la journalisation des requêtes ou l'authentification personnalisée :

# main.py

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def read_root():
    return {"Hello": "World"}

Cette flexibilité de Starlette rend FastAPI hautement configurable, permettant aux développeurs d'ajouter facilement des middlewares personnalisés selon leurs besoins.

---

4. Interface utilisateur Swagger : documentation interactive de l'API

FastAPI génère automatiquement une documentation API interactive avec Swagger UI. Cette documentation est disponible par défaut dans /docs et permet aux développeurs de tester les points de terminaison directement depuis le navigateur.

Pour voir cela en action, démarrez votre application FastAPI et visitez http://127.0.0.1:8000/docs. Vous verrez une interface utilisateur Swagger interactive qui répertorie tous vos itinéraires, leurs paramètres et les réponses attendues.

Une autre interface de documentation, ReDoc, est également fournie par défaut dans /redoc, offrant une vue plus détaillée des spécifications de l'API.

---

5. Pydantic : validation et sérialisation des données

L'un des aspects les plus puissants de FastAPI est son utilisation de Pydantic pour la validation des données. Les modèles Pydantic vous permettent de définir la structure des données de requête et de réponse avec des contraintes de type strictes et une validation automatique.

Ajoutons un modèle Pydantic à notre exemple :

uvicorn main:app --reload

Dans ce code :

• Le modèle Item hérite de BaseModel et définit trois champs : nom, prix et is_offer. Ces champs ont des types de données spécifiques et une valeur par défaut facultative pour is_offer.
• Lorsque vous envoyez une requête à /items/{item_id} avec des données JSON, FastAPI utilise Pydantic pour valider les données par rapport au modèle Item, en convertissant automatiquement les types de données si possible.

Essayez d'envoyer une demande comme celle-ci en utilisant l'interface utilisateur Swagger à l'adresse /docs :

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    return {"item_id": item_id}

FastAPI validera les données et renverra automatiquement toute erreur si les données ne correspondent pas aux types attendus. Par exemple, si le prix est donné sous forme de chaîne (comme « vingt »), FastAPI répondra avec une erreur de validation détaillée.

---

6. Rassembler tout cela

Développons notre application en ajoutant plus d'itinéraires et en combinant tout ce que nous avons appris jusqu'à présent :

from starlette.middleware.cors import CORSMiddleware

app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

Avec cette configuration :

• Routage et gestion des paramètres : le point de terminaison @app.get("/items/{item_id}") illustre les paramètres de chemin et les paramètres de requête (par exemple, q).
• Gestion des exceptions : utilisation de HTTPException pour les réponses d'erreur personnalisées (par exemple, lorsqu'un élément n'est pas trouvé).
• CORS : le middleware CORS vous permet d'effectuer des requêtes à partir de différents domaines, ce qui est crucial pour la communication frontend-backend dans les applications Web.

---

Exécution de l'application

Pour exécuter cette application, utilisez Uvicorn :

# main.py

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def read_root():
    return {"Hello": "World"}

Accédez à http://127.0.0.1:8000/docs pour voir la documentation interactive, ou utilisez un outil tel que cURL ou Postman pour envoyer des requêtes aux différents points de terminaison.

---

Résumé

FastAPI combine les avantages en termes de performances de la programmation asynchrone avec la simplicité des astuces de type Python pour créer un framework rapide, facile à utiliser et adapté aux applications de production. En intégrant Uvicorn, Starlette, Swagger UI et Pydantic, FastAPI offre une approche incroyablement rationalisée du développement d'API, ce qui en fait un excellent choix pour les applications de prototypage rapide et de production.

Une fois ces principes fondamentaux en place, vous êtes désormais équipé pour plonger plus profondément dans le monde de FastAPI et créer des applications évolutives et hautes performances.

Référence

1. Documentation FastAPI
2. Documentation Uvicorn
3. Documentation Starlette
4. Documentation Pydantique
5. Documentation de l'interface utilisateur Swagger

---

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!