Gestion de l'authentification et des sessions
Pe această pagină
Leçon réécrite le 3 novembre 2026 sur la base du guide Computer use d’OpenAI et de la documentation d’authentification de Playwright. La version précédente plaçait les mots de passe et les codes 2FA directement dans l’invite envoyée au modèle, y compris via des variables d’environnement, ce qui n’empêche pas leur transmission, et déléguait la connexion SSO à l’agent. Désormais, votre code gère les secrets, l’état de la session est sauvegardé via
storage_state, et le SSO est effectué une seule fois manuellement. Sources : Computer use · Playwright, authentication.
Le défi de l’authentification
La plupart des flux d’automatisation nécessitent d’être connecté à un service. Tant que votre agent reste sur des pages publiques, tout fonctionne bien ; dès qu’il doit ouvrir un CRM, un back-office ou une boîte mail, il se heurte à un mur de connexion. Les formulaires, la 2FA, le SSO et les sessions persistantes requièrent chacun une gestion spécifique, mais une règle les régit tous : le modèle ne voit jamais un secret.
Connexion par formulaire
La tentation est de dicter la séquence à l’agent, identifiants inclus :
# NE FAITES PAS CECI : le mot de passe entre dans la requête envoyée à l'API
task = """
Connectez-vous au site :
1. Cliquez sur le champ email et tapez : [email protected]
2. Cliquez sur le champ mot de passe et tapez : MyPassword123
3. Cliquez sur le bouton "Se connecter"
"""
Lire le mot de passe depuis une variable d’environnement avant de l’insérer dans l’invite ne change rien : il laisse toujours votre infrastructure dans la requête, il est conservé avec la réponse (les réponses sont stockées par défaut, voir leçon 12) et il peut fuir dans vos journaux. OpenAI recommande de garder les identifiants hors du texte des pages et des captures d’écran. La solution consiste à faire remplir le formulaire de connexion par votre code avec Playwright, puis à passer la main à l’agent une fois la session ouverte.
import os
def log_in(page, login_url: str):
"""Connexion effectuée par votre code : le modèle ne voit jamais le mot de passe."""
page.goto(login_url)
page.get_by_label("Email").fill(os.environ["APP_EMAIL"])
page.get_by_label("Password").fill(os.environ["APP_PASSWORD"])
page.get_by_role("button", name="Log in").click()
page.wait_for_load_state("networkidle")
Adaptez les libellés Email et Password à votre application. C’est l’un des rares endroits du flux où un sélecteur est pleinement justifié : une page de connexion change rarement et les enjeux de sécurité l’emportent sur la flexibilité.
Réutilisation de l’état de session
Se connecter à chaque exécution fait perdre du temps et peut parfois déclencher des alertes de sécurité côté service. Playwright permet de sauvegarder l’état d’un contexte (cookies, stockage local, IndexedDB) dans un fichier, puis de créer un nouveau contexte à partir de ce fichier.
import os
def save_session(context, filepath="session.json"):
"""Sauvegarde l'état actuel de la session."""
context.storage_state(path=filepath)
def new_context_with_session(browser, filepath="session.json"):
"""Crée un contexte à partir d'une session sauvegardée, si elle existe."""
options = {"viewport": {"width": 1280, "height": 720}}
if os.path.exists(filepath):
options["storage_state"] = filepath
return browser.new_context(**options)
Intégré au flux de travail, cela crée une logique en deux étapes : partir de la session sauvegardée, vérifier qu’elle est toujours valide, et ne repasser par la connexion que si cela échoue. L’état est sauvegardé à nouveau après la tâche, car de nombreux services renouvellent leur jeton de session en cours de route.
from playwright.sync_api import sync_playwright
def authenticated_workflow(task: str, login_url: str):
"""Flux de travail avec réutilisation de session."""
pw = sync_playwright().start()
browser = pw.chromium.launch(headless=True)
try:
context = new_context_with_session(browser)
page = context.new_page()
page.goto(login_url)
if is_logged_in(page):
print("Session restaurée avec succès")
else:
log_in(page, login_url) # votre code, pas l'agent
if not is_logged_in(page):
raise RuntimeError("Connexion impossible : vérifiez les identifiants ou la 2FA")
save_session(context)
result = run_agent(task, page=page)
save_session(context) # mise à jour de l'état
return result
finally:
browser.close()
pw.stop()
Traitez le fichier de session comme un mot de passe : Playwright avertit qu’il peut contenir des cookies et des en-têtes permettant l’usurpation de compte, et déconseille fortement de le versionner, même dans un dépôt privé. Stockez-le avec vos secrets.
Gestion de l’authentification à deux facteurs (2FA)
La 2FA pose un défi car elle nécessite souvent une intervention humaine, qu’il s’agisse d’un code SMS ou d’une application d’authentification. C’est précisément son but : elle est conçue pour qu’un automate ne puisse pas la contourner seul. Deux approches coexistent selon le facteur utilisé, et le choix du facteur lors de la création du compte de service détermine si votre flux peut s’exécuter sans surveillance.
TOTP automatisé
Si le compte utilise une application TOTP comme Google Authenticator ou Authy, le code affiché n’est qu’une fonction du secret partagé et de l’horloge. Votre code peut donc le générer et le saisir lui-même, sans le montrer au modèle.
import os
import pyotp
def enter_totp_code(page):
"""Saisit le code TOTP actuel : le secret et le code restent dans votre code."""
totp = pyotp.TOTP(os.environ["TOTP_SECRET"])
page.get_by_label("Verification code").fill(totp.now())
page.get_by_role("button", name="Verify").click()
Réfléchissez à ce que vous faites : stocker le secret TOTP aux côtés du mot de passe réduit la 2FA à un seul facteur, puisque les deux secrets vivent au même endroit. Réservez cette approche à un compte de service dédié, avec des droits limités au strict minimum.
Attente manuelle
Les facteurs non automatisables, tels que les SMS ou les notifications push, nécessitent une pause explicite. L’agent s’arrête, un opérateur valide sur son téléphone, puis la boucle reprend là où elle s’était arrêtée. C’est une solution acceptable pour un processus lancé manuellement, beaucoup moins pour une tâche cron nocturne.
def wait_for_2fa(page):
"""Met l'agent en pause et attend la validation manuelle."""
print("2FA requise. Validez manuellement, puis appuyez sur Entrée.")
input("Appuyez sur Entrée pour continuer...")
# L'agent reprend après validation
Gestion du SSO (Single Sign-On)
Les connexions SSO (Google, Microsoft, SAML) redirigent vers un fournisseur d’identité externe : l’agent changerait de domaine en cours de flux et devrait y saisir des identifiants. Ne déléguez pas cette étape à l’agent. Effectuez la connexion SSO une seule fois, manuellement, dans un navigateur visible contrôlé par Playwright, puis sauvegardez l’état de la session : les exécutions suivantes partiront de cet état.
def manual_sso_login(login_url: str, filepath="session.json"):
"""Un humain se connecte dans un navigateur visible ; la session est sauvegardée."""
pw = sync_playwright().start()
browser = pw.chromium.launch(headless=False)
context = browser.new_context()
page = context.new_page()
page.goto(login_url)
input("Connectez-vous dans la fenêtre ouverte, puis appuyez sur Entrée...")
save_session(context, filepath)
browser.close()
pw.stop()
Lorsque la session expirera finalement, le flux de travail devra s’arrêter et demander à nouveau cette connexion humaine. Ajoutez cette instruction aux directives de l’agent : s’il se retrouve devant une page de fournisseur d’identité, il s’arrête et le signale au lieu de tenter quoi que ce soit.
Détection de l’état de connexion
Toute cette mécanique repose sur une question à laquelle vous devez pouvoir répondre de manière fiable : sommes-nous connectés ? Une fonction dédiée croise deux signaux : d’abord l’URL actuelle, car une redirection vers /login est sans équivoque, puis la présence d’un élément réservé aux utilisateurs authentifiés, typiquement le menu du compte. Le premier test est instantané, le second couvre les applications qui affichent la page de connexion sans changer l’URL.
from playwright.sync_api import TimeoutError as PlaywrightTimeoutError
def is_logged_in(page) -> bool:
"""Vérifie si la session est active."""
# Vérification de l'URL
if "/login" in page.url or "/signin" in page.url:
return False
# Vérification de l'élément DOM
try:
page.wait_for_selector("[data-testid=user-menu]", timeout=3000)
return True
except PlaywrightTimeoutError:
return False
Le except cible précisément l’expiration du délai d’attente : un except: nu avalerait aussi une interruption clavier ou une vraie erreur de programmation, que vous voulez voir remonter.
Sécurité des identifiants
„Ne stockez jamais de mots de passe dans votre code source, vos invites ou vos journaux.“
En pratique, cette règle se décline en quelques habitudes qui ne coûtent presque rien une fois adoptées. Les identifiants vivent dans des variables d’environnement, alimentés en développement par un fichier .env que vous excluez immédiatement du contrôle de version via .gitignore — cette omission est une cause classique de fuites de secrets sur les dépôts publics. En production, remplacez ce fichier par un gestionnaire de secrets, tel que Vault ou AWS Secrets Manager, qui délivre les valeurs à la demande et trace les accès. Seul votre code les lit, jamais le modèle. Prévoyez une rotation régulière des mots de passe et des jetons API, afin qu’une ancienne fuite n’ouvre plus rien. Enfin, filtrez vos journaux pour n’y jamais enregistrer de données sensibles : un agent qui journalise fidèlement chaque frappe copie aussi ce qu’on lui a fait taper.
Puncte cheie
- Le modèle ne voit jamais un secret : votre code saisit le mot de passe et le code 2FA avec Playwright
- Sauvegardez l’état de la session avec
storage_stateet traitez ce fichier comme un secret - Le TOTP est automatisé côté code, réservé à un compte de service aux droits limités
- Effectuez la connexion SSO une seule fois manuellement, puis réutilisez la session sauvegardée
- Vérifiez toujours l’état de connexion avant de lancer un flux de travail