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. Gérer l’authentification avec Computer Use demande des stratégies spécifiques car votre agent doit interagir avec des formulaires de connexion, des 2FA, des SSO et des sessions persistantes.

Connexion par formulaire

Le cas le plus simple : remplir un formulaire de connexion avec email et mot de passe.

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
"""

Attention : ne codez jamais les identifiants dans vos prompts en production. Utilisez des variables d’environnement :

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

Pour éviter de vous reconnecter à chaque exécution, sauvegardez et restaurez les cookies :

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égrez cela dans votre workflow :

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 (code SMS, application authenticator). Plusieurs approches :

TOTP automatisé

Si vous utilisez une application TOTP (Google Authenticator, Authy), vous pouvez générer le code programmatiquement :

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

Pour les 2FA non automatisables (SMS, push notification) :

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. Votre agent doit suivre ces redirections :

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

Créez une fonction qui vérifie si l’agent est connecté :

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

Bonnes pratiques :

• Variables d’environnement pour les identifiants
• Fichiers .env exclus du contrôle de version (.gitignore)
• Gestionnaires de secrets en production (Vault, AWS Secrets Manager)
• Rotation régulière des mots de passe et tokens API
• Logs filtrés pour ne jamais enregistrer de données sensibles

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