Crée ton API REST avec FastAPI et Python

Pourquoi créer une API REST avec FastAPI ?

Tu développes en Python et tu souhaites exposer ton code sous forme d’API ? Que ce soit pour alimenter une application mobile, connecter un chatbot, ou simplement structurer ton backend, les API REST sont devenues le standard incontournable du développement web moderne.

FastAPI est un framework Python récent (2018) qui a rapidement conquis les développeurs grâce à sa simplicité, ses performances et sa documentation automatique. Dans ce tutoriel pas à pas, tu vas construire ta première API REST complète, de l’installation jusqu’au déploiement.

Qu’est-ce qu’une API REST ?

Une API (Application Programming Interface) REST permet à deux applications de communiquer via le protocole HTTP. Concrètement, ton serveur expose des endpoints (des URLs) que les clients peuvent appeler pour lire, créer, modifier ou supprimer des données.

Les verbes HTTP les plus courants sont :

• GET — récupérer des données (ex: liste des articles)
• POST — créer une nouvelle ressource
• PUT — mettre à jour une ressource existante
• DELETE — supprimer une ressource

Imagine un livreur qui consulte une API pour connaître sa prochaine livraison : il appelle GET /livraisons/123 et reçoit les détails en JSON. C’est aussi simple que ça.

Pourquoi choisir FastAPI ?

FastAPI se distingue des autres frameworks Python (Flask, Django REST Framework) pour plusieurs raisons :

• Performance — il rivalise avec Node.js et Go grâce à son moteur asynchrone basé sur Starlette
• Validation automatique — les types Python (Pydantic) valident tes données sans effort supplémentaire
• Documentation interactive — Swagger UI et ReDoc sont générés automatiquement
• Async natif — idéal pour les appels à des API externes ou des bases de données

Installation et configuration

Commence par créer un environnement virtuel et installer FastAPI :

python3 -m venv venv
source venv/bin/activate
pip install fastapi uvicorn

Uvicorn est le serveur ASGI qui fera tourner ton application. Une fois installé, crée un fichier main.py :

from fastapi import FastAPI

app = FastAPI(title="Mon API")

@app.get("/")
def lire_racine():
    return {"message": "Bienvenue sur mon API !"}

Lance le serveur avec :

uvicorn main:app --reload

Ouvre ton navigateur sur http://localhost:8000 et tu verras ton premier endpoint en action. Accède à /docs pour découvrir la documentation Swagger générée automatiquement — tu peux même tester tes endpoints directement depuis l’interface.

Créer ton premier endpoint CRUD

Passons à quelque chose de concret : une API de gestion de tâches (to-do list). Voici le modèle de données et les endpoints :

from fastapi import FastAPI
from pydantic import BaseModel
from typing import Optional

app = FastAPI(title="Gestionnaire de tâches")

class Tache(BaseModel):
    titre: str
    description: Optional[str] = None
    terminee: bool = False

taches_db = []
compteur = 1

@app.post("/taches")
def creer_tache(tache: Tache):
    global compteur
    tache_dict = tache.model_dump()
    tache_dict["id"] = compteur
    compteur += 1
    taches_db.append(tache_dict)
    return tache_dict

@app.get("/taches")
def lister_taches():
    return taches_db

@app.get("/taches/{tache_id}")
def lire_tache(tache_id: int):
    for t in taches_db:
        if t["id"] == tache_id:
            return t
    return {"erreur": "Tâche introuvable"}

@app.put("/taches/{tache_id}")
def modifier_tache(tache_id: int, tache: Tache):
    for i, t in enumerate(taches_db):
        if t["id"] == tache_id:
            taches_db[i] = {"id": tache_id, **tache.model_dump()}
            return taches_db[i]
    return {"erreur": "Tâche introuvable"}

@app.delete("/taches/{tache_id}")
def supprimer_tache(tache_id: int):
    for i, t in enumerate(taches_db):
        if t["id"] == tache_id:
            taches_db.pop(i)
            return {"message": "Tâche supprimée"}
    return {"erreur": "Tâche introuvable"}

Ajouter une base de données avec SQLite

Pour le moment, les données sont stockées en mémoire et disparaissent au redémarrage. Ajoutons SQLite avec SQLAlchemy :

pip install sqlalchemy databases

Crée un fichier database.py :

from sqlalchemy import create_engine, Column, Integer, String, Boolean
from sqlalchemy.orm import declarative_base, Session

Base = declarative_base()
engine = create_engine("sqlite:///./taches.db")
Base.metadata.create_all(bind=engine)

class TacheDB(Base):
    __tablename__ = "taches"
    id = Column(Integer, primary_key=True, index=True)
    titre = Column(String, nullable=False)
    description = Column(String, default="")
    terminee = Column(Boolean, default=False)

Ensuite, modifie ton main.py pour utiliser la base de données :

from fastapi import FastAPI, Depends
from sqlalchemy.orm import Session as DBSession
from database import TacheDB, engine, SessionLocal

app = FastAPI(title="API Tâches avec base de données")

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

@app.post("/taches")
def creer_tache(tache: Tache, db: DBSession = Depends(get_db)):
    db_tache = TacheDB(**tache.model_dump())
    db.add(db_tache)
    db.commit()
    db.refresh(db_tache)
    return db_tache

Les données persistent désormais entre les redémarrages du serveur.

Tester ton API

FastAPI génère automatiquement une interface Swagger à l’adresse /docs. Tu peux y tester chaque endpoint :

• Crée une tâche avec POST /taches
• Liste les tâches avec GET /taches
• Récupère une tâche spécifique avec GET /taches/1
• Modifie-la avec PUT /taches/1
• Supprime-la avec DELETE /taches/1

Tu peux aussi utiliser curl en ligne de commande :

curl -X POST "http://localhost:8000/taches" \
  -H "Content-Type: application/json" \
  -d '{"titre": "Apprendre FastAPI", "terminee": false}'

Et après ? Les prochaines étapes

Tu viens de construire une API REST complète avec FastAPI. Félicitations ! Voici quelques pistes pour aller plus loin :

• Ajoute l’authentification avec OAuth2 et JWT (FastAPI le supporte nativement)
• Déploie ton API sur un serveur (Railway, Render, ou un VPS avec Docker + Nginx)
• Ajoute des tests avec pytest et le client TestClient de FastAPI
• Connecte une base PostgreSQL pour passer en production
• Consulte la documentation officielle de FastAPI pour explorer toutes les fonctionnalités avancées

L’avantage de FastAPI, c’est que tu peux commencer petit et ajouter des fonctionnalités au fur et à mesure sans réécrire tout ton code. La courbe d’apprentissage est douce, mais le framework t’accompagne jusqu’à des architectures complexes.

FastAPI est un framework puissant, mais pour aller plus loin — authentification, déploiement, tests avancés — un guide fait toute la différence. Si tu veux apprendre à construire des APIs robustes avec un vrai suivi, je t’accompagne pas à pas dans mes formations. On travaille sur des projets concrets, du code clean, et tu repars avec des compétences directement exploitables.

Tu veux aller plus loin avec FastAPI et Python ? Découvre ma formation Python complète — du débutant au déploiement, avec un vrai suivi pas à pas.