🚀 FastAPI – Installation, Syntaxe & Déploiement

FastAPI = Starlette + Pydantic

FastAPI n'a pas réinventé la roue. Il combine intelligemment deux librairies :

1. Starlette (Le Moteur) : Un micro-framework ASGI (Asynchronous Server Gateway Interface) léger et très rapide. Il gère le routage, les middlewares, et les requêtes/réponses asynchrones.
2. Pydantic (La Validation) : Une librairie qui utilise les "type hints" Python (ex: name: str) pour valider, sérialiser et parser les données (ex: JSON).

Uvicorn (Le Serveur)

Un serveur web ASGI (comme Gunicorn pour WSGI). C'est lui qui exécute l'application FastAPI.

Schéma de la Stack

[Image d'une architecture ASGI]

+--------------------------------------+
| Internet (Requête HTTP)              |
+--------------------------------------+
                   |
                   ▼
+--------------------------------------+
| Serveur ASGI (ex: Uvicorn, Gunicorn) |
| (Gère les connexions)                |
+--------------------------------------+
                   |
                   ▼
+--------------------------------------+
| Starlette (Routage, Async)           |  <-- (FastAPI)
+--------------------------------------+
                   |
                   ▼
+--------------------------------------+
| Pydantic (Validation des données)    |  <-- (FastAPI)
+--------------------------------------+
                   |
                   ▼
+--------------------------------------+
| Votre Code Applicatif                |
| (ex: main.py, @app.get(...))         |
+--------------------------------------+

main.py

from fastapi import FastAPI

# 1. Créer l'instance de l'application
app = FastAPI()

# 2. Définir une "route" avec un "décorateur"
# @app.get -> Opération (GET)
# "/" -> Path (URL)
@app.get("/")
def read_root():
    # 3. Ce que retourne la fonction (dict, list, str, int)
    #    est automatiquement converti en JSON.
    return {"message": "Hello, IDEO-Lab!"}

@app.get("/test")
def read_test():
    return {"status": "ok"}

Lancement

uvicorn main:app --reload

Résultat (via curl ou navigateur)

$ curl http://127.0.0.1:8000/
{"message":"Hello, IDEO-Lab!"}

$ curl http://127.0.0.1:8000/test
{"status":"ok"}

La validation par les types

Pydantic est la librairie de validation de données au cœur de FastAPI. Vous définissez la "forme" (shape) de vos données en créant une classe qui hérite de BaseModel.

FastAPI utilise ces modèles pour :

• Valider les requêtes entrantes (Request Body).
• Sérialiser les réponses sortantes (Response Model).
• Générer la documentation OpenAPI (Swagger/ReDoc).

Exemple : schemas.py

from pydantic import BaseModel
from typing import Optional, List
from datetime import datetime

class Tag(BaseModel):
    id: int
    name: str

class Article(BaseModel):
    # Champ requis
    titre: str
    
    # Champ requis (type complexe)
    auteur_id: int
    
    # Champ optionnel (défaut: None)
    description: Optional[str] = None
    
    # Champ avec valeur par défaut
    publie: bool = False
    
    # Champ avec type complexe (Liste)
    tags: List[str] = []
    
    # Champ avec type imbriqué
    # (Pydantic gère les modèles imbriqués)
    tag_objets: List[Tag] = []
    
    # Exemple de config (ex: pour l'ORM)
    class Config:
        orm_mode = True

Génération automatique

C'est la fonctionnalité "magique" de FastAPI. En se basant sur vos décorateurs (@app.get), vos "type hints" (item_id: int) et vos modèles Pydantic (item: Article), FastAPI génère un schéma OpenAPI 3.

Il expose ensuite ce schéma via deux interfaces web :

1. Swagger UI (/docs)

URL : http://127.0.0.1:8000/docs

Une interface interactive. Vous pouvez voir tous vos endpoints, leurs paramètres, leurs réponses, et même les tester directement depuis le navigateur.

2. ReDoc (/redoc)

URL : http://127.0.0.1:8000/redoc

Une interface de documentation statique (non-interactive), plus propre pour la lecture seule.

Personnalisation

app = FastAPI(
    title="IDEO-Lab API",
    description="L'API officielle pour IDEO-Lab",
    version="1.0.0"
)

@app.post(
    "/articles/",
    response_model=ArticleDB,
    tags=["Articles"], // Regroupe dans Swagger
    summary="Crée un nouvel article"
)
async def create_article(article_in: ArticleInput):
    ...

HTTPException

Pour retourner une réponse d'erreur HTTP (4xx, 5xx), le plus simple est de lever (raise) une HTTPException.

FastAPI l'interceptera et la convertira en une réponse JSON propre.

from fastapi import FastAPI, HTTPException

app = FastAPI()

items_db = {1: "Item A", 2: "Item B"}

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    
    if item_id not in items_db:
        # Lever l'exception
        raise HTTPException(
            status_code=404,
            detail="Article non trouvé",
            headers={"X-Error": "ID Inconnu"}
        )
        
    return {"item": items_db[item_id]}

Appel

$ curl http://127.0.0.1:8000/items/99
{
  "detail": "Article non trouvé"
}
# (Le statut HTTP sera 404)

Gestionnaires d'exceptions (Avancé)

Vous pouvez intercepter des erreurs spécifiques (ex: erreur BDD) pour retourner une réponse 500 propre.

from fastapi.responses import JSONResponse
from fastapi import Request

class MaSuperErreur(Exception):
    pass

@app.exception_handler(MaSuperErreur)
async def mon_gestionnaire_erreur(req: Request, exc: MaSuperErreur):
    return JSONResponse(
        status_code=418,
        content={"message": "J'ai attrapé une erreur custom !"}
    )

async def

FastAPI est basé sur ASGI, il supporte donc nativement les fonctions "coroutines" (async def).

Quand l'utiliser ?
Utilisez async def si votre fonction contient une opération d'I/O (Entrée/Sortie) lente et asynchrone.
Ex: await (attendre) une requête BDD (async), await une API externe (async), await asyncio.sleep().

Quand ne PAS l'utiliser ?
Si votre fonction fait juste du calcul CPU (ex: crunching de nombres) ou utilise une librairie I/O *bloquante* (ex: requests standard), utilisez def normal.

Exemple

import asyncio
from fastapi import FastAPI
app = FastAPI()

# Fonction 'def' (Synchrone)
# (Bloque le worker pendant 5s)
@app.get("/sync")
def route_sync():
    time.sleep(5) # Bloquant !
    return {"message": "Sync terminé"}

# Fonction 'async def' (Asynchrone)
# (Libère le worker pendant 5s)
@app.get("/async")
async def route_async():
    # 'await' cède le contrôle au serveur,
    # qui peut traiter d'autres requêtes.
    await asyncio.sleep(5) # Non-bloquant !
    return {"message": "Async terminé"}

Middleware

Un Middleware est une fonction qui s'exécute sur **chaque requête** *avant* qu'elle n'atteigne votre route (et sur chaque réponse *après*).

Utile pour : Logs, CORS, Gzip, gestion d'erreurs globales.

CORS (Cross-Origin Resource Sharing)

Problème : Par défaut, un navigateur n'autorise pas un frontend (http://mon-site-react.com) à appeler une API (http://mon-api.com).

Solution : L'API doit envoyer des headers HTTP (ex: Access-Control-Allow-Origin) pour autoriser le frontend. FastAPI gère cela avec CORSMiddleware.

from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware

app = FastAPI()

# Liste des "origines" (frontends) autorisées
origins = [
    "http://localhost:3000", // React local
    "http://localhost:8080", // Vue local
    "https://mon-site-react.com",
]

app.add_middleware(
    CORSMiddleware,
    allow_origins=origins, // Les sites autorisés
    allow_credentials=True,
    allow_methods=["*"], // (GET, POST, etc.)
    allow_headers=["*"],
)

@app.get("/")
def root():
    return {"message": "ok"}

Commandes

# Installation
pip install fastapi "uvicorn[standard]"

# Lancement (Dev)
uvicorn main:app --reload

# Lancement (Prod)
gunicorn -w 4 -k uvicorn.workers.UvicornWorker main:app

Décorateurs

from fastapi import FastAPI
app = FastAPI()

@app.get("/")
@app.post("/")
@app.put("/{item_id}")
@app.delete("/{item_id}")
@app.patch("/{item_id}")

Paramètres (from fastapi import ...)

# Path (ex: /items/{item_id})
def f(item_id: int): ...

# Query (ex: /items/?q=test)
def f(q: Optional[str] = None): ...

# Body (ex: POST /items)
from pydantic import BaseModel
class Item(BaseModel):
    name: str
def f(item: Item): ...

# Validation
from fastapi import Path, Query
def f(
    item_id: int = Path(..., gt=0),
    q: str = Query(None, max_length=10)
): ...

# Dépendances
from fastapi import Depends
def get_db(): ...
def f(db: Session = Depends(get_db)): ...

# Erreurs
from fastapi import HTTPException
raise HTTPException(status_code=404, detail="Not found")