Gérer l'authentification et les sessions

Le défi de l’authentification

La majorité des workflows d’automatisation nécessitent d’être connecté à un service. Tant que votre agent reste sur des pages publiques, tout va bien ; dès qu’il doit ouvrir un CRM, un back-office ou une boîte mail, il se heurte à un mur de connexion. Gérer l’authentification avec Computer Use demande donc des stratégies spécifiques, car votre agent doit interagir avec des formulaires de connexion, des 2FA, des SSO et des sessions persistantes. Chacun de ces quatre obstacles se traite différemment, et c’est ce que nous allons dérouler ici.

Connexion par formulaire

Le cas le plus simple consiste à remplir un formulaire de connexion avec un email et un mot de passe. Vous décrivez la séquence à l’agent comme vous la décririez à un collègue qui découvre l’application, en terminant par l’attente du chargement du tableau de bord : c’est ce dernier point qui évite que l’agent enchaîne trop vite sur une page encore vide.

task = """
Connecte-toi au site :
1. Clique sur le champ email et tape : [email protected]
2. Clique sur le champ mot de passe et tape : MonMotDePasse123
3. Clique sur le bouton "Se connecter"
4. Attends que le dashboard se charge
"""

Ce prompt est parfait pour une démonstration et catastrophique en production : le mot de passe est écrit en clair dans le code, donc dans votre dépôt Git, dans vos logs et dans l’historique de vos appels API. La règle est simple, ne codez jamais les identifiants dans vos prompts en production. Passez par des variables d’environnement, et l’agent reçoit exactement le même prompt sans que le secret n’ait jamais transité par votre code source.

import os

credentials = {
    "email": os.environ["APP_EMAIL"],
    "password": os.environ["APP_PASSWORD"],
}

task = f"""
Connecte-toi au site avec :
- Email : {credentials['email']}
- Mot de passe : {credentials['password']}
"""

Réutiliser les cookies de session

Se reconnecter à chaque exécution coûte du temps, des tokens, et déclenche parfois des alertes de sécurité côté service. Pour l’éviter, sauvegardez les cookies à la fin d’une session et restaurez-les au démarrage de la suivante. Deux fonctions suffisent : l’une sérialise les cookies du contexte Playwright dans un fichier, l’autre les réinjecte et signale par un booléen si un fichier de session existait.

import json

def save_session(context, filepath="session.json"):
    """Sauvegarde les cookies de la session courante."""
    cookies = context.cookies()
    with open(filepath, "w") as f:
        json.dump(cookies, f)

def restore_session(context, filepath="session.json"):
    """Restaure une session précédemment sauvegardée."""
    try:
        with open(filepath, "r") as f:
            cookies = json.load(f)
        context.add_cookies(cookies)
        return True
    except FileNotFoundError:
        return False

Intégré au workflow, cela donne une logique en deux temps : on tente d’abord la restauration, on vérifie que la session est encore valide, et on ne repasse par la connexion complète qu’en cas d’échec. Notez que les cookies sont resauvegardés après chaque étape, y compris après l’exécution de la tâche, car beaucoup de services renouvellent leur jeton de session en cours de route.

def authenticated_workflow(task: str, login_url: str):
    """Workflow avec gestion automatique de la session."""
    pw = sync_playwright().start()
    browser = pw.chromium.launch(headless=True)
    context = browser.new_context(
        viewport={"width": 1280, "height": 720}
    )
    
    # Essayer de restaurer la session
    if restore_session(context):
        page = context.new_page()
        page.goto(login_url)
        # Vérifier si la session est encore valide
        if is_logged_in(page):
            print("Session restaurée avec succès")
            run_agent(task, page=page)
            save_session(context)
            return
    
    # Sinon, se connecter
    page = context.new_page()
    page.goto(login_url)
    run_agent("Connecte-toi avec les identifiants fournis", page=page)
    save_session(context)
    
    # Puis exécuter la tâche
    run_agent(task, page=page)
    save_session(context)  # Mettre à jour les cookies

Gérer 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 authenticator. C’est précisément son but : elle est conçue pour qu’un automate ne puisse pas la franchir seul. Deux approches coexistent selon le facteur utilisé, et le choix du facteur au moment de créer le compte de service détermine si votre workflow pourra tourner sans surveillance.

TOTP automatisé

Si vous utilisez une application TOTP comme Google Authenticator ou Authy, le code affiché n’est qu’une fonction du secret partagé et de l’horloge. Vous pouvez donc le générer programmatiquement et le transmettre à l’agent au moment où le champ apparaît, sans aucune intervention.

import pyotp

totp_secret = os.environ["TOTP_SECRET"]
totp = pyotp.TOTP(totp_secret)
code = totp.now()

task = f"""
Après la connexion, un champ de code 2FA apparaît.
Entre le code : {code}
Puis clique sur "Vérifier".
"""

Attente manuelle

Les facteurs non automatisables, SMS ou notification push, imposent 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 interrompue. C’est une solution acceptable pour un traitement lancé à la main, beaucoup moins pour un cron nocturne.

def wait_for_2fa(page):
    """Pause l'agent 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 la validation

Gérer les SSO (Single Sign-On)

Les connexions SSO (Google, Microsoft, SAML) redirigent vers un fournisseur d’identité externe, ce qui signifie que votre agent change de domaine en cours de route et retrouve une interface qu’il n’a jamais vue. Votre prompt doit donc annoncer la redirection à l’avance et décrire le parcours chez le fournisseur, sinon l’agent interprète le changement de page comme une erreur et tente de revenir en arrière.

task = """
Clique sur "Se connecter avec Google".
Tu seras redirigé vers la page de connexion Google.
1. Entre l'email dans le champ affiché
2. Clique sur "Suivant"
3. Entre le mot de passe
4. Clique sur "Suivant"
5. Si une vérification est demandée, attends
6. Tu seras redirigé vers l'application
"""

Détecter l’état de connexion

Toute cette mécanique repose sur une question à laquelle il faut savoir répondre de façon fiable : sommes-nous connectés ? Une fonction dédiée croise deux signaux, l’URL courante d’abord, puisqu’une redirection vers /login est sans ambiguïté, puis la présence d’un élément réservé aux utilisateurs authentifiés, typiquement le menu de compte. Le premier test est instantané, le second couvre les applications qui affichent la page de connexion sans changer d’URL.

def is_logged_in(page) -> bool:
    """Vérifie si la session est active."""
    # Vérification par URL
    if "/login" in page.url or "/signin" in page.url:
        return False
    
    # Vérification par élément DOM
    try:
        page.wait_for_selector("[data-testid=user-menu]", timeout=3000)
        return True
    except:
        return False

Sécurité des identifiants

En pratique, cette règle se décline en quelques habitudes qui ne coûtent presque rien une fois prises. Les identifiants vivent dans des variables d’environnement, alimentées en développement par un fichier .env que vous excluez immédiatement du contrôle de version via .gitignore — cet oubli est la première cause de fuite de secrets sur les dépôts publics. En production, remplacez ce fichier par un gestionnaire de secrets, Vault ou AWS Secrets Manager, qui délivre les valeurs à la demande et trace les accès. Prévoyez une rotation régulière des mots de passe et des tokens API, de sorte qu’une fuite ancienne n’ouvre plus rien. Enfin, filtrez vos logs pour ne jamais y enregistrer de données sensibles : un agent qui journalise fidèlement chaque frappe recopie aussi les mots de passe.

Points clés à retenir

• Utilisez les cookies de session pour éviter de vous reconnecter à chaque exécution
• Le TOTP peut être automatisé si vous avez le secret partagé
• Les SSO nécessitent un suivi des redirections multi-domaines
• Ne stockez jamais d’identifiants dans le code ou les prompts — utilisez des variables d’environnement
• Vérifiez toujours l’état de connexion avant de lancer un workflow