Débuter avec FastAPI
Pourquoi FastAPI ?
FastAPI est un cadre moderne et performant pour construire des API web en Python 3.7+ basées sur les types de données (type hints). C'est une alternative récente à d'autres frameworks populaires comme Django ou Flask, offrant une meilleure performance et une meilleure qualité de code grâce aux types de données.
Un cas d'usage concret : FastAPI est idéal pour développer des applications web rapides et scalables. Par exemple, si vous travaillez dans un environnement où la vitesse et l’efficacité sont essentielles, comme une application de chatbot ou une API de traitement de données en temps réel, FastAPI peut être la solution parfaite.
Prerequis
- Connaissance de base de Python 3.7+
- Connaissances en POO (Programmation Orientée Objet)
- Installation d'un éditeur de code (par exemple VSCode)
- Outils à installer :
- pip (pour gérer les packages Python)
- python (v3.7+)
Installation des dépendances :
pip install fastapi uvicorn
Concepts fondamentaux
1. Création d'une Application FastAPI
Un premier exemple simple de FastAPI peut être écrit comme suit :
## app.py
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"message": "Bienvenue sur mon API avec FastAPI"}
2. Définition des Routes
FastAPI utilise une syntaxe simple pour définir les routes de l'API. Voici un exemple :
## app.py
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
class Item(BaseModel):
name: str
description: str = None
price: float
tax: float = None
@app.post("/items/")
def create_item(item: Item):
return item
3. Gestion des Paramètres
FastAPI permet de définir des paramètres dans les routes :
## app.py
from fastapi import FastAPI, Path, Query
app = FastAPI()
@app.get("/items/{item_id}")
def read_item(item_id: int = Path(..., title="The ID of the item to get"), q: str = Query(None, min_length=3)):
return {"item_id": item_id, "q": q}
4. Sérialisation et Deserialisation
FastAPI gère automatiquement la sérialisation et la désérialisation des données JSON avec les types de données définis :
## app.py
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
class Item(BaseModel):
name: str
description: str = None
price: float
tax: float = None
@app.post("/items/")
def create_item(item: Item):
return item
Mise en pratique : Projet fil rouge
Création d'un Mini-Projet : Gestionnaire de Tâches
Étape 1 : Initialisation du Projet
Créer un nouveau dossier pour votre projet et initialiser un environnement virtuel :
mkdir task_manager
cd task_manager
python -m venv venv
source venv/bin/activate # Sous Windows, utilisez `venv\Scripts\activate`
Étape 2 : Installation des Dépendances
Installez FastAPI et Uvicorn :
pip install fastapi uvicorn
Étape 3 : Création du Fichier Principal
Créer un fichier main.py avec le code suivant :
## main.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
app = FastAPI()
class Task(BaseModel):
id: int
title: str
description: str = None
completed: bool = False
tasks_db = []
@app.post("/tasks/")
def create_task(task: Task):
tasks_db.append(task)
return task
@app.get("/tasks/{task_id}")
def read_task(task_id: int):
for task in tasks_db:
if task.id == task_id:
return task
raise HTTPException(status_code=404, detail="Task not found")
@app.put("/tasks/{task_id}")
def update_task(task_id: int, updated_task: Task):
for idx, task in enumerate(tasks_db):
if task.id == task_id:
tasks_db[idx] = updated_task
return updated_task
raise HTTPException(status_code=404, detail="Task not found")
@app.delete("/tasks/{task_id}")
def delete_task(task_id: int):
global tasks_db
tasks_db = [task for task in tasks_db if task.id != task_id]
return {"message": "Task deleted"}
Étape 4 : Exécution de l'API
Lancez le serveur avec Uvicorn :
uvicorn main:app --reload
Erreurs fréquentes et debugging
Erreur 1 : TypeError: object of type 'type' has no len()
Code incorrect :
## app.py
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"items": []}
Code correct :
## app.py
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
class Item(BaseModel):
name: str
description: str = None
price: float
tax: float = None
@app.get("/")
def read_root():
return {"items": []}
Erreur 2 : 1 validation error for Item
price field required
Code incorrect :
## app.py
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
class Item(BaseModel):
name: str
description: str = None
price: float = None
tax: float = None
@app.post("/items/")
def create_item(item: Item):
return item
Code correct :
## app.py
from fastapi import FastAPI
from pydantic import BaseModel, Field
app = FastAPI()
class Item(BaseModel):
name: str
description: str = None
price: float = Field(..., gt=0)
tax: float = None
@app.post("/items/")
def create_item(item: Item):
return item
Erreur 3 : HTTPException: HTTP error 422 Unprocessable entity
tax field required
Code incorrect :
## app.py
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
class Item(BaseModel):
name: str
description: str = None
price: float
tax: float = Field(..., gt=0)
@app.post("/items/")
def create_item(item: Item):
return item
Code correct :
## app.py
from fastapi import FastAPI
from pydantic import BaseModel, Field
app = FastAPI()
class Item(BaseModel):
name: str
description: str = None
price: float
tax: float = Field(None, gt=0)
@app.post("/items/")
def create_item(item: Item):
return item
Pour aller plus loin
- Intégration avec la base de données : Utiliser SQLAlchemy ou Tortoise ORM pour intégrer votre API avec une base de données.
- Ajout d'authentification et de sécurité : Utiliser OAuth2 ou JWT pour sécuriser votre API.
- Déploiement sur un serveur : Déployer votre application FastAPI sur un serveur cloud comme AWS, Google Cloud, ou Heroku.
Défi pratique
Créez une API simple pour gérer des utilisateurs avec les opérations CRUD (Create, Read, Update, Delete). Utilisez Pydantic pour la validation des données et SQLAlchemy pour la gestion de la base de données.