Aller au contenu
English

Appliquer les autorisations

  • Leçon 11
  • 110 min
  • Module 4 : Ajouter la fiabilité et le contrôle d'accès

Où nous en sommes

Dans le module 3, nous avons construit une tranche qui répond avec une vraie recherche et des citations vérifiées. Mais personne ne se connecte encore : Sam pouvait lire le rabais réservé au personnel de l'autre boutique, et la requête renvoyait 200 avec une bonne réponse. Dans cette leçon, nous vérifions l'appelant, sa boutique et son rôle à chaque requête, et nous ajoutons un deuxième verrou dans la base de données, comme une banque avec des coffrets de sûreté.

Lue depuis YouTube. Rien ne se charge depuis YouTube avant que vous appuyiez sur lecture. Confidentialité

Ce que vous saurez faire

Faites vérifier trois choses à l’assistant pour chaque requête : qui l’envoie, son adhésion à cette boutique et les autorisations de son rôle. Ajoutez ensuite un deuxième verrou dans la base de données. Ainsi, même un filtre oublié ne peut pas afficher les documents d’une autre boutique.

Avant de commencerCe qu’il faut savoir et avoir sous la mainEnviron 110 minutes

Ce que vous devez savoir

Votre projet

  • ~/projects/doc-assistant à la fin du module 3 : python -m pytest se termine par 62 passed (62 tests réussis). PostgreSQL fonctionne (docker compose up -d --wait db).
  • Le dépôt des exercices dans ~/projects/nextia-learning-labs. Vous copiez l’instantané end-of-m04 dans cette leçon.
  • Trois terminaux, chacun dans le dossier du projet avec l’environnement virtuel actif.

Cette leçon copie les fichiers du module entier. Les deux prochaines leçons expliquent les parties de cette même copie consacrées aux défaillances et au nettoyage. Testé avec Python 3.12 sur macOS. Les commandes PowerShell sont écrites, mais n’ont pas été exécutées.

Imaginez une banque qui loue des coffrets de sûreté. Au comptoir, l’employé regarde d’abord votre carte d’identité : qui vous êtes.

Ensuite, l’employé vous cherche dans la liste des titulaires de coffrets de la banque. Votre carte ne dit rien sur les coffrets. Si vous n’êtes pas sur la liste, l’employé dit « Je ne peux pas vous aider avec ça ». La réponse est la même pour un coffret qui n’existe pas. Un inconnu n’apprend donc rien.

Certains titulaires peuvent seulement regarder dans un coffret. D’autres peuvent aussi y déposer des objets et en retirer. La liste indique lesquels. Et la chambre forte a elle-même un deuxième verrou : le coffret 214 s’ouvre seulement avec la clé du coffret 214. Une erreur au comptoir n’ouvre pas le mauvais coffret.

L’assistant documentaire a besoin du même comptoir et de la même chambre forte. Larkfield et Bramble Books sont deux titulaires de coffrets. Leurs documents sont le contenu des coffrets.

Le problème : dans le module 3, tout le monde est Sam, partout

Section intitulée « Le problème : dans le module 3, tout le monde est Sam, partout »

À la fin du module 3, chaque requête agit comme un utilisateur d’exercice, Sam, dans la boutique indiquée par l’URL. Sam travaille chez Larkfield. Démarrez l’API du module 3 et demandez-lui qui vous êtes :

Fenêtre de terminal
curl -s http://127.0.0.1:8000/auth/session
{"user_id":"usr-sam","name":"","csrf_token":"","via":"dev"}

via: dev signifie que personne ne s’est connecté. Maintenant, Sam demande les documents de Bramble Books. La liste revient avec trois documents réservés au personnel de l’autre boutique : refund-approval-procedure, staff-discount et supplier-terms. Ensuite, Sam pose une question à l’assistant de Bramble :

Fenêtre de terminal
curl -s -X POST http://127.0.0.1:8000/v1/tenants/bramble/answers \
-H 'content-type: application/json' -d '{"question": "What is the staff discount?"}'

La réponse (abrégée) :

"answer":"Staff get 30 percent off books for themselves and their household."
"citations":[{"title":"Staff discount (staff only)","doc_key":"staff-discount","access":"staff", ...}]
"provider":"mock"

Un employé de Larkfield vient de lire une politique réservée au personnel d’une autre entreprise. Le fournisseur simulé a répondu, car personne n’avait enregistré cette question. Le passage l’indique clairement, donc un vrai modèle répondrait aussi.

La deuxième défaillance se trouve à l’intérieur d’une boutique. Omar est membre de Larkfield avec un accès en lecture seule. Il peut poser des questions, mais les procédures réservées au personnel ne lui sont pas accessibles. Dans le module 3, les scripts donnent à tout le monde le rôle staff (personnel) :

Fenêtre de terminal
python -m scripts.ask "What is the staff discount?" --tenant larkfield --user usr-omar --as-of 2026-10-09
Omar (staff) at Larkfield asks: What is the staff discount?
Passages found: 81007010cd4d staff-discount-and-perks v1, 7919a06cc2aa staff-discount-and-perks v1, 93cb6359874a privacy-policy v3, 6fddb68adafa privacy-policy v3, 2638b732560d support-team-routing v4
Answer (answerable): Staff get 20% off all products except gift cards, up to $2,000 of purchases per calendar year. It cannot be combined with other promotions or discount codes.

Rien ici ne ressemble à une erreur : les deux requêtes renvoient 200, avec de bonnes réponses et des citations valides. Une vérification d’accès manquante se cache derrière le parcours sans erreur. Le module 3 l’a omise volontairement pour créer d’abord un parcours. Maintenant, les critères A1 à A4 de Grace doivent être respectés.

L’idée : quatre vérifications, toujours dans le même ordre

Section intitulée « L’idée : quatre vérifications, toujours dans le même ordre »

La solution reprend la routine de l’employé de banque, en code exécuté avant chaque route d’une boutique. La première vérification est l’authentification : prouver qui envoie la requête. Les autres vérifications relèvent de l’autorisation : décider ce que cette personne peut faire. Un locataire est une organisation cliente qui partage l’application avec d’autres; ici, une boutique.

  1. Qui envoie la requête? Un navigateur connecté envoie un témoin de session. Un script envoie un jeton d’accès. Sans l’un ni l’autre, la réponse est 401.
  2. Cette personne est-elle membre de la boutique indiquée dans le chemin? L’API lit la table memberships. Sans ligne pour cette personne et cette boutique, la réponse est 404 Not found (introuvable). Une boutique qui n’existe pas reçoit exactement la même réponse.
  3. Le rôle permet-il cette action? Un propriétaire ou un membre du personnel peut téléverser et supprimer. Un membre en lecture seule peut seulement poser des questions et lire. Un rôle aux autorisations insuffisantes reçoit 403.
  4. Quelles lignes la requête peut-elle voir? Chaque requête SQL précise la boutique, et la base de données ajoute la sécurité au niveau des lignes. La recherche garde seulement les niveaux d’accès du rôle.
Une requête pour les documents de Larkfield passe quatre vérifications, de haut en bas. 1, qui envoie la requête : aucun jeton, aucun témoin ou un jeton qui échoue à une vérification mène à 401, non authentifié. 2, membre de larkfield : aucune ligne, comme pour Ines, Tomás ou une boutique inexistante, mène à 404 Not found (introuvable). 3, le rôle permet-il l'action : téléverser ou supprimer en lecture seule mène à 403, interdit. 4, quelles lignes : tenant_id larkfield, sécurité au niveau des lignes et accès public. À la fin : 200, 30 documents, les 6 documents réservés au personnel sont masqués.
L'ordre des vérifications pour la requête d'Omar. Chaque vérification a une sortie avec un code d'état. Seule une requête qui les passe toutes atteint les données. Même alors, elle voit seulement sa boutique et ses niveaux d'accès.
Description textuelle du diagramme

La requête d’Omar pour les documents de Larkfield rencontre quatre vérifications dans l’ordre. Vérification 1, login.identify() : sans jeton ni témoin valide, elle se termine par 401. Vérification 2, access.membership() : sans ligne d’adhésion, comme pour Ines, Tomás ou une boutique inventée, elle se termine par 404. Vérification 3, require_change() : un téléversement ou une suppression par un membre en lecture seule se termine par 403. La vérification 4 limite les lignes à Larkfield et, pour Omar, aux documents publics. Sa requête se termine par 200 et 30 documents.

Pourquoi 404 et non 403 pour une personne externe? Un 403 dirait « cette boutique existe, mais elle ne vous est pas accessible ». Cela indique à un inconnu quelles boutiques utilisent l’assistant. Le cours sur l’authentification appelle cet ordre identité, puis adhésion, puis rôle. Notez aussi ce que le jeton ne contient pas : une boutique ou un rôle. Le jeton indique seulement qui est la personne. La table des adhésions indique le reste, et l’API la lit à chaque requête. Ainsi, quand Grace retire un membre, le changement s’applique dès la prochaine requête.

Voici la même requête de liste, GET /v1/tenants/larkfield/documents, envoyée par sept personnes différentes. Avant de lire la dernière colonne, prédisez son contenu à partir des quatre vérifications.

Personne Adhésion à Larkfield Vérification décisive Résultat
personne (aucun jeton) – 1 401 unauthenticated (non authentifié)
Sam personnel – 200, 36 documents
Grace propriétaire – 200, 36 documents
Omar lecture seule 4 200, 30 documents (6 réservés au personnel masqués)
Ines aucune (propriétaire chez Bramble Books) 2 404 not_found (introuvable)
Tomás aucune 2 404 not_found
Sam, à /tenants/acme/ boutique inexistante 2 404 not_found

Le téléversement d’Omar s’arrête à la vérification 3. Le cas de Camille est intéressant : Camille fait partie du personnel de Larkfield et a un accès en lecture seule chez Bramble Books. Son rôle dépend de la boutique dans le chemin, jamais de son jeton. Le test tests/test_access.py vérifie toute cette matrice : personnes × boutiques × lister, poser une question et téléverser.

Dans le parcours standard, copiez la fin du module 4 par-dessus votre projet. Dans le parcours avec votre propre idée, faites la même chose dans une copie. Utilisez-la comme référence pour vos changements.

  1. Sauvegardez d’abord votre travail. Dans le dossier du projet, exécutez git add -A et git commit -m "End of Module 3". La copie de l’étape 3 écrase les fichiers modifiés.

  2. Récupérez les nouveaux instantanés :

    Fenêtre de terminal
    git -C ~/projects/nextia-learning-labs pull
  3. Copiez l’instantané par-dessus votre projet. Le module 4 ne supprime aucun fichier du module 3, donc une copie suffit :

    Fenêtre de terminal
    cp -R ~/projects/nextia-learning-labs/C27/snapshots/end-of-m04/. ~/projects/doc-assistant/

    Comme dans le module 3, récupérez vos propres fichiers de docs/ depuis votre commit (enregistrement des modifications) : git checkout -- docs. Le module 4 n’y modifie aucun fichier.

  4. Recréez .env à partir de .env.example, car les paramètres de connexion sont nouveaux : cp .env.example .env (PowerShell : Copy-Item .env.example .env -Force). Remettez ensuite le mot de passe de votre base de données à ses trois endroits.

  5. Créez les clés du fournisseur d’identité d’exercice et les deux secrets :

    Fenêtre de terminal
    python -m idp init
    Made a signing key (OR3Awot8TUBq8zIJ) and the clients in …/doc-assistant/.idp.
    Wrote the client secret of doc-assistant-web to …/doc-assistant/.env.
    Wrote a new SESSION_SECRET (the API signs its session cookies with it).
    The provider keeps only the client secret's SHA-256. Never commit .env or .idp/.

    Votre identifiant de clé diffère. .idp/ et .env sont dans .gitignore.

  6. Appliquez les deux nouvelles migrations à votre base de données, puis vérifiez l’état :

    Fenêtre de terminal
    python -m doc_assistant.migrate
    python -m doc_assistant.migrate --status
    applied 002_row_level_security
    applied 003_duplicate_safe_ingestion
    2 migration(s) applied.
    001_core applied
    002_row_level_security applied
    003_duplicate_safe_ingestion applied
  7. Exécutez les tests. La dernière ligne est 95 passed (95 tests réussis) :

    Fenêtre de terminal
    python -m pytest

Si l’étape 6 s’arrête avec une UniqueViolation, votre base de données contient deux fois le même fichier. Le cas de défaillance « La migration refuse votre base de données » dans Gérer les défaillances explique le problème et la solution.

La page connecte les personnes par l’API, avec le fournisseur d’identité d’exercice du cours sur l’authentification. Personnes inventées, aucun mot de passe, pour s’exercer seulement. L’API est un backend pour le frontend : le navigateur ne détient jamais de jeton, seulement un témoin signé par l’API.

  1. Dans le premier terminal, démarrez le fournisseur. Il affiche Practice identity provider: http://localhost:8400 (made-up people, no passwords) (fournisseur d’identité d’exercice : personnes inventées, aucun mot de passe).

    Fenêtre de terminal
    python -m idp
  2. Dans le deuxième terminal, démarrez l’API :

    Fenêtre de terminal
    fastapi dev doc_assistant/main.py
  3. Ouvrez http://127.0.0.1:8000. La page indique You are not signed in. (vous n’êtes pas connecté). Sélectionnez Sign in (se connecter). La page du fournisseur s’ouvre : choisissez Omar.

  4. Vérifiez que la page indique Signed in as Omar (connecté en tant qu’Omar), Your role : read only (votre rôle : lecture seule) et affiche 30 documents pour Larkfield.

La page du fournisseur d'identité d'exercice : se connecter à Document assistant (web). C'est le fournisseur d'identité d'exercice du cours. Il ne demande pas de mot de passe : choisissez une personne inventée. L'application demande : openid profile documents:read documents:write. Un bouton par personne, chacun avec une adresse courriel : Grace, Sam, Omar, Ines, Camille, Tomás et Kwame.
Le sélecteur de personnes du fournisseur d'exercice. Un vrai fournisseur demande un mot de passe et souvent un deuxième facteur. Celui-ci sert seulement à s'exercer. L’image est en anglais.
Une séquence entre le navigateur, l'API et le fournisseur d'exercice. Le navigateur demande /auth/login à l'API. L'API le redirige vers le fournisseur avec state, nonce et un défi PKCE, et définit un témoin de connexion signé de courte durée. La personne choisit Omar; le fournisseur redirige vers /auth/callback avec un code. L'API échange le code, avec le vérificateur PKCE et son secret client, contre un jeton d'identité et un jeton d'accès. Elle vérifie les deux et définit le témoin de session assistant_session. Il contient l'identifiant utilisateur, une expiration de 8 heures et un jeton CSRF, signés avec HMAC-SHA256. Les requêtes suivantes envoient le témoin. L'API lit chaque fois l'adhésion et le rôle dans la base de données.
Connexion avec le flux de code d'autorisation et PKCE, comme dans le cours sur l'authentification. Le navigateur reçoit un témoin signé et aucun jeton.
Description textuelle du diagramme

Le navigateur demande /auth/login à l’API, qui l’envoie au fournisseur avec un state aléatoire, un nonce et un défi PKCE. La personne choisit Omar. Le fournisseur renvoie le navigateur à /auth/callback avec un code à usage unique. L’API échange le code contre un jeton d’identité et un jeton d’accès, puis vérifie les deux. Ensuite, elle définit assistant_session : l’identifiant utilisateur, une expiration 8 heures plus tard et un jeton CSRF, signés avec SESSION_SECRET. Les requêtes suivantes envoient ce témoin, et l’API lit l’adhésion d’Omar à chaque requête.

Mais pourquoi ne pas garder une table de sessions, comme dans le cours sur l’authentification? Sam a choisi un témoin signé : aucune table, aucune tâche de nettoyage. Le coût est inscrit dans la revue des menaces. On ne peut pas annuler un témoin signé avant son expiration. Un témoin volé fonctionne donc pendant un maximum de 8 heures. Retirer une adhésion fonctionne toujours immédiatement, car le témoin ne contient ni boutique ni rôle. Pour un assistant de boutique avec des données d’exercice, Sam accepte cela. Pour une banque, vous garderiez la table de sessions.

Le témoin est HttpOnly, donc le JavaScript de la page ne peut pas le lire. Et chaque requête qui change quelque chose doit aussi envoyer l’en-tête X-CSRF-Token. Un autre site Web peut faire envoyer le témoin par votre navigateur, mais il ne peut pas lire le jeton.

L’équipe du cours a effectué la même connexion avec curl pour voir chaque étape cachée par le navigateur. Les valeurs des témoins et les codes sont remplacés par … :

GET /auth/login 302 location: http://localhost:8400/authorize?response_type=code&client_id=doc-assistant-web&…&code_challenge_method=S256
set-cookie: assistant_login=…; HttpOnly; Max-Age=600; Path=/; SameSite=lax
POST /authorize (the picker), Omar 302 location: http://127.0.0.1:8000/auth/callback?code=…&state=…
GET /auth/callback?code=…&state=… 302 location: /app/
set-cookie: assistant_session=…; HttpOnly; Max-Age=28800; Path=/; SameSite=lax
GET /auth/session 200 {"user_id":"usr-omar","name":"Omar","csrf_token":"…","via":"session"}
POST /v1/…/answers, no CSRF header 403 {"code":"csrf_failed","message":"This request needs the page's X-CSRF-Token header.", …}
POST /v1/…/answers, with the header 200 {"answerable": false, "answer": "The documents do not say what the staff discount is.", …}
the cookie with one character changed 401 {"code":"unauthenticated","message":"Sign in first.", …}
POST /auth/logout, with the header 200 {"signed_out":true}

Max-Age=28800 correspond aux 8 heures. Si un seul caractère du témoin change, sa signature devient invalide. L’API considère alors la requête comme anonyme : 401.

Les scripts, les tests et curl ne passent pas par les clics d’une page de connexion. Ils envoient un jeton d’accès dans l’en-tête Authorization. Le fournisseur d’exercice en crée un sur votre ordinateur, valide pendant 10 minutes. Dans le troisième terminal :

Fenêtre de terminal
OMAR=$(python -m idp token usr-omar)
curl -s http://127.0.0.1:8000/v1/me -H "Authorization: Bearer $OMAR"
{"user":{"user_id":"usr-omar","name":"Omar","email":"omar@larkfield.example"},"via":"token","memberships":[{"tenant_id":"larkfield","name":"Larkfield","role":"read_only"}]}

Créez des jetons pour Sam, Ines et Tomás de la même façon (SAM, INES, TOMAS). Exécutez ensuite le petit exemple pour de vrai. Chaque ligne montre le corps de la réponse et le code d’état :

no token, larkfield: {"code":"unauthenticated","message":"Sign in first.","request_id":"6211c18e31e94c61"} 401
Ines, larkfield: {"code":"not_found","message":"Not found.","request_id":"eb6e0a8d622b4da7"} 404
Tomás, larkfield: {"code":"not_found","message":"Not found.","request_id":"90ad388c14d448c0"} 404
Sam, acme: {"code":"not_found","message":"Not found.","request_id":"a1422a5b69384a8e"} 404
Sam asks at bramble: {"code":"not_found","message":"Not found.","request_id":"f7801f72b69640cc"} 404
Omar uploads: {"code":"forbidden","message":"Your role in Larkfield (read_only) cannot upload or delete documents.","request_id":"3f374c76ddcb46d3"} 403
a broken token: {"code":"unauthenticated","message":"The access token was refused: The token is not a JWT. (malformed).","request_id":"f05e4464721a4cc8"} 401

Les trois corps des réponses 404 sont identiques, sauf le request_id. L’attaque du début de cette leçon, où Sam interroge l’assistant de Bramble, se termine maintenant à la vérification 2. Le script du terminal la refuse aussi, car scripts/common.py utilise maintenant la même fonction d’adhésion. python -m scripts.ask "What is the staff discount?" --tenant bramble --user usr-sam se termine par doc_assistant.errors.ApiError: Not found. (introuvable).

Le code des vérifications est court. Ouvrez doc_assistant/deps.py :

def principal(request: Request, tenant: str) -> Principal:
who = identify(request) # 401 when nobody is signed in
with request.app.state.db.admin() as conn: # memberships: read on every request, never cached
p = membership(conn, who.user_id, tenant) # 404 when the caller is not a member of this shop
request.state.user_id, request.state.tenant = p.user_id, p.tenant_id
return p

Chaque route d’une boutique prend who: Principal = Depends(principal), donc aucune route ne peut sauter cette vérification. access.py associe chaque rôle à ses niveaux d’accès. Les routes de téléversement et de suppression appellent d’abord require_change(who). Les vérifications des jetons dans auth.py sont celles du cours sur l’authentification, avec l’audience doc-assistant.

Le deuxième verrou : la sécurité au niveau des lignes

Section intitulée « Le deuxième verrou : la sécurité au niveau des lignes »

Chaque requête SQL du projet indique tenant_id = %s. Mais un jour, quelqu’un écrit un rapport ou un correctif rapide qui l’oublie. La sécurité au niveau des lignes est une fonctionnalité de PostgreSQL. Des politiques sur une table décident, ligne par ligne, ce qu’une requête SQL peut voir et écrire. La base de données les applique à chaque requête SQL, que le filtre soit présent ou oublié. C’est le deuxième verrou de la chambre forte.

La migration 002_row_level_security.sql crée un rôle sans pouvoirs spéciaux, assistant_app. Elle crée aussi une politique sur chacune des quatre tables qui contiennent les données d’une boutique :

CREATE POLICY one_tenant ON chunks
USING (tenant_id = current_setting('app.tenant_id', true))
WITH CHECK (tenant_id = current_setting('app.tenant_id', true));

USING filtre les lignes qu’une requête SQL lit. WITH CHECK refuse les lignes qu’une requête SQL écrit. Exécutez vous-même la requête au filtre oublié dans psql (ouvrez-le avec docker compose exec db psql -U assistant -d assistant). D’abord comme utilisateur Compose, puis dans une transaction avec le rôle de l’API. Prédisez d’abord les trois décomptes.

SELECT tenant_id, count(*) FROM chunks GROUP BY tenant_id;
BEGIN;
SET LOCAL ROLE assistant_app;
SELECT tenant_id, count(*) FROM chunks GROUP BY tenant_id;
SELECT set_config('app.tenant_id', 'bramble', true);
SELECT tenant_id, count(*) FROM chunks GROUP BY tenant_id;
INSERT INTO answers (tenant_id, user_id, question, as_of, answerable, answer, provider, model, latency_ms)
VALUES ('larkfield', 'usr-ines', 'x', '2026-10-11', false, 'x', 'x', 'x', 1);
ROLLBACK;
larkfield | 185
bramble | 60
(2 rows)
...
(0 rows)
...
bramble | 60
(1 row)
ERROR: new row violates row-level security policy for table "answers"
La même requête SQL sans filtre de boutique, trois fois : comme utilisateur Compose, puis avec le rôle assistant_app, sans et avec app.tenant_id. Seule la dernière voit exactement une boutique.
Description textuelle du graphique

Un diagramme à trois colonnes. L’utilisateur Compose assistant voit 245 passages : 185 de Larkfield et 60 de Bramble Books. Le rôle assistant_app sans paramètre de boutique en voit 0. Le rôle assistant_app avec app.tenant_id défini à bramble en voit 60, seulement les passages de Bramble.

Pourquoi l’utilisateur Compose voit-il tout? SELECT rolname, rolsuper, rolbypassrls FROM pg_roles affiche assistant | t | t. L’image Docker en fait un superutilisateur, et les politiques ne s’appliquent jamais à un superutilisateur. C’est pourquoi db.py change de rôle au début de chaque transaction d’une boutique :

conn.execute("SELECT set_config('role', %s, true), set_config('app.tenant_id', %s, true)",
(self.app_role, tenant_id))

Le dernier argument, true, met fin aux deux paramètres avec la transaction, avant le retour de la connexion au pool de connexions (pool). Le cours sur l’authentification a mesuré le coût de cette instruction : une fraction de milliseconde.

Vérifications d’accès aux sources : ce qu’un membre en lecture seule récupère

Section intitulée « Vérifications d’accès aux sources : ce qu’un membre en lecture seule récupère »

La boutique n’est pas la seule frontière. Chez Larkfield, 6 des 36 documents sont réservés au personnel. Un membre en lecture seule ne doit jamais obtenir leurs passages, ni dans la liste, ni dans la recherche, ni dans une réponse. La recherche filtre par niveau d’accès avant de garder les 5 meilleurs passages. Ainsi, aucun passage masqué ne prend une place. Posez de nouveau la question d’Omar :

Fenêtre de terminal
python -m scripts.ask "What is the staff discount?" --tenant larkfield --user usr-omar --as-of 2026-10-09
Omar (read_only) at Larkfield asks: What is the staff discount?
Passages found: 93cb6359874a privacy-policy v3, 6fddb68adafa privacy-policy v3, 1dc2f10bbe79 policy-governance v2, b8eb17ce658e policy-governance v2, 3a423579caf1 privacy-policy v3
Answer (not answerable): The documents do not say what the staff discount is.
recorded chat-small | 3261 ms | tokens 946 in, 30 out | US$0.000110 | trace 2ccf6551e5af3f429bcab78026f52cf4

Comparez le résultat avec le début de cette leçon. Omar est maintenant read_only (en lecture seule), ses cinq passages sont tous publics, et la réponse est honnête : « les documents ne le précisent pas ». Sam obtient toujours la réponse de 20 %.

L'assistant documentaire connecté sous le nom d'Omar, chez Larkfield, avec le rôle en lecture seule. La question « Quel est le rabais du personnel? », datée du 9 octobre 2026, affiche cette réponse : « Aucune réponse dans les documents : les documents ne précisent pas le rabais du personnel. » Enregistrement : chat-small, 21 ms, 0,000119 $ US. En dessous, Documents : 30 documents (30 indexés).
La vue d'Omar : l'abstention honnête et 30 des 36 documents de Larkfield. Une capture de l'application de fin de cours, dont la page est identique à celle de fin du module 4. L’image est en anglais.

L’équipe du cours a vérifié les 11 questions réservées au personnel de la banque de questions, comme membre en lecture seule. Elle a utilisé de vraies réponses. La recherche a renvoyé 0 passage réservé au personnel, et le modèle s’est abstenu pour 10 questions. Pour la onzième, « Un client doit-il retourner un produit défectueux de 60 dollars couvert par la garantie? », il a répondu à partir de la politique de garantie publique. C’est permis : le document public y répond aussi.

Un autre endroit pouvait laisser fuiter des données : les enregistrements. On trouve un enregistrement par sa question, pas par ses passages. Omar aurait donc pu voir la réponse enregistrée de Sam. Le fournisseur de réponses enregistrées ne rejoue donc un enregistrement que si les passages de l’appelant comprennent tous les passages cités. Vous avez vu cette règle dans Intégrer la récupération; elle compte maintenant que les rôles diffèrent.

Utilisez les quatre vérifications dans chaque produit multilocataire, dès le premier jour où de vraies personnes se connectent. Chaque requête coûte une requête d’adhésion et une instruction supplémentaire par transaction : quelques millisecondes, contre environ une seconde pour un appel au modèle. Les vérifications ajoutent aussi un élément qui peut échouer : l’API a besoin des clés du fournisseur pour vérifier un jeton.

Ne sautez pas une couche parce qu’une autre existe. La vérification d’adhésion bloque les personnes externes, la sécurité au niveau des lignes intercepte un filtre oublié. Le filtre de niveau d’accès empêche les membres en lecture seule de voir le texte réservé au personnel.

Erreur courante

Chaque requête avec un jeton reçoit 503 identity_provider_unavailable

Symptôme : l’API démarre, mais chaque requête avec un jeton et le lien Sign in (se connecter) de la page répondent :

{"code":"identity_provider_unavailable","message":"The identity provider cannot be reached.","request_id":"a31de875e6b4407a"}

Cause : le fournisseur d’exercice ne fonctionne pas, ou utilise un autre port que celui de OIDC_ISSUER dans .env. L’API a besoin des clés publiques du fournisseur pour vérifier la signature d’un jeton. Elle les récupère auprès du fournisseur.

Solution : lancez python -m idp dans son propre terminal et vérifiez qu’il affiche la même adresse que OIDC_ISSUER. Si les requêtes échouent encore, redémarrez aussi l’API.

Erreur courante

La sécurité au niveau des lignes est activée, mais une requête voit encore les deux boutiques

Symptôme : dans psql ou un script, une requête qui a oublié WHERE tenant_id compte 245 passages, même après set_config('app.tenant_id', 'bramble', true).

Cause : la connexion utilise l’utilisateur Compose assistant, un superutilisateur. Les politiques ne s’appliquent jamais à un superutilisateur, et PostgreSQL ne donne aucun avertissement.

Solution : exécutez les opérations des boutiques avec db.tenant(...), qui passe au rôle assistant_app. Gardez db.admin() pour les rares tâches qui doivent accéder à plusieurs boutiques : migrations, chargement et recherche d’adhésion. En cas de doute, vérifiez SELECT current_user; dans la transaction.

Dans le parcours standard, votre projet correspond maintenant à l’instantané. Dans le parcours avec votre propre idée, faites les mêmes quatre vérifications pour vos utilisateurs et vos locataires. Écrivez vos rôles et leurs niveaux d’accès dans access.py, et vos adhésions dans les données d’identité.

Gardez ces preuves dans docs/evidence/ (ou à l’endroit indiqué dans votre plan de preuves) :

  • La sortie de python -m pytest tests/test_access.py tests/test_auth.py -v : chaque ligne de la matrice d’accès réussit.
  • Votre propre transcription curl du petit exemple : une ligne par appelant, avec le code de statut.
  • La transaction psql ci-dessus, exécutée sur votre base de données : les trois comptes et l’insertion refusée.
  • Une phrase dans votre revue des menaces sur votre choix de session et le risque accepté.

Liste de vérification

  • Une requête sans jeton ni témoin (cookie) reçoit 401 sur chaque route de boutique.
  • Un non-membre reçoit le même corps de réponse 404 pour une vraie boutique et une boutique inventée.
  • Un membre en lecture seule reçoit 403 pour un téléversement ou une suppression, et aucun passage réservé au personnel dans la liste, la recherche ou une réponse.
  • L’API exécute les requêtes des boutiques avec un rôle sans pouvoirs de superutilisateur et définit la boutique pour chaque transaction.
  • Les requêtes de la page qui modifient des données nécessitent le jeton CSRF.

Vérifiez votre compréhension

Ines est propriétaire de Bramble Books. Elle pose une question à /v1/tenants/larkfield/answers avec un jeton valide. Quelle vérification la bloque, avec quel statut, et pourquoi ce statut plutôt que 403?

Afficher la réponse

La vérification 2, celle de l’adhésion : aucune ligne d’adhésion ne relie Ines à Larkfield. L’API répond donc 404 not_found (introuvable), avec le corps « Not found. » (introuvable). Un statut 403 lui indiquerait que Larkfield existe et utilise l’assistant. Le corps de la réponse 404 est identique à celui d’une boutique inexistante, comme acme. Une personne externe n’apprend donc rien. Son jeton est valide : la vérification 1 réussit.

Vérifiez votre compréhension

Prédisez le résultat : dans une transaction sous assistant_app sans app.tenant_id défini, combien de passages SELECT count(*) FROM chunks renvoie-t-il? Et sous l'utilisateur Compose? Expliquez les deux résultats.

Afficher la réponse

Sous assistant_app sans boutique : 0. La politique compare le tenant_id de chaque ligne à current_setting('app.tenant_id', true), qui est vide (NULL). Aucune ligne ne correspond donc. C’est la valeur par défaut sûre. Sous l’utilisateur Compose assistant : les 245 passages (185 + 60), car c’est un superutilisateur. Les politiques ne s’appliquent jamais à un superutilisateur. C’est pourquoi db.tenant() change le rôle dans chaque transaction.

Vérifiez votre compréhension

Vérification pratique : avec le fournisseur et l'API en marche, créez un jeton pour Camille. Listez les documents des deux boutiques et essayez un téléversement dans chacune. Qu'obtenez-vous, et pourquoi?

Afficher la réponse

Chez Larkfield, elle fait partie du personnel : la liste contient 36 documents, et le téléversement est accepté (202). Chez Bramble Books, elle est en lecture seule. La liste contient 12 des 15 documents : les 3 documents réservés au personnel sont masqués. Un téléversement reçoit 403 forbidden (interdit) : « Your role in Bramble Books (read_only) cannot upload or delete documents. » (Votre rôle chez Bramble Books, en lecture seule, ne permet pas de téléverser ou de supprimer des documents.) Son jeton est le même dans les deux requêtes. Le rôle vient de l’adhésion à la boutique indiquée dans le chemin. Supprimez ensuite votre téléversement de test, ou exécutez python -m scripts.load_pack --reset.

Récapitulatif

  • Dans le module 3, Sam a lu le rabais réservé au personnel de Bramble, et Omar celui de Larkfield. Les deux requêtes ont renvoyé 200 avec de bonnes réponses : un parcours réussi peut cacher une vérification d’accès manquante.
  • Quatre vérifications s’exécutent pour chaque requête de boutique : qui (401), membre de cette boutique (404, même pour une boutique inventée), rôle (403) et quelles lignes.
  • Le navigateur conserve un témoin HttpOnly signé avec un jeton CSRF; les scripts envoient des jetons d’accès. Aucun ne contient de boutique ni de rôle : l’API lit l’adhésion à chaque requête.
  • La sécurité au niveau des lignes est le deuxième verrou : avec un filtre oublié, assistant_app voit une boutique ou rien. Elle ne s’applique jamais au superutilisateur de Compose.
  • Un membre en lecture seule récupère 0 passage réservé au personnel. Pour les 11 questions réservées au personnel, le modèle s’est abstenu 10 fois et a répondu une fois à partir d’un document public.

Ensuite, l’assistant apprend à bien gérer les échecs : fichiers refusés, téléversements en double et fournisseur de modèle qui ne répond pas.

Leçon suivante : Gérer les défaillances