Les routes (endpoints Fast API)

Dans FastAPI, une route est l’URL que votre application expose et à laquelle les clients (navigateurs, applications mobiles, ou autres services) peuvent envoyer des requêtes.

Chaque route correspond généralement à une fonction Python qui traite la requête et renvoie une réponse.

Comment ça fonctionne ?

FastAPI utilise des décorateurs comme @app.get(), @app.post(), @app.put(), @app.delete() pour lier une URL à une fonction.

Quand un client envoie une requête à cette URL, FastAPI appelle la fonction correspondante.

La fonction retourne une réponse HTTP, qui peut être du texte, du JSON ou même un rendu HTML.

Exemple conceptuel (sans code concret)

Ici, l’endpoint /users est associé à une fonction qui définit la logique pour cette route.

Méthodes HTTP et endpoints

Chaque route peut accepter une ou plusieurs méthodes HTTP :

Pourquoi c’est important :

Variables dans les routes

FastAPI permet de définir des routes dynamiques avec des variables dans l’URL :

Exemple conceptuel : /users/{id}

Avantage pédagogique :

Retour d’une route

Une fonction associée à une route retourne généralement :

Pourquoi c’est fondamental :

Bonnes pratiques pour les routes FastAPI

En résumé, dans FastAPI :

Fonctions :

  • Routes FastAPI (exemple)

    Exemple de code :

    from fastapi import FastAPI
from pydantic import BaseModel

# 1️⃣ Création de l'application FastAPI
app = FastAPI()

# 2️⃣ Route principale (GET)
@app.get("/")
def read_root():
    return {"message": "Bienvenue sur la page d'accueil !"}

# 3️⃣ Route avec paramètre dynamique
@app.get("/user/{username}")
def read_user(username: str):
    return {"message": f"Bonjour, {username} !"}

# 4️⃣ Route avec paramètre numérique
@app.get("/post/{post_id}")
def read_post(post_id: int):
    return {"post_id": post_id, "message": f"Vous consultez l'article #{post_id}"}

# 5️⃣ Route POST avec modèle de données
class Item(BaseModel):
    name: str
    price: float
    description: str = None

@app.post("/items/")
def create_item(item: Item):
    return {"message": "Article créé avec succès", "item": item}

    Explication du code :

    from fastapi import FastAPI importe la classe FastAPI, qui permet de créer l’application web ou API en Python.
     
    from pydantic import BaseModel importe BaseModel de Pydantic, utilisé pour définir et valider des modèles de données.
     
    app = FastAPI() crée une instance de l’application FastAPI.
    

    Route principale (GET)
     
    @app.get("/") définit une route accessible via une requête GET à http://127.0.0.1:8000/.
     def read_root(): définit la fonction exécutée quand cette route est visitée.
     return {"message": "Bienvenue sur la page d'accueil !"} renvoie un dictionnaire JSON comme réponse.
    

    Route avec paramètre dynamique (chaîne)
     
    @app.get("/user/{username}") capture une valeur dans l’URL (exemple : /user/Alice).
     username: str précise que le paramètre est une chaîne de caractères.
     return {"message": f"Bonjour, {username} !"} renvoie une réponse personnalisée selon le nom fourni dans l’URL.
    

    Route avec paramètre numérique
     
    @app.get("/post/{post_id}") définit une route qui prend un entier dans l’URL (exemple : /post/42).
     post_id: int précise que le paramètre doit être un entier.
     return {"post_id": post_id, "message": f"Vous consultez l'article #{post_id}"} renvoie un dictionnaire JSON incluant le numéro de l’article et un message.
    

    Route POST avec modèle de données
     
    class Item(BaseModel): crée un modèle de données avec Pydantic.
     Les attributs name: str, price: float, et description: str = None définissent les champs attendus et leur type.
     @app.post("/items/") définit une route POST pour créer un nouvel objet.
     def create_item(item: Item): récupère automatiquement les données JSON envoyées dans la requête et les transforme en objet Item.
     return {"message": "Article créé avec succès", "item": item} renvoie la confirmation de création et les données reçues.