Terminez d'abord "Authentification, jetons et gestion sécurisée des identifiants" pour débloquer cette leçon.Aller à la leçon précédente

Aperçu du projet

Dans cette leçon culminante, vous allez construire un agent IA complet qui réalise quatre tâches du monde réel au nom d’un utilisateur authentifié : vérifier l’identité par l’authentification, lire et écrire des enregistrements dans une base de données, appeler des API externes pour récupérer ou envoyer des données, et faire respecter le contrôle d’accès basé sur les rôles (RBAC) afin que les utilisateurs voient uniquement ce qui leur est permis de voir. C’est le point d’intégration où chaque concept précédent du cours se connecte.

L’agent que vous construisez suit un modèle requête-réponse : un utilisateur envoie une requête, l’agent vérifie qui est l’utilisateur, détermine ce que l’utilisateur est autorisé à faire, puis interroge la base de données, appelle une API, ou les deux, et renvoie un résultat. Nous utiliserons Python pour la logique de l’agent, une base de données SQL pour la persistance, une API externe simulée pour les données externes, et un mécanisme JWT (JSON Web Token) simple pour l’authentification.

Architecture et configuration

Avant d’écrire du code, traçons les quatre éléments mobiles et la manière dont ils se connectent. L’utilisateur envoie une requête avec un jeton JWT. L’agent valide le jeton, extrait l’ID utilisateur et le rôle, puis dirige la requête soit vers un gestionnaire de base de données, soit vers un appelateur d’API en fonction de l’intention de l’utilisateur. Le gestionnaire de base de données utilise des requêtes SQL paramétrées pour prévenir les injections. L’appelant d’API joint le même JWT aux requêtes sortantes afin que le service externe puisse vérifier indépendamment l’émetteur.

python
from dataclasses import dataclass
@dataclass
class UserContext:
user_id: int
role: str
token: str

Cet objet UserContext voyage avec chaque appel interne. Une fois qu’une requête entre dans l’agent, le contexte y est apposé et chaque fonction en aval reçoit le même contexte, de sorte que les vérifications d’autorisation se produisent à chaque étape, et pas seulement au point d’entrée.

Mise en œuvre de l’authentification

L’authentification consiste à prouver qui est l’utilisateur. Nous utiliserons un jeton simple de type JWT : une chaîne encodée en base64 contenant l’ID utilisateur, le rôle et un horodatage d’expiration, signée avec une clé secrète partagée. En production, on utiliserait une bibliothèque comme PyJWT, mais ici nous laissons cela minimal pour que vous puissiez voir les mécanismes.

python
import base64, json, hmac, hashlib, time
SECRET = "change-me-in-production"
def create_token(user_id: int, role: str) -> str:
payload = {"uid": user_id, "role": role, "exp": int(time.time()) + 3600}
body = base64.urlsafe_b64encode(json.dumps(payload).encode()).decode()
sig = hmac.new(SECRET.encode(), body.encode(), hashlib.sha256).hexdigest()
return f"{body}.{sig}"
def verify_token(token: str) -> UserContext:
body, sig = token.split(".")
expected = hmac.new(SECRET.encode(), body.encode(), hashlib.sha256).hexdigest()
if not hmac.compare_digest(sig, expected):
raise PermissionError("Invalid token signature")
payload = json.loads(base64.urlsafe_b64decode(body))
if payload["exp"] < int(time.time()):
raise PermissionError("Token expired")
return UserContext(user_id=payload["uid"], role=payload["role"], token=token)

La fonction verify_token est le gardien. Chaque point d’accès protégé l’appelle en premier. Si le jeton est altéré, expiré ou manquant, la requête est rejetée avant l’exécution du code de base de données ou d’API.

Interroger la base de données en toute sécurité

Avec l’authentification effectuée, l’étape suivante consiste à permettre à l’agent de lire les enregistrements des utilisateurs. La règle cruciale est : ne jamais construire du SQL par concaténation de chaînes. Utilisez toujours des requêtes paramétrées afin que l’entrée utilisateur soit traitée comme des données, et non comme du SQL exécutable.

python
import sqlite3
def get_user_orders(ctx: UserContext, target_user_id: int) -> list:
conn = sqlite3.connect("app.db")
cur = conn.cursor()
cur.execute("SELECT id, product, total FROM orders WHERE user_id = ?", (target_user_id,))
rows = cur.fetchall()
conn.close()
return rows

Remarquez comment l’ID utilisateur est passé en paramètre sous forme de tuple, et non interpolé dans la chaîne. Cette habitude unique bloque les injections SQL, qui est l’attaque la plus courante sur les bases de données.

Appels d’API externes

De nombreuses tâches d’agent nécessitent des données que la base de données ne possède pas, comme le statut d’expédition d’un coursier ou la météo pour un itinéraire de livraison. L’agent appelle une API HTTP externe, en transmettant le même JWT afin que le service externe puisse vérifier l’appelant.

python
import urllib.request
def get_shipping_status(ctx: UserContext, order_id: int) -> dict:
req = urllib.request.Request(
f"https://api.courier.example/orders/{order_id}",
headers={"Authorization": f"Bearer {ctx.token}"}
)
with urllib.request.urlopen(req) as resp:
return json.loads(resp.read())

Le jeton est transféré sans être généré à nouveau. Cela permet au service de coursier d’enregistrer qui a demandé et d’appliquer ses propres limites de débit par utilisateur.

Renforcement du contrôle d’accès basé sur les rôles

L’authentification indique qui est l’utilisateur. L’autorisation (RBAC) indique ce qu’il est autorisé à faire. L’endroit le plus propre pour faire respecter cela est une petite fonction de politique appelée à chaque point d’entrée.

python
def require_role(ctx: UserContext, allowed: list[str]):
if ctx.role not in allowed:
raise PermissionError(f"Role '{ctx.role}' not permitted")
python
def list_all_orders(ctx: UserContext) -> list:
require_role(ctx, ["admin"])
conn = sqlite3.connect("app.db")
cur = conn.cursor()
cur.execute("SELECT id, user_id, product, total FROM orders")
rows = cur.fetchall()
conn.close()
return rows

Un utilisateur régulier qui appelle list_all_orders se voit refuser l’accès. Un administrateur qui l’appelle obtient la table complète. La vérification de politique est sur une ligne, mais c’est la différence entre un système sûr et une fuite de données.

Mettre tous les éléments ensemble

La fonction principale de l’agent relie l’authentification, l’accès à la base de données, les appels API et le RBAC en un seul flux.

python
def handle_request(token: str, intent: str, params: dict):
ctx = verify_token(token)
if intent == "my_orders":
return get_user_orders(ctx, params["user_id"])
elif intent == "all_orders":
return list_all_orders(ctx)
elif intent == "shipping":
return get_shipping_status(ctx, params["order_id"])
else:
raise ValueError("Unknown intent")

Chaque chemin commence par verify_token. Chaque chemin qui touche des données sensibles appelle require_role. Chaque requête à la base de données est paramétrée. Chaque appel API sortant porte le jeton de l’utilisateur. Ces quatre habitudes, répétées partout, sont ce qui rend l’agent prêt pour la production.

diagramme de flux montrant la requête utilisateur entrant dans l’agent, se bifurquant via verify_token, puis routant vers la vérification require_role, puis se scindant en chemin de requête vers la base de données ou vers l’appel API externe, les deux chemins revenant à l’utilisateur

Résumé

Vous avez désormais un agent de bout en bout fonctionnel. L’authentification prouve l’identité par des jetons signés. Les requêtes SQL paramétrées lisent et écrivent les données sans risque d’injection. Les appels API sortants réutilisent le même token afin que les services externes puissent auditer et limiter le débit par utilisateur. Le contrôle d’accès basé sur les rôles est présent à chaque point d’entrée, pas seulement à la porte d’entrée, de sorte que l’escalade de privilèges nécessite de contourner plusieurs vérifications. Lorsque vous construisez de vrais agents, le schéma est le même : authentifier une fois, autoriser partout, paramétrer toujours, et propager le contexte à travers chaque appel.

Entraînement

Point de contrôle de la leçon

Révisez la leçon et recevez des conseils sur votre travail.

0/1
Répondu · 0/1