Migrer de Flask vers FastAPI

Pourquoi Migrer de Flask vers FastAPI ?

Le développement web est un domaine en constante évolution, et avec chaque nouveau langage ou framework qui apparaît, il est important de se poser la question : "Quelle est la meilleure solution pour mon projet ?". Un choix populaire aujourd'hui est d'utiliser FastAPI au lieu de Flask. En effet, FastAPI offre un ensemble de fonctionnalités plus récentes et plus puissantes qui simplifient le développement d'API modernes.

Le contexte du quotidien peut être tout aussi varié que l'évolution des technologies. Par exemple, si vous travaillez sur une application web avec une grande quantité de données à traiter en temps réel, vous pouvez trouver que Flask ne répond pas suffisamment bien aux besoins en termes de performance et d'efficacité. C'est là que FastAPI entre en jeu. Sa capacité à générer des APIs performantes est particulièrement utile pour les applications nécessitant une grande vitesse de réponse.

Prerequis

Pour suivre ce tutoriel, vous aurez besoin des éléments suivants :

• Python : Version 3.7 ou supérieure.
• FastAPI : Le framework que nous allons utiliser. Vous pouvez l'installer en utilisant pip :

pip install fastapi uvicorn

• Starlette : La librairie sous-jacente de FastAPI, vous ne devriez pas avoir besoin d'installer Starlette manuellement.
• Un environnement de développement Python comme PyCharm ou VSCode.

Concepts fondamentaux

1. Route et Path Parameter Les routes définissent comment les utilisateurs accèdent à vos API. Les path parameters sont des valeurs dynamiques qui peuvent être incluses dans l'URL.

from fastapi import FastAPI

app = FastAPI()

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

2. Query Parameters Les query parameters sont des paramètres passés dans la chaîne de requête URL.

from fastapi import FastAPI

app = FastAPI()

@app.get("/items/")
async def read_items(q: str = None):
    return {"q": q}

3. Request Body Les request bodies sont utilisés pour passer des données complexes, comme des objets JSON.

from fastapi import FastAPI

app = FastAPI()

@app.post("/items/")
async def create_item(item: dict):
    return item

4. Response Model Les response models sont des classes Pydantic qui définissent la structure de la réponse que votre API retourne.

from fastapi import FastAPI, Depends
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):
    name: str
    description: str = None
    price: float
    tax: float = None

@app.post("/items/")
async def create_item(item: Item):
    return item

5. Dependencies Les dépendances permettent de réutiliser du code entre les différentes parties de votre API.

from fastapi import FastAPI, Depends

app = FastAPI()

fake_items_db = [{"item_id": "Foo"}, {"item_id": "Bar"}]

async def common_parameters(q: str = None, skip: int = 0, limit: int = 10):
    return dict(q=q, skip=skip, limit=limit)

@app.get("/items/")
async def read_items(commons: dict = Depends(common_parameters)):
    response = fake_items_db[commons["skip"] : commons["skip"] + commons["limit"]]
    if commons["q"]:
        response = [item for item in response if commons["q"] in item["item_id"]]
    return {"items": response}

Mise en pratique : projet fil rouge

Nous allons créer un simple gestionnaire de tâches en utilisant FastAPI. Ce projet comprendra les fonctionnalités suivantes :

1. Ajouter une tâche
2. Lister toutes les tâches
3. Supprimer une tâche

Étape 1 : Création du fichier principal

Créez un fichier main.py avec le contenu suivant :

from fastapi import FastAPI, HTTPException

app = FastAPI()

## Base de données simulée
tasks_db = {}

@app.post("/tasks/")
async def create_task(task: dict):
    task_id = len(tasks_db) + 1
    tasks_db[task_id] = task
    return {"task_id": task_id, **task}

@app.get("/tasks/")
async def list_tasks():
    return list(tasks_db.values())

@app.delete("/tasks/{task_id}")
async def delete_task(task_id: int):
    if task_id not in tasks_db:
        raise HTTPException(status_code=404, detail="Task not found")
    del tasks_db[task_id]
    return {"message": "Task deleted"}

Étape 2 : Installation des dépendances

Assurez-vous d'avoir installé les dépendances nécessaires :

pip install fastapi uvicorn

Étape 3 : Exécution de l'API

Vous pouvez exécuter votre API avec la commande suivante :

uvicorn main:app --reload

Allez sur http://127.0.0.1:8000/docs pour accéder à l'interface interactive de FastAPI.

Erreurs frequentes et debugging

Voici quelques erreurs courantes que vous pouvez rencontrer lors de la migration vers FastAPI :

1. Erreur : HTTPException not imported Si vous obtenez une erreur indiquant que HTTPException n'est pas importé, assurez-vous d'importer correctement :

from fastapi import HTTPException

2. Erreur : PydanticTypeError : Type not allowed for field Si FastAPI bloque une certaine structure de données avec un message similaire, vérifiez que vous utilisez les types Pydantic corrects.

3. Erreur : Depends error in function Si vous rencontrez une erreur liée aux dépendances, assurez-vous que la fonction dépendante est bien définie et qu'elle retourne le bon type de données.

Pour aller plus loin

1. Utiliser les Asynchronous Database Operations avec SQLAlchemy : Apprenez à gérer des opérations de base de données asynchrones en utilisant SQLAlchemy.
2. Intégrer un système d'authentification : Utilisez FastAPI pour ajouter une authentification basique ou OAuth 2.0 à votre API.
3. Gestion des erreurs et des exceptions de manière plus robuste : Apprenez à gérer les exceptions en utilisant des blocs try/except et des classes personnalisées.

Défi pratique

Tentez d'ajouter une fonctionnalité supplémentaire à votre gestionnaire de tâches, par exemple, la mise à jour d'une tâche existante.