# Backend Python / Flask

Ajoutez la connexion à une application Python Flask à l'aide de la bibliothèque Authlib et du flux Authorization Code avec PKCE.

Ce guide ajoute la connexion OIDC à une application Flask au moyen d'[Authlib](https://docs.authlib.org/en/latest/client/flask.html), qui prend en charge la discovery, PKCE et la validation des tokens. Il part d'un client **confidentiel** (un backend capable de garder un secret).

Si vous n'avez pas encore enregistré d'application, voir [Avant de commencer](https://dts-identity.com/fr/docs/quickstarts.md#before-you-start). Pour le protocole sous-jacent, voir [OpenID Connect (Authorization Code + PKCE)](https://dts-identity.com/fr/docs/quickstarts/oidc-authorization-code.md).

## 1. Installer les dépendances

```bash
pip install flask authlib requests
```

## 2. Configurer le client

```python
import os

from authlib.integrations.flask_client import OAuth
from flask import Flask, redirect, session, url_for

app = Flask(__name__)
app.secret_key = os.environ["SESSION_SECRET"]

oauth = OAuth(app)
oauth.register(
    "idp",
    client_id=os.environ["OIDC_CLIENT_ID"],
    client_secret=os.environ["OIDC_CLIENT_SECRET"],
    # Your instance's login domain (issuer). Authlib reads the discovery
    # document and configures all endpoints from it.
    server_metadata_url="https://<your-domain>/.well-known/openid-configuration",
    client_kwargs={
        "scope": "openid profile email offline_access",
        "code_challenge_method": "S256",  # send a PKCE challenge as well
    },
)
```

Gardez `OIDC_CLIENT_ID` et `OIDC_CLIENT_SECRET` dans l'environnement, jamais dans la gestion de versions.

## 3. Démarrer la connexion

Authlib construit l'URL d'autorisation avec une challenge PKCE et un `state`, mémorise les deux dans la session, puis redirige le navigateur :

```python
@app.route("/login")
def login():
    redirect_uri = url_for("callback", _external=True)  # e.g. https://app.example.com/callback
    return oauth.idp.authorize_redirect(redirect_uri)
```

La `redirect_uri` doit correspondre exactement à une valeur enregistrée sur l'application.

## 4. Traiter le callback

Échangez le code contre des tokens. Authlib valide pour vous la réponse, le `state`, le verifier PKCE et l'ID token.

```python
@app.route("/callback")
def callback():
    tokens = oauth.idp.authorize_access_token()

    claims = tokens["userinfo"]  # validated ID-token claims
    session["user"] = {"sub": claims["sub"], "name": claims.get("name"), "email": claims.get("email")}
    session["id_token"] = tokens["id_token"]

    # Optional: fetch additional claims from UserInfo
    # userinfo = oauth.idp.userinfo(token=tokens)

    return redirect("/")
```

## 5. Déconnexion

Envoyez l'utilisateur vers l'endpoint end-session, puis effacez votre propre session.

```python
from urllib.parse import urlencode

@app.route("/logout")
def logout():
    metadata = oauth.idp.load_server_metadata()
    params = urlencode({
        "id_token_hint": session.get("id_token", ""),
        "post_logout_redirect_uri": "https://app.example.com/",
    })
    session.clear()
    return redirect(f"{metadata['end_session_endpoint']}?{params}")
```

Enregistrez `https://app.example.com/` comme post-logout redirect URI sur l'application, de la même manière que vous enregistrez une redirect URI.

## Dépannage

- **L'appel de discovery échoue.** Vérifiez que `https://<your-domain>/.well-known/openid-configuration` est joignable depuis votre serveur et que le domaine est bien l'hôte de connexion de votre instance.
- **`mismatching_state` au callback.** La session qui a démarré la connexion doit être celle qui traite le callback. Assurez-vous que les cookies de session survivent à la redirection (`SameSite` correct et, en production, cookies `secure` sur HTTPS), et que `secret_key` est identique sur tous les workers ; une clé aléatoire par worker casse silencieusement la session à chaque redirection.
- **Aucun refresh token n'est jamais renvoyé.** Incluez `offline_access` dans le scope et vérifiez que l'application est configurée pour recevoir des refresh tokens.

## Étapes suivantes

- [Application monopage React](https://dts-identity.com/fr/docs/quickstarts/react-spa.md) pour un client purement navigateur.
- [Protéger une API](https://dts-identity.com/fr/docs/quickstarts/protect-an-api.md) pour valider les access tokens dans votre propre API Python.
- [Applications](https://dts-identity.com/fr/docs/integrations/applications.md) pour examiner les durées de vie des tokens et les autres paramètres du client.
