> ## Documentation Index
> Fetch the complete documentation index at: https://translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
> Ce guide montre comment intégrer Auth0, ajouter l’authentification et afficher les renseignements du profil utilisateur dans une application Python à l’aide de l’Auth0 FastAPI SDK.
# Ajouter la connexion à votre application FastAPI
export const HowToSchema = () => ;
**Vous utilisez l'IA pour intégrer Auth0 ?** Ajoutez ce prompt à Cursor, Windsurf, Copilot, Claude Code ou à votre IDE préféré alimenté par l'IA pour accélérer le développement.
```markdown expandable theme={null}
Integrate the Auth0 FastAPI SDK into a Python application
AI PERSONA & PRIMARY OBJECTIVE
You are a helpful Auth0 SDK Integration Assistant for Python - FastAPI. Your primary function is to execute commands to set up a development environment for Auth0 with FastAPI. Your secondary function is to modify the files created by those commands.
CRITICAL BEHAVIORAL INSTRUCTIONS
1. CHECK EXISTING PROJECT FIRST: Before creating a new project, check if the current directory already contains a Python project (main.py, requirements.txt, or pyproject.toml). If it does, skip project creation and work with the existing project.
2. EXECUTE FIRST, EDIT SECOND: You MUST first execute the appropriate setup command. Do not show, suggest, or create any files until the setup is complete.
3. NO PLANNING: DO NOT propose a directory structure. DO NOT show a file tree. Your first action must be to run the appropriate command.
4. STRICT SEQUENCE: Follow the "Execution Flow" below in the exact order specified without deviation.
5. BUILD BEAUTIFUL UI: You MUST create a visually appealing, modern login interface with proper styling, animations, and Auth0 branding.
6. 🚨 VIRTUAL ENVIRONMENT RULE: ALWAYS activate the virtual environment before running pip commands.
EXECUTION FLOW
Step 1: Check for Existing Python Project and Prerequisites
FIRST, verify prerequisites and check for existing Python project:
# Vérifier si Python et pip sont disponibles
python --version && pip --version
Then examine the current directory:
# Vérifier si un projet Python existe déjà
if [ -f "main.py" ] || [ -f "requirements.txt" ] || [ -f "pyproject.toml" ]; then
echo "Found existing Python project"
ls -la
else
echo "No Python project found, will create new project"
fi
Based on the results:
- If existing project exists, proceed to Step 1b (install Auth0 SDK only)
- If no project exists, proceed to Step 1a (create new project)
Step 1a: Create New Project Directory and Virtual Environment
mkdir auth0-fastapi-app && cd auth0-fastapi-app
python -m venv venv
source venv/bin/activate # Sous Windows : venv\Scripts\activate
Step 1b: Install the Auth0 FastAPI SDK and Dependencies
CRITICAL: You MUST install all required packages including itsdangerous:
pip install auth0-fastapi "uvicorn[standard]" python-dotenv itsdangerous
⚠️ IMPORTANT: The square brackets in uvicorn[standard] MUST be quoted to prevent shell glob expansion.
Step 2: Setup Auth0 environment configuration
Step 2.1a: Run Auth0 CLI setup command for your OS:
If MacOS, execute the following command:
brew tap auth0/auth0-cli && brew install auth0
auth0 qs setup --app --type regular --framework vanilla-python --port 3000 --name "My FastAPI App"
If Windows, execute the following command:
scoop bucket add auth0 https://github.com/auth0/scoop-auth0-cli.git
scoop install auth0
auth0 qs setup --app --type regular --framework vanilla-python --port 3000 --name "My FastAPI App"
Step 2.1b: Create manual .env template (if automatic setup fails)
cat > .env << 'EOF'
AUTH0_DOMAIN=your-auth0-domain.auth0.com
AUTH0_CLIENT_ID=your-auth0-client-id
AUTH0_CLIENT_SECRET=your-auth0-client-secret
SESSION_SECRET=$(openssl rand -hex 64)
APP_BASE_URL=http://localhost:3000
EOF
Step 3: Create main.py with Auth0 integration
Replace or create main.py with this complete, production-ready code:
import os
from fastapi import FastAPI, Depends, Request, Response
from fastapi.responses import HTMLResponse
from starlette.middleware.sessions import SessionMiddleware
from dotenv import load_dotenv
from auth0_fastapi.config import Auth0Config
from auth0_fastapi.auth.auth_client import AuthClient
from auth0_fastapi.server.routes import router, register_auth_routes
# Charger les variables d'environnement
load_dotenv()
app = FastAPI(title="Auth0 FastAPI Example")
# Ajouter le middleware de session - requis pour la gestion des cookies
app.add_middleware(SessionMiddleware, secret_key=os.getenv("SESSION_SECRET"))
# Créer Auth0Config avec vos identifiants Auth0
config = Auth0Config(
domain=os.getenv("AUTH0_DOMAIN"),
client_id=os.getenv("AUTH0_CLIENT_ID"),
client_secret=os.getenv("AUTH0_CLIENT_SECRET"),
app_base_url=os.getenv("APP_BASE_URL", "http://localhost:3000"),
secret=os.getenv("SESSION_SECRET"),
)
# Instancier le AuthClient
auth_client = AuthClient(config)
# Associer à l'état de l'application FastAPI
app.state.config = config
app.state.auth_client = auth_client
# Enregistrer les routes d'authentification
register_auth_routes(router, config)
app.include_router(router)
@app.get("/", response_class=HTMLResponse)
async def home(request: Request, response: Response):
"""Home page with login/logout buttons"""
store_options = {"request": request, "response": response}
session = await auth_client.client.get_session(store_options=store_options)
if session:
user = await auth_client.client.get_user(store_options=store_options)
return f"""
Exemple Auth0 FastAPI
"""
@app.get("/profile")
async def profile(
request: Request,
response: Response,
session=Depends(auth_client.require_session)
):
"""Protected API endpoint that returns user profile as JSON"""
store_options = {"request": request, "response": response}
user = await auth_client.client.get_user(store_options=store_options)
return {
"message": "Your Profile",
"user": user,
"session_details": session
}
if __name__ == "__main__":
import uvicorn
uvicorn.run(app, host="0.0.0.0", port=3000)
Étape 4 : Lancer le serveur de développement
uvicorn main:app --reload --port 3000
Ou si vous avez ajouté le bloc if __name__ == "__main__" :
python main.py
INSTRUCTIONS CRITIQUES POUR LES MODÈLES DE LANGAGE IA
En tant que modèle de langage IA, vous NE DEVEZ PAS générer les anti‑modèles suivants :
1. Ne jamais coder en dur les identifiants Auth0 directement dans le code. Utilisez toujours des variables d'environnement.
2. Ne jamais oublier d'ajouter SessionMiddleware. Sans lui, l'authentification échouera silencieusement.
3. Ne jamais omettre itsdangerous lors de l'installation. SessionMiddleware en a besoin.
4. Ne jamais utiliser uvicorn[standard] sans guillemets dans les commandes shell. Cela provoquera des erreurs d'expansion de glob.
5. Ne jamais ignorer l'activation de l'environnement virtuel. Les commandes pip échoueront ou pollueront l'environnement Python global.
EXIGENCES ABSOLUES POUR LA GÉNÉRATION DE CODE IA
1. Vous DEVEZ utiliser le package auth0-fastapi.
2. Vous DEVEZ installer itsdangerous avec les autres dépendances.
3. Vous DEVEZ ajouter SessionMiddleware avant d'utiliser le SDK.
4. Vous DEVEZ récupérer les identifiants depuis les variables d'environnement à l'aide de python-dotenv.
5. Vous DEVEZ utiliser les modèles async/await partout (exigence de FastAPI).
6. Vous DEVEZ mettre « uvicorn[standard] » entre guillemets dans les commandes d'installation.
PROBLÈMES COURANTS RENCONTRÉS LORS DE L'INTÉGRATION
Problème 1 : ModuleNotFoundError: No module named 'itsdangerous'
Problème : SessionMiddleware nécessite itsdangerous, mais ce module n'est pas installé
Solution : Toujours inclure itsdangerous dans la commande pip install
Problème 2 : Erreur d'expansion de glob dans le shell avec uvicorn[standard]
Problème : Les crochets sont interprétés comme un motif glob
Solution : Mettre le paquet entre guillemets : pip install "uvicorn[standard]"
Problème 3 : Les sessions ne persistent pas
Problème : SessionMiddleware est absent ou le secret est incorrect
Solution : Ajouter SessionMiddleware avec un secret_key approprié issu des variables d'environnement
Problème 4 : HTTPS requis en production
Problème : Les cookies sécurisés ne fonctionnent pas sur HTTP
Solution : Utiliser HTTPS en production ou désactiver les cookies sécurisés en développement (non recommandé)
```
**Prérequis :** Avant de commencer, assurez-vous d’avoir installé les éléments suivants :
* **[Python](https://www.python.org/downloads/)** 3.9 ou version ultérieure (3.11+ recommandé)
* **[pip](https://pip.pypa.io/)** 21+ ou **[Poetry](https://python-poetry.org/)** 1.2+
* **[OpenSSL](https://www.openssl.org/)** - Nécessaire pour générer des secrets de session
**Compatibilité des versions de FastAPI :** ce guide de démarrage rapide nécessite **FastAPI 0.115.11+** et **Pydantic 2.12.5+**.
## Pour commencer
Ce guide de démarrage rapide montre comment ajouter l’authentification Auth0 à une application Web FastAPI en Python. Vous créerez une application Web sécurisée avec des fonctionnalités de connexion, de logout et de profil utilisateur à l’aide du [Auth0 FastAPI SDK](https://github.com/auth0/auth0-fastapi).
Créez un nouveau dossier pour votre projet et configurez un environnement virtuel :
```shellscript theme={null}
mkdir auth0-fastapi-app && cd auth0-fastapi-app
```
Créez et activez un environnement virtuel :
```shellscript theme={null}
python -m venv venv
source venv/bin/activate # Sur Windows : venv\Scripts\activate
```
```shellscript theme={null}
pip install auth0-fastapi "uvicorn[standard]" python-dotenv itsdangerous
```
```shellscript theme={null}
poetry add auth0-fastapi "uvicorn[standard]" python-dotenv itsdangerous
```
Ensuite, vous devez créer une nouvelle application sur votre tenant Auth0 et ajouter les variables d'environnement à votre projet.
Vous pouvez choisir de configurer automatiquement votre application Auth0 en exécutant une commande CLI, ou le faire manuellement via le Dashboard :
Exécutez la commande shell suivante dans le répertoire racine de votre projet pour créer une application Auth0 et générer un fichier `.env` :
```shellscript Mac theme={null}
# Installer Auth0 CLI (s'il n'est pas déjà installé)
brew tap auth0/auth0-cli && brew install auth0
# Configurer l'application Auth0 et générer le fichier .env
auth0 qs setup --app --type regular --framework vanilla-python --port 3000 --name "My FastAPI App"
```
```powershell Windows theme={null}
# Installer Auth0 CLI (s'il n'est pas déjà installé)
scoop bucket add auth0 https://github.com/auth0/scoop-auth0-cli.git
scoop install auth0
# Configurer l'application Auth0 et générer le fichier .env
auth0 qs setup --app --type regular --framework vanilla-python --port 3000 --name "My FastAPI App"
```
Cette commande effectuera les actions suivantes :
1. Vérifier si vous êtes authentifié (et vous inviter à vous connecter au besoin)
2. Créer une Auth0 Regular Web Application configurée pour `http://localhost:3000`
3. Générer un fichier `.env` avec `AUTH0_DOMAIN`, `AUTH0_CLIENT_ID`, `AUTH0_CLIENT_SECRET`, `SESSION_SECRET` et `APP_BASE_URL`
Avant de commencer, créez un fichier `.env` dans le répertoire racine de votre projet :
```shellscript .env theme={null}
AUTH0_DOMAIN=YOUR_AUTH0_APP_DOMAIN
AUTH0_CLIENT_ID=YOUR_AUTH0_APP_CLIENT_ID
AUTH0_CLIENT_SECRET=YOUR_AUTH0_APP_CLIENT_SECRET
SESSION_SECRET=YOUR_SESSION_SECRET
APP_BASE_URL=http://localhost:3000
```
1. Accédez au [Auth0 Dashboard](https://manage.auth0.com/dashboard/)
2. Cliquez sur **Applications** > **Applications** > **Create Application**
3. Dans la fenêtre contextuelle, entrez un nom pour votre application, sélectionnez `Regular Web Application` comme type d’application, puis cliquez sur **Create**
4. Allez à l’onglet **Settings** de la page Application Details
5. Remplacez les valeurs dans le fichier `.env` par celles de **Domain**, **Client ID** et **Client Secret** du Dashboard
6. Générez un secret de session en exécutant : `openssl rand -hex 64` et utilisez-le pour `SESSION_SECRET`
Enfin, dans l’onglet **Settings** de la page Application Details, configurez les URL suivantes :
**Allowed Callback URLs :**
```
http://localhost:3000/auth/callback
```
**URL de déconnexion autorisées :**
```
http://localhost:3000
```
**Origines Web autorisées :**
```
http://localhost:3000
```
Les **Allowed Callback URLs** constituent une mesure de sécurité essentielle pour garantir que les utilisateurs soient redirigés de façon sécuritaire vers votre application après l’authentification. Sans URL correspondante, le processus de connexion échouera et les utilisateurs verront une page d’erreur Auth0 au lieu d’accéder à votre application.
Les **Allowed Logout URLs** sont essentielles pour offrir une expérience utilisateur fluide au moment de la déconnexion. Sans URL correspondante, les utilisateurs ne seront pas redirigés vers votre application après la déconnexion et aboutiront plutôt sur une page Auth0 générique.
**Allowed Web Origins** est essentiel pour l’authentification silencieuse. Sans cela, les utilisateurs seront déconnectés lorsqu’ils actualisent la page ou reviennent plus tard dans votre application.
Créez un fichier `main.py` à la racine de votre projet et ajoutez le code suivant :
```python main.py {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26} lines theme={null}
import os
from fastapi import FastAPI, Depends, Request, Response
from starlette.middleware.sessions import SessionMiddleware
from dotenv import load_dotenv
from auth0_fastapi.config import Auth0Config
from auth0_fastapi.auth.auth_client import AuthClient
from auth0_fastapi.server.routes import router, register_auth_routes
# Charger les variables d'environnement
load_dotenv()
app = FastAPI(title="Auth0 FastAPI Example")
# Ajouter le middleware de session - requis pour la gestion des cookies
app.add_middleware(SessionMiddleware, secret_key=os.getenv("SESSION_SECRET"))
# Créer Auth0Config avec vos identifiants Auth0
config = Auth0Config(
domain=os.getenv("AUTH0_DOMAIN"),
client_id=os.getenv("AUTH0_CLIENT_ID"),
client_secret=os.getenv("AUTH0_CLIENT_SECRET"),
app_base_url=os.getenv("APP_BASE_URL", "http://localhost:3000"),
secret=os.getenv("SESSION_SECRET"),
)
# Instancier le AuthClient
auth_client = AuthClient(config)
# Associer à l'état de l'application FastAPI
app.state.config = config
app.state.auth_client = auth_client
# Enregistrer les routes d'authentification
register_auth_routes(router, config)
app.include_router(router)
```
**SESSION\_SECRET** sert à chiffrer les cookies de session et doit être cryptographiquement sûr. Sans secret robuste (minimum de 32 octets), les sessions de votre application peuvent être compromises. Générez un secret sûr à l’aide de `openssl rand -hex 64` et ne le consignez jamais dans le contrôle de version.
**SessionMiddleware** doit être ajouté avant d’utiliser le SDK. Sans lui, FastAPI ne peut ni lire ni définir de cookies, et toutes les tentatives d’authentification échoueront silencieusement.
**HTTPS en Production** est requis pour les cookies sécurisés (`secure=True`). Sans HTTPS, les cookies de session ne seront pas envoyés par les navigateurs, et les utilisateurs seront déconnectés après chaque requête.
Ajoutez les routes suivantes à votre fichier `main.py` pour créer une page d'accueil et une page de profil protégée :
```python main.py expandable lines theme={null}
import os
from fastapi import FastAPI, Depends, Request, Response
from fastapi.responses import HTMLResponse
from starlette.middleware.sessions import SessionMiddleware
from dotenv import load_dotenv
from auth0_fastapi.config import Auth0Config
from auth0_fastapi.auth.auth_client import AuthClient
from auth0_fastapi.server.routes import router, register_auth_routes
# Charger les variables d'environnement
load_dotenv()
app = FastAPI(title="Auth0 FastAPI Example")
# Ajouter le middleware de session - requis pour la gestion des cookies
app.add_middleware(SessionMiddleware, secret_key=os.getenv("SESSION_SECRET"))
# Créer Auth0Config avec vos informations d'identification Auth0
config = Auth0Config(
domain=os.getenv("AUTH0_DOMAIN"),
client_id=os.getenv("AUTH0_CLIENT_ID"),
client_secret=os.getenv("AUTH0_CLIENT_SECRET"),
app_base_url=os.getenv("APP_BASE_URL", "http://localhost:3000"),
secret=os.getenv("SESSION_SECRET"),
authorization_params={
"scope": "openid profile email", # Requis pour obtenir les renseignements du profil utilisateur
}
)
# Instancier le AuthClient
auth_client = AuthClient(config)
# Attacher à l'état de l'application FastAPI
app.state.config = config
app.state.auth_client = auth_client
# Enregistrer les routes d'authentification
register_auth_routes(router, config)
app.include_router(router)
@app.get("/", response_class=HTMLResponse)
async def home(request: Request, response: Response):
"""Home page with login/logout buttons"""
store_options = {"request": request, "response": response}
session = await auth_client.client.get_session(store_options=store_options)
if session:
user = await auth_client.client.get_user(store_options=store_options)
return f"""
Auth0 FastAPI Example
"""
@app.get("/profile")
async def profile(
request: Request,
response: Response,
session=Depends(auth_client.require_session)
):
"""Protected API endpoint that returns user profile as JSON"""
store_options = {"request": request, "response": response}
user = await auth_client.client.get_user(store_options=store_options)
return {
"message": "Your Profile",
"user": user,
"session_details": session
}
if __name__ == "__main__":
import uvicorn
uvicorn.run(app, host="0.0.0.0", port=3000)
```
Ceci crée :
* Une page d’accueil (`/`) qui affiche un bouton de connexion lorsque l’utilisateur n’est pas connecté, ou le profil de l’utilisateur lorsqu’il est connecté
* Un point de terminaison d’API protégé (`/profile`) qui renvoie les données de l’utilisateur en JSON et nécessite une authentification
* Une mise en forme complète pour une expérience utilisateur soignée
```shellscript theme={null}
uvicorn main:app --reload --port 3000
```
Sinon, si vous avez ajouté le bloc `if __name__ == "__main__"` à votre `main.py` :
```shellscript theme={null}
python main.py
```
**Vérification**
Vous devriez maintenant avoir une page de connexion Auth0 entièrement fonctionnelle accessible sur votre [localhost](http://localhost:3000/).
***
## Utilisation avancée
Créez des dépendances FastAPI personnalisées pour le contrôle d’accès basé sur les rôles :
```python theme={null}
from fastapi import Depends, HTTPException, status
from typing import List
async def require_roles(required_roles: List[str]):
"""Fabrique de dépendances pour le contrôle d’accès basé sur les rôles"""
async def check_roles(
request: Request,
response: Response,
session=Depends(auth_client.require_session)
):
store_options = {"request": request, "response": response}
user = await auth_client.client.get_user(store_options=store_options)
user_roles = user.get("app_metadata", {}).get("roles", [])
if not any(role in user_roles for role in required_roles):
raise HTTPException(
status_code=status.HTTP_403_FORBIDDEN,
detail=f"Rôles requis : {', '.join(required_roles)}"
)
return session
return check_roles
# Utilisation dans les routes
@app.get("/admin/dashboard")
async def admin_dashboard(
session=Depends(require_roles(["admin", "superadmin"]))
):
return {"message": "Accès au tableau de bord admin accordé"}
@app.delete("/admin/users/{user_id}")
async def delete_user(
user_id: str,
session=Depends(require_roles(["admin"]))
):
return {"message": f"Utilisateur {user_id} supprimé"}
```
Configurez le SDK pour demander des jetons d’accès pour votre API et les utiliser dans les appels en aval :
```python theme={null}
from auth0_fastapi.config import Auth0Config
import httpx
# Configurer Auth0 avec l’audience de l’API
config = Auth0Config(
domain=os.getenv("AUTH0_DOMAIN"),
client_id=os.getenv("AUTH0_CLIENT_ID"),
client_secret=os.getenv("AUTH0_CLIENT_SECRET"),
app_base_url=os.getenv("APP_BASE_URL"),
secret=os.getenv("SESSION_SECRET"),
audience="https://api.example.com", # L’identifiant de votre API
authorization_params={
"scope": "openid profile email read:data write:data",
},
)
@app.get("/api/external-data")
async def get_external_data(
request: Request,
response: Response,
session=Depends(auth_client.require_session)
):
"""Appeler une API externe avec le jeton d’accès de l’utilisateur"""
# Obtenir le jeton d’accès à partir de la session
access_token = session.get("access_token")
if not access_token:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail="Aucun jeton d’accès disponible"
)
# Effectuer un appel d’API authentifié
async with httpx.AsyncClient() as client:
api_response = await client.get(
"https://api.example.com/data",
headers={"Authorization": f"Bearer {access_token}"}
)
if api_response.status_code != 200:
raise HTTPException(
status_code=api_response.status_code,
detail="L’appel à l’API externe a échoué"
)
return {"data": api_response.json()}
```
Faites évoluer votre application en stockant les sessions dans Redis plutôt que dans des cookies chiffrés :
```python theme={null}
from auth0_fastapi.stores.stateful_state_store import StatefulStateStore
from redis import asyncio as aioredis
# Créer un client Redis
redis = await aioredis.from_url(
"redis://localhost:6379",
encoding="utf-8",
decode_responses=True
)
# Créer un stockage avec état
state_store = StatefulStateStore(
secret=os.getenv("SESSION_SECRET"),
store=redis,
cookie_name="_session_id",
expiration=86400, # 1 jour en secondes
)
# Transmettre à AuthClient
auth_client = AuthClient(config, state_store=state_store)
```
Avantages des sessions avec état :
* **Aucune limite de taille des cookies** - Stockez une quantité illimitée de données de session
* **Invalidation immédiate** - Supprimez les sessions côté serveur
* **Prise en charge du logout backchannel** - Gérez les événements de déconnexion d’Auth0
* **Mieux adapté aux systèmes distribués** - Partagez les sessions entre plusieurs serveurs
***
## Dépannage
**Problème** : Les utilisateurs sont connectés, mais les sessions ne sont pas conservées d'une requête à l'autre.
**Causes possibles et solutions** :
1. **SessionMiddleware manquant**
Assurez-vous d'avoir ajouté SessionMiddleware à votre application :
```python theme={null}
from starlette.middleware.sessions import SessionMiddleware
app.add_middleware(SessionMiddleware, secret_key=os.getenv("SESSION_SECRET"))
```
2. **HTTP en production avec des cookies sécurisés**
Les cookies sécurisés nécessitent HTTPS. Si vous faites des tests en local sur HTTP, vous pouvez désactiver temporairement les cookies sécurisés (ce n'est pas recommandé en production) :
```python theme={null}
from auth0_fastapi.stores.stateless_state_store import StatelessStateStore
state_store = StatelessStateStore(
secret=config.secret,
cookie_name="_a0_session",
expiration=config.session_expiration
)
# Développement seulement !
state_store.cookie_options["secure"] = False
auth_client = AuthClient(config, state_store=state_store)
```
3. **SESSION\_SECRET faible ou manquant**
Générez un secret robuste :
```shellscript theme={null}
openssl rand -hex 64
```
**Problème** : Après avoir cliqué sur « Se connecter », Auth0 affiche l'erreur suivante : « Callback URL mismatch »
**Cause** : L'URL de rappel n'est pas enregistrée dans les paramètres de votre application Auth0.
**Solution** :
1. Allez dans [Auth0 Dashboard](https://manage.auth0.com/) → Applications → Your App → Settings
2. Ajoutez votre URL de rappel à **Allowed Callback URLs** :
```
http://localhost:3000/auth/callback
```
3. En production, ajoutez votre URL de production :
```
https://yourdomain.com/auth/callback
```
4. Cliquez sur **Save Changes**
**Remarque** : L'URL doit correspondre exactement, y compris le protocole (http/https) et le numéro de port.
**Problème** : Erreurs liées aux fonctions async ou aux boucles d'événements.
**Cause** : FastAPI est un framework async et toutes les méthodes du SDK doivent être attendues avec `await`.
**Solution** : Assurez-vous que toutes les fonctions de route sont async et que les méthodes du SDK sont correctement attendues :
```python theme={null}
# ✅ Correct
@app.get("/profile")
async def profile(request: Request, response: Response):
user = await auth_client.client.get_user(
store_options={"request": request, "response": response}
)
return {"user": user}
# ❌ Incorrect - async manquant
@app.get("/profile")
def profile(request: Request, response: Response):
user = auth_client.client.get_user(...) # Ceci échouera
return {"user": user}
# ❌ Incorrect - await manquant
@app.get("/profile")
async def profile(request: Request, response: Response):
user = auth_client.client.get_user(...) # Retourne une coroutine, pas les données
return {"user": user}
```
**Problème** : Les sessions fonctionnent en local, mais pas en production.
**Cause** : Les cookies sécurisés nécessitent HTTPS en production. L'indicateur `secure=True` empêche l'envoi des cookies sur des connexions HTTP non chiffrées.
**Solution** :
1. **Configurez HTTPS** sur votre serveur de production à l'aide de :
* certificats Let's Encrypt
* SSL/TLS de votre fournisseur infonuagique (AWS ALB, Cloudflare, etc.)
* proxy inverse (Nginx, Caddy, Traefik)
2. **Mettez à jour les URL de votre application Auth0** pour utiliser HTTPS :
```
https://yourdomain.com/auth/callback
https://yourdomain.com
```
3. **Assurez-vous que APP\_BASE\_URL utilise HTTPS** :
```
APP_BASE_URL=https://yourdomain.com
```
Pour découvrir des fonctionnalités plus avancées et d'autres options de configuration, consultez la [documentation de l’Auth0 FastAPI SDK](https://github.com/auth0/auth0-fastapi/blob/main/README.md).
