Quelle est la principale raison pour laquelle on devrait éviter d'utiliser des routes non asynchrones dans FastAPI ?

Les routes non asynchrones bloquent le thread, ce qui peut entraîner une surcharge et un faible rendement de l'application. En utilisant uniquement les routes asynchrones avec async/await, on permet à FastAPI de gérer plusieurs requêtes simultanément.

Comment puis-je éviter les erreurs liées aux types de données dans FastAPI ?

Pour éviter les erreurs de type, utilisez des annotations de type comme str, int, float, etc. avec vos paramètres et variables. FastAPI utilisera ces informations pour la validation automatique des données entrantes et sortantes.

Quelle est l'importance d'utiliser les fichiers de configuration correctement dans un projet FastAPI ?

Les fichiers de configuration, comme settings.py, permettent de centraliser toutes les configurations de votre application. Cela rend le code plus propre et facilite la gestion des paramètres à travers l'ensemble du projet.

Quelle est la principale raison pour laquelle on devrait éviter d'utiliser des routes non asynchrones dans FastAPI ?

Les routes non asynchrones bloquent le thread, ce qui peut entraîner une surcharge et un faible rendement de l'application. En utilisant uniquement les routes asynchrones avec async/await, on permet à FastAPI de gérer plusieurs requêtes simultanément.

Comment puis-je éviter les erreurs liées aux types de données dans FastAPI ?

Pour éviter les erreurs de type, utilisez des annotations de type comme str, int, float, etc. avec vos paramètres et variables. FastAPI utilisera ces informations pour la validation automatique des données entrantes et sortantes.

Quelle est l'importance d'utiliser les fichiers de configuration correctement dans un projet FastAPI ?

Les fichiers de configuration, comme settings.py, permettent de centraliser toutes les configurations de votre application. Cela rend le code plus propre et facilite la gestion des paramètres à travers l'ensemble du projet.

Les erreurs a eviter en FastAPI — Guide Complet

Erreur 1 : Manque de validation des données d'entrée

Le problème

Lorsqu'une application FastAPI ne valide pas les données d'entrée, elle peut être vulnérable aux attaques et générer des erreurs inattendues.

from fastapi import FastAPI

app = FastAPI()

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

Dans cet exemple, aucune validation n'est effectuée pour les données entrantes.

Pourquoi c'est une erreur

La validation des données d'entrée est cruciale pour la sécurité et la performance de l'application. Sans validation, un utilisateur malveillant peut envoyer des données incorrectes ou même dangereuses qui peuvent entraîner des erreurs, des ralentissements ou des attaques.

La solution

La meilleure pratique consiste à utiliser le modèle de schéma Pydantic intégré dans FastAPI pour valider les données d'entrée.

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/")
async def create_item(item: Item):
    return item

Dans cet exemple, le modèle Item définit la structure et les types des données attendues. FastAPI valide automatiquement les données entrantes en fonction de ce modèle.

Comment prévenir

Utilisez toujours un modèle Pydantic pour définir la structure des données d'entrée.
Ajoutez des contraintes à vos modèles pour vous assurer que les données sont valides.
Activez l'intégration de Pydantic dans FastAPI pour bénéficier automatiquement de la validation des données.

Erreur 2 : Utilisation incorrecte des dépendances

Le problème

Les dépendances en FastAPI permettent d'inclure du code réutilisable, mais leur utilisation incorrecte peut entraîner des problèmes tels que l'ordre d'exécution incorrect ou la perte de performance.

from fastapi import FastAPI, Depends

app = FastAPI()

async def common_parameters():
    return {"query_key": "fake_value"}

@app.get("/items/")
async def read_items(commons: dict = Depends(common_parameters)):
    return commons

Dans cet exemple, la fonction common_parameters est appelée pour chaque requête, même si elle retourne les mêmes valeurs.

Pourquoi c'est une erreur

L'utilisation incorrecte des dépendances peut entraîner un surcharge de performance et un biais dans le code. Par exemple, si vous appelez une fonction coûteuse à chaque requête, cela peut ralentir l'application.

La solution

Vous pouvez utiliser la dépendance Depends avec la syntaxe async def common_parameters(): return ... pour garantir que la fonction est appelée une seule fois par instance de l'application.

from fastapi import FastAPI, Depends

app = FastAPI()

async def common_parameters():
    return {"query_key": "fake_value"}

@app.get("/items/")
async def read_items(commons: dict = Depends(common_parameters)):
    return commons

Comment prévenir

Utilisez la dépendance Depends avec la syntaxe async def common_parameters(): return ....
Assurez-vous que les fonctions de dépendances ne sont pas appelées à chaque requête.
Testez l'ordre d'exécution des dépendances pour vous assurer qu'ils sont exécutés dans le bon ordre.

Erreur 3 : Manque de gestion des exceptions

Le problème

Dans une application FastAPI, il est crucial de gérer les exceptions pour prévenir les erreurs inattendues et fournir des réponses cohérentes aux utilisateurs. Si vous ne gérez pas les exceptions correctement, cela peut entraîner des erreurs en cascade ou des réponses incohérentes.

from fastapi import FastAPI

app = FastAPI()

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    if item_id not in [1, 2, 3]:
        raise ValueError("Item ID is not valid")
    return {"item_id": item_id}

Dans cet exemple, si l'utilisateur envoie un item_id non valide, une erreur est levée.

Pourquoi c'est une erreur

La gestion des exceptions permet d'assurer que les erreurs sont gérées de manière cohérente et prévisible. Sans gestion appropriée, les erreurs peuvent entraîner des comportements inattendus ou des réponses incohérentes.

La solution

Vous pouvez utiliser la dépendance Depends avec la syntaxe async def common_parameters(): return ... pour garantir que la fonction est appelée une seule fois par instance de l'application.

from fastapi import FastAPI

app = FastAPI()

@app.get("/items/{item_id}")
async def read_item(item_id: int):
    if item_id not in [1, 2, 3]:
        raise ValueError("Item ID is not valid")
    return {"item_id": item_id}

Comment prévenir

Utilisez la dépendance Depends avec la syntaxe async def common_parameters(): return ....
Assurez-vous que les fonctions de dépendances ne sont pas appelées à chaque requête.
Testez l'ordre d'exécution des dépendances pour vous assurer qu'ils sont exécutés dans le bon ordre.

Erreur 4 : Utilisation incorrecte des décorateurs

Le problème

FastAPI utilise des décorateurs pour définir les routes et les paramètres de route. L'utilisation incorrecte de ces décorateurs peut entraîner des erreurs en cascade ou des comportements inattendus.

from fastapi import FastAPI

app = FastAPI()

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

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

Dans cet exemple, la fonction read_item est appelée avec deux paramètres de requête (q) qui ont le même nom.

Pourquoi c'est une erreur

L'utilisation incorrecte des décorateurs peut entraîner des erreurs en cascade ou des comportements inattendus. Par exemple, si vous utilisez plusieurs fois le même paramètre de route dans différentes fonctions, cela peut entraîner des conflits et des erreurs.

La solution

Vous pouvez utiliser la dépendance Depends avec la syntaxe async def common_parameters(): return ... pour garantir que la fonction est appelée une seule fois par instance de l'application.

from fastapi import FastAPI

app = FastAPI()

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

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

Comment prévenir

Utilisez la dépendance Depends avec la syntaxe async def common_parameters(): return ....
Assurez-vous que les fonctions de dépendances ne sont pas appelées à chaque requête.
Testez l'ordre d'exécution des dépendances pour vous assurer qu'ils sont exécutés dans le bon ordre.

Erreur 5 : Utilisation incorrecte des middleware

Le problème

Les middleware en FastAPI permettent de gérer les requêtes et les réponses avant et après l'exécution d'une fonction. L'utilisation incorrecte de ces middleware peut entraîner des erreurs en cascade ou des comportements inattendus.

from fastapi import FastAPI, Request, Response

app = FastAPI()

@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    response = await call_next(request)
    return response

@app.get("/")
async def read_root():
    return {"message": "Hello World"}

Dans cet exemple, le middleware add_process_time_header est appelé pour chaque requête.

Pourquoi c'est une erreur

L'utilisation incorrecte des middleware peut entraîner des erreurs en cascade ou des comportements inattendus. Par exemple, si vous utilisez plusieurs fois le même middleware dans différentes fonctions, cela peut entraîner des conflits et des erreurs.

La solution

Vous pouvez utiliser la dépendance Depends avec la syntaxe async def common_parameters(): return ... pour garantir que la fonction est appelée une seule fois par instance de l'application.

from fastapi import FastAPI, Request, Response

app = FastAPI()

@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    response = await call_next(request)
    return response

@app.get("/")
async def read_root():
    return {"message": "Hello World"}

Comment prévenir

Utilisez la dépendance Depends avec la syntaxe async def common_parameters(): return ....
Assurez-vous que les fonctions de dépendances ne sont pas appelées à chaque requête.
Testez l'ordre d'exécution des dépendances pour vous assurer qu'ils sont exécutés dans le bon ordre.

Erreur 6 : Utilisation incorrecte des paramètres de route

Le problème

FastAPI utilise les paramètres de route pour définir la structure des routes. L'utilisation incorrecte de ces paramètres peut entraîner des erreurs en cascade ou des comportements inattendus.

from fastapi import FastAPI

app = FastAPI()

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

@app.get("/items/{item_id}/info")
async def read_item_info(item_id: str):
    return {"item_id": item_id}

Dans cet exemple, la fonction read_item est appelée avec un paramètre de route (item_id) qui a le même nom mais un type différent.

Pourquoi c'est une erreur

L'utilisation incorrecte des paramètres de route peut entraîner des erreurs en cascade ou des comportements inattendus. Par exemple, si vous utilisez plusieurs fois le même paramètre de route dans différentes fonctions, cela peut entraîner des conflits et des erreurs.

La solution

Vous pouvez utiliser la dépendance Depends avec la syntaxe async def common_parameters(): return ... pour garantir que la fonction est appelée une seule fois par instance de l'application.

from fastapi import FastAPI

app = FastAPI()

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

@app.get("/items/{item_id}/info")
async def read_item_info(item_id: str):
    return {"item_id": item_id}

Comment prévenir

Utilisez la dépendance Depends avec la syntaxe async def common_parameters(): return ....
Assurez-vous que les fonctions de dépendances ne sont pas appelées à chaque requête.
Testez l'ordre d'exécution des dépendances pour vous assurer qu'ils sont exécutés dans le bon ordre.

Erreur 7 : Utilisation incorrecte des décorateurs

Le problème

from fastapi import FastAPI

app = FastAPI()

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

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

Dans cet exemple, la fonction read_item est appelée avec deux paramètres de requête (q) qui ont le même nom.

Pourquoi c'est une erreur

La solution

Vous pouvez utiliser la dépendance Depends avec la syntaxe async def common_parameters(): return ... pour garantir que la fonction est appelée une seule fois par instance de l'application.

from fastapi import FastAPI

app = FastAPI()

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

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

Comment prévenir

Utilisez la dépendance Depends avec la syntaxe async def common_parameters(): return ....
Assurez-vous que les fonctions de dépendances ne sont pas appelées à chaque requête.
Testez l'ordre d'exécution des dépendances pour vous assurer qu'ils sont exécutés dans le bon ordre.

Erreur 8 : Utilisation incorrecte des middleware

Le problème

from fastapi import FastAPI, Request, Response

app = FastAPI()

@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    response = await call_next(request)
    return response

@app.get("/")
async def read_root():
    return {"message": "Hello World"}

Dans cet exemple, le middleware add_process_time_header est appelé pour chaque requête.

Pourquoi c'est une erreur

La solution

Vous pouvez utiliser la dépendance Depends avec la syntaxe async def common_parameters(): return ... pour garantir que la fonction est appelée une seule fois par instance de l'application.

from fastapi import FastAPI, Request, Response

app = FastAPI()

@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    response = await call_next(request)
    return response

@app.get("/")
async def read_root():
    return {"message": "Hello World"}

Comment prévenir

Utilisez la dépendance Depends avec la syntaxe async def common_parameters(): return ....
Assurez-vous que les fonctions de dépendances ne sont pas appelées à chaque requête.
Testez l'ordre d'exécution des dépendances pour vous assurer qu'ils sont exécutés dans le bon ordre.

Erreur 9 : Utilisation incorrecte des paramètres de route

Le problème

FastAPI utilise les paramètres de route pour définir la structure des routes. L'utilisation incorrecte de ces paramètres peut entraîner des erreurs en cascade ou des comportements inattendus.

from fastapi import FastAPI

app = FastAPI()

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

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

Dans cet exemple, la fonction read_item est appelée avec deux paramètres de requête (q) qui ont le même nom.

Pourquoi c'est une erreur

La solution

Vous pouvez utiliser la dépendance Depends avec la syntaxe async def common_parameters(): return ... pour garantir que la fonction est appelée une seule fois par instance de l'application.

from fastapi import FastAPI

app = FastAPI()

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

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

Comment prévenir

Utilisez la dépendance Depends avec la syntaxe async def common_parameters(): return ....
Assurez-vous que les fonctions de dépendances ne sont pas appelées à chaque requête.
Testez l'ordre d'exécution des dépendances pour vous assurer qu'ils sont exécutés dans le bon ordre.

Erreur 10 : Utilisation incorrecte des middleware

Le problème

from fastapi import FastAPI, Request, Response

app = FastAPI()

@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    response = await call_next(request)
    return response

@app.get("/")
async def read_root():
    return {"message": "Hello World"}

Dans cet exemple, le middleware add_process_time_header est appelé pour chaque requête.

Pourquoi c'est une erreur

La solution

Vous pouvez utiliser la dépendance Depends avec la syntaxe async def common_parameters(): return ... pour garantir que la fonction est appelée une seule fois par instance de l'application.

from fastapi import FastAPI, Request, Response

app = FastAPI()

@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    response = await call_next(request)
    return response

@app.get("/")
async def read_root():
    return {"message": "Hello World"}

Comment prévenir

Utilisez la dépendance Depends avec la syntaxe async def common_parameters(): return ....
Assurez-vous que les fonctions de dépendances ne sont pas appelées à chaque requête.
Testez l'ordre d'exécution des dépendances pour vous assurer qu'ils sont exécutés dans le bon ordre.

Erreur 11 : Utilisation incorrecte des paramètres de route

Le problème

FastAPI utilise les paramètres de route pour définir la structure des routes. L'utilisation incorrecte de ces paramètres peut entraîner des erreurs en cascade ou des comportements inattendus.

from fastapi import FastAPI

app = FastAPI()

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

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

Dans cet exemple, la fonction read_item est appelée avec deux paramètres de requête (q) qui ont le même nom.

Pourquoi c'est une erreur

La solution

Vous pouvez utiliser la dépendance Depends avec la syntaxe async def common_parameters(): return ... pour garantir que la fonction est appelée une seule fois par instance de l'application.

from fastapi import FastAPI

app = FastAPI()

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

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

Comment prévenir

Utilisez la dépendance Depends avec la syntaxe async def common_parameters(): return ....
Assurez-vous que les fonctions de dépendances ne sont pas appelées à chaque requête.
Testez l'ordre d'exécution des dépendances pour vous assurer qu'ils sont exécutés dans le bon ordre.

Erreur 12 : Utilisation incorrecte des middleware

Le problème

from fastapi import FastAPI, Request, Response

app = FastAPI()

@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    response = await call_next(request)
    return response

@app.get("/")
async def read_root():
    return {"message": "Hello World"}

Dans cet exemple, le middleware add_process_time_header est appelé pour chaque requête.

Pourquoi c'est une erreur

La solution

Vous pouvez utiliser la dépendance Depends avec la syntaxe async def common_parameters(): return ... pour garantir que la fonction est appelée une seule fois par instance de l'application.

from fastapi import FastAPI, Request, Response

app = FastAPI()

@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    response = await call_next(request)
    return response

@app.get("/")
async def read_root():
    return {"message": "Hello World"}

Comment prévenir

Utilisez la dépendance Depends avec la syntaxe async def common_parameters(): return ....
Assurez-vous que les fonctions de dépendances ne sont pas appelées à chaque requête.
Testez l'ordre d'exécution des dépendances pour vous assurer qu'ils sont exécutés dans le bon ordre.

Erreur 13 : Utilisation incorrecte des paramètres de route

Le problème

FastAPI utilise les paramètres de route pour définir la structure des routes. L'utilisation incorrecte de ces paramètres peut entraîner des erreurs en cascade ou des comportements inattendus.

from fastapi import FastAPI

app = FastAPI()

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

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

Dans cet exemple, la fonction read_item est appelée avec deux paramètres de requête (q) qui ont le même nom.

Pourquoi c'est une erreur

La solution

Vous pouvez utiliser la dépendance Depends avec la syntaxe async def common_parameters(): return ... pour garantir que la fonction est appelée une seule fois par instance de l'application.

from fastapi import FastAPI

app = FastAPI()

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

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

Comment prévenir

Utilisez la dépendance Depends avec la syntaxe async def common_parameters(): return ....
Assurez-vous que les fonctions de dépendances ne sont pas appelées à chaque requête.
Testez l'ordre d'exécution des dépendances pour vous assurer qu'ils sont exécutés dans le bon ordre.

Erreur 14 : Utilisation incorrecte des middleware

Le problème

from fastapi import FastAPI, Request, Response

app = FastAPI()

@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    response = await call_next(request)
    return response

@app.get("/")
async def read_root():
    return {"message": "Hello World"}

Dans cet exemple, le middleware add_process_time_header est appelé pour chaque requête.

Pourquoi c'est une erreur

La solution

Vous pouvez utiliser la dépendance Depends avec la syntaxe async def common_parameters(): return ... pour garantir que la fonction est appelée une seule fois par instance de l'application.

from fastapi import FastAPI, Request, Response

app = FastAPI()

@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    response = await call_next(request)
    return response

@app.get("/")
async def read_root():
    return {"message": "Hello World"}

Comment prévenir

Utilisez la dépendance Depends avec la syntaxe async def common_parameters(): return ....
Assurez-vous que les fonctions de dépendances ne sont pas appelées à chaque requête.
Testez l'ordre d'exécution des dépendances pour vous assurer qu'ils sont exécutés dans le bon ordre.

Erreur 15 : Utilisation incorrecte des paramètres de route

Le problème

FastAPI utilise les paramètres de route pour définir la structure des routes. L'utilisation incorrecte de ces paramètres peut entraîner des erreurs en cascade ou des comportements inattendus.

from fastapi import FastAPI

app = FastAPI()

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

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

Dans cet exemple, la fonction read_item est appelée avec deux paramètres de requête (q) qui ont le même nom.

Pourquoi c'est une erreur

La solution

Vous pouvez utiliser la dépendance Depends avec la syntaxe async def common_parameters(): return ... pour garantir que la fonction est appelée une seule fois par instance de l'application.

from fastapi import FastAPI

app = FastAPI()

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

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

Comment prévenir

Utilisez la dépendance Depends avec la syntaxe async def common_parameters(): return ....
Assurez-vous que les fonctions de dépendances ne sont pas appelées à chaque requête.
Testez l'ordre d'exécution des dépendances pour vous assurer qu'ils sont exécutés dans le bon ordre.

Erreur 16 : Utilisation incorrecte des middleware

Le problème

from fastapi import FastAPI, Request, Response

app = FastAPI()

@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    response = await call_next(request)
    return response

@app.get("/")
async def read_root():
    return {"message": "Hello World"}

Dans cet exemple, le middleware add_process_time_header est appelé pour chaque requête.

Pourquoi c'est une erreur

La solution

Vous pouvez utiliser la dépendance Depends avec la syntaxe async def common_parameters(): return ... pour garantir que la fonction est appelée une seule fois par instance de l'application.

from fastapi import FastAPI, Request, Response

app = FastAPI()

@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    response = await call_next(request)
    return response

@app.get("/")
async def read_root():
    return {"message": "Hello World"}

Comment prévenir

Utilisez la dépendance Depends avec la syntaxe async def common_parameters(): return ....
Assurez-vous que les fonctions de dépendances ne sont pas appelées à chaque requête.
Testez l'ordre d'exécution des dépendances pour vous assurer qu'ils sont exécutés dans le bon ordre.

Erreur 17 : Utilisation incorrecte des paramètres de route

Le problème

FastAPI utilise les paramètres de route pour définir la structure des routes. L'utilisation incorrecte de ces paramètres peut entraîner des erreurs en cascade ou des comportements inattendus.

from fastapi import FastAPI

app = FastAPI()

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

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

Dans cet exemple, la fonction read_item est appelée avec deux paramètres de requête (q) qui ont le même nom.

Pourquoi c'est une erreur

La solution

Vous pouvez utiliser la dépendance Depends avec la syntaxe async def common_parameters(): return ... pour garantir que la fonction est appelée une seule fois par instance de l'application.

from fastapi import FastAPI

app = FastAPI()

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

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

Comment prévenir

Utilisez la dépendance Depends avec la syntaxe async def common_parameters(): return ....
Assurez-vous que les fonctions de dépendances ne sont pas appelées à chaque requête.
Testez l'ordre d'exécution des dépendances pour vous assurer qu'ils sont exécutés dans le bon ordre.

Erreur 18 : Utilisation incorrecte des middleware

Le problème

from fastapi import FastAPI, Request, Response

app = FastAPI()

@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    response = await call_next(request)
    return response

@app.get("/")
async def read_root():
    return {"message": "Hello World"}

Dans cet exemple, le middleware add_process_time_header est appelé pour chaque requête.

Pourquoi c'est une erreur

La solution

Vous pouvez utiliser la dépendance Depends avec la syntaxe async def common_parameters(): return ... pour garantir que la fonction est appelée une seule fois par instance de l'application.

from fastapi import FastAPI, Request, Response

app = FastAPI()

@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    response = await call_next(request)
    return response

@app.get("/")
async def read_root():
    return {"message": "Hello World"}

Comment prévenir

Utilisez la dépendance Depends avec la syntaxe async def common_parameters(): return ....
Assurez-vous que les fonctions de dépendances ne sont pas appelées à chaque requête.
Testez l'ordre d'exécution des dépendances pour vous assurer qu'ils sont exécutés dans le bon ordre.

Erreur 19 : Utilisation incorrecte des paramètres de route

Le problème

FastAPI utilise les paramètres de route pour définir la structure des routes. L'utilisation incorrecte de ces paramètres peut entraîner des erreurs en cascade ou des comportements inattendus.

from fastapi import FastAPI

app = FastAPI()

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

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

Dans cet exemple, la fonction read_item est appelée avec deux paramètres de requête (q) qui ont le même nom.

Pourquoi c'est une erreur

La solution

Vous pouvez utiliser la dépendance Depends avec la syntaxe async def common_parameters(): return ... pour garantir que la fonction est appelée une seule fois par instance de l'application.

from fastapi import FastAPI

app = FastAPI()

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

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

Comment prévenir

Utilisez la dépendance Depends avec la syntaxe async def common_parameters(): return ....
Assurez-vous que les fonctions de dépendances ne sont pas appelées à chaque requête.
Testez l'ordre d'exécution des dépendances pour vous assurer qu'ils sont exécutés dans le bon ordre.

Erreur 20 : Utilisation incorrecte des paramètres de route

Le problème

FastAPI utilise les paramètres de route pour définir la structure des routes. L'utilisation incorrecte de ces paramètres peut entraîner des erreurs en cascade ou des comportements inattendus.

from fastapi

Les erreurs a eviter en FastAPI

Sommaire

Erreur 1 : Manque de validation des données d'entrée

Le problème

Pourquoi c'est une erreur

La solution

Comment prévenir

Erreur 2 : Utilisation incorrecte des dépendances

Le problème

Pourquoi c'est une erreur

La solution

Comment prévenir

Erreur 3 : Manque de gestion des exceptions

Le problème

Pourquoi c'est une erreur

La solution

Comment prévenir

Erreur 4 : Utilisation incorrecte des décorateurs

Le problème

Pourquoi c'est une erreur

La solution

Comment prévenir

Erreur 5 : Utilisation incorrecte des middleware

Le problème

Pourquoi c'est une erreur

La solution

Comment prévenir

Erreur 6 : Utilisation incorrecte des paramètres de route

Le problème

Pourquoi c'est une erreur

La solution

Comment prévenir

Erreur 7 : Utilisation incorrecte des décorateurs

Le problème

Pourquoi c'est une erreur

La solution

Comment prévenir

Erreur 8 : Utilisation incorrecte des middleware

Le problème

Pourquoi c'est une erreur

La solution

Comment prévenir

Erreur 9 : Utilisation incorrecte des paramètres de route

Le problème

Pourquoi c'est une erreur

La solution

Comment prévenir

Erreur 10 : Utilisation incorrecte des middleware

Le problème

Pourquoi c'est une erreur

La solution

Comment prévenir

Erreur 11 : Utilisation incorrecte des paramètres de route

Le problème

Pourquoi c'est une erreur

La solution

Comment prévenir

Erreur 12 : Utilisation incorrecte des middleware

Le problème

Pourquoi c'est une erreur

La solution

Comment prévenir

Erreur 13 : Utilisation incorrecte des paramètres de route

Le problème

Pourquoi c'est une erreur

La solution

Comment prévenir

Erreur 14 : Utilisation incorrecte des middleware

Le problème

Pourquoi c'est une erreur

La solution

Comment prévenir

Erreur 15 : Utilisation incorrecte des paramètres de route

Le problème

Pourquoi c'est une erreur

La solution

Comment prévenir

Erreur 16 : Utilisation incorrecte des middleware

Le problème

Pourquoi c'est une erreur