Gestire autenticazione e sessioni
In questa pagina
Lezione riscritta il 3 novembre 2026 sulla base della guida Computer use di OpenAI e della documentazione sull’autenticazione di Playwright. La versione precedente inseriva password e codici 2FA direttamente nel prompt inviato al modello, anche tramite variabili d’ambiente (cosa che non ne impedisce la trasmissione), e delegava il login SSO all’agente. Ora il tuo codice gestisce i segreti, lo stato della sessione viene salvato con
storage_statee l’SSO viene eseguito una volta manualmente. Fonti: Computer use · Playwright, authentication.
La sfida dell’autenticazione
La maggior parte dei flussi di automazione richiede di essere connessi a un servizio. Finché il tuo agente rimane su pagine pubbliche, tutto funziona; nel momento in cui deve aprire un CRM, un back-office o una casella di posta, si scontra con un muro di login. Moduli, 2FA, SSO e sessioni persistenti richiedono ciascuno una gestione specifica, ma una regola li governa tutti: il modello non deve mai vedere un segreto.
Login basato su moduli
La tentazione è dettare la sequenza all’agente, credenziali incluse:
# NON FARLO: la password finisce nella richiesta inviata alle API
task = """
Accedi al sito:
1. Clicca sul campo email e digita: [email protected]
2. Clicca sul campo password e digita: MyPassword123
3. Clicca sul pulsante "Log in"
"""
Leggere la password da una variabile d’ambiente prima di inserirla nel prompt non cambia nulla: lascia comunque le tue infrastrutture esposte nella richiesta, viene conservata insieme alla risposta (le risposte sono salvate di default, vedi Lezione 12) e può finire nei log. OpenAI raccomanda di tenere le credenziali fuori dal testo delle pagine e dagli screenshot. La soluzione è far compilare il modulo di login al tuo codice con Playwright, per poi passare il controllo all’agente una volta aperta la sessione.
import os
def log_in(page, login_url: str):
"""Login eseguito dal tuo codice: il modello non vede mai la password."""
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")
Adatta le etichette Email e Password alla tua applicazione. Questo è uno dei pochi casi nel flusso di lavoro in cui un selettore è pienamente giustificato: una pagina di login cambia raramente e i rischi per la sicurezza superano la necessità di flessibilità.
Riutilizzare lo stato della sessione
Effettuare il login a ogni esecuzione fa perdere tempo e può talvolta attivare alert di sicurezza lato servizio. Playwright può salvare lo stato di un contesto (cookie, local storage, IndexedDB) su file, per poi creare un nuovo contesto a partire da quel file.
import os
def save_session(context, filepath="session.json"):
"""Salva lo stato corrente della sessione."""
context.storage_state(path=filepath)
def new_context_with_session(browser, filepath="session.json"):
"""Crea un contesto da una sessione salvata, se esiste."""
options = {"viewport": {"width": 1280, "height": 720}}
if os.path.exists(filepath):
options["storage_state"] = filepath
return browser.new_context(**options)
Integrato nel flusso di lavoro, questo crea una logica in due passaggi: parti dalla sessione salvata, verifica che sia ancora valida ed effettua nuovamente il login solo in caso di fallimento. Lo stato viene salvato di nuovo dopo il task, perché molti servizi rinnovano il token di sessione durante l’uso.
from playwright.sync_api import sync_playwright
def authenticated_workflow(task: str, login_url: str):
"""Flusso di lavoro con riutilizzo della sessione."""
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("Sessione ripristinata con successo")
else:
log_in(page, login_url) # tuo codice, non l'agente
if not is_logged_in(page):
raise RuntimeError("Login impossibile: verifica credenziali o 2FA")
save_session(context)
result = run_agent(task, page=page)
save_session(context) # aggiorna lo stato
return result
finally:
browser.close()
pw.stop()
Tratta il file di sessione come una password: Playwright avverte che può contenere cookie e header che consentono l’impersonificazione dell’account e sconsiglia vivamente di metterlo sotto controllo versione, anche in un repository privato. Conservalo insieme ai tuoi segreti.
Gestire l’autenticazione a due fattori (2FA)
Il 2FA rappresenta una sfida perché spesso richiede un intervento umano, che si tratti di un codice SMS o di un’app authenticator. È proprio questo il suo scopo: è progettato affinché un automa non possa aggirarlo da solo. Coesistono due approcci a seconda del fattore utilizzato; la scelta del fattore al momento della creazione dell’account di servizio determina se il tuo flusso di lavoro può essere eseguito senza supervisione.
TOTP automatizzato
Se l’account usa un’app TOTP come Google Authenticator o Authy, il codice visualizzato è solo una funzione del segreto condiviso e dell’orologio. Il tuo codice può quindi generarlo e inserirlo da solo, senza mostrarlo al modello.
import os
import pyotp
def enter_totp_code(page):
"""Inserisce il codice TOTP corrente: segreto e codice restano nel tuo codice."""
totp = pyotp.TOTP(os.environ["TOTP_SECRET"])
page.get_by_label("Verification code").fill(totp.now())
page.get_by_role("button", name="Verify").click()
Rifletti su ciò che stai facendo: conservare il segreto TOTP insieme alla password riduce il 2FA a un singolo fattore, poiché entrambi i segreti risiedono nello stesso luogo. Riserva questo approccio a un account di servizio dedicato, con diritti limitati allo stretto necessario.
Attesa manuale
I fattori non automatizzabili, come SMS o notifiche push, richiedono una pausa esplicita. L’agente si ferma, un operatore valida sul proprio telefono, poi il ciclo riprende da dove si era interrotto. È una soluzione accettabile per un processo avviato manualmente, molto meno per un job cron notturno.
def wait_for_2fa(page):
"""Mette in pausa l'agente e attende la validazione manuale."""
print("2FA richiesto. Esegui la validazione manuale, poi premi Invio.")
input("Premi Invio per continuare...")
# L'agente riprende dopo la validazione
Gestire l’SSO (Single Sign-On)
I login SSO (Google, Microsoft, SAML) reindirizzano a un identity provider esterno: l’agente cambierebbe dominio a metà flusso e dovrebbe inserire le credenziali lì. Non delegare questo passaggio all’agente. Esegui il login SSO una volta, manualmente, in un browser visibile controllato da Playwright, poi salva lo stato della sessione: le esecuzioni successive partiranno da questo stato.
def manual_sso_login(login_url: str, filepath="session.json"):
"""Un umano effettua il login in un browser visibile; la sessione viene salvata."""
pw = sync_playwright().start()
browser = pw.chromium.launch(headless=False)
context = browser.new_context()
page = context.new_page()
page.goto(login_url)
input("Accedi nella finestra aperta, poi premi Invio...")
save_session(context, filepath)
browser.close()
pw.stop()
Quando la sessione scadrà, il flusso di lavoro dovrà fermarsi e richiedere nuovamente questo login umano. Aggiungi questa istruzione alle linee guida dell’agente: se si trova davanti a una pagina di un identity provider, si ferma e lo segnala invece di tentare qualsiasi azione.
Rilevare lo stato di login
Tutta questa meccanica poggia su una domanda a cui devi saper rispondere in modo affidabile: siamo connessi? Una funzione dedicata incrocia due segnali: prima l’URL corrente, poiché un reindirizzamento verso /login è inequivocabile, poi la presenza di un elemento riservato agli utenti autenticati, tipicamente il menu account. Il primo test è istantaneo, il secondo copre le applicazioni che mostrano la pagina di login senza cambiare URL.
from playwright.sync_api import TimeoutError as PlaywrightTimeoutError
def is_logged_in(page) -> bool:
"""Verifica se la sessione è attiva."""
# Controllo URL
if "/login" in page.url or "/signin" in page.url:
return False
# Controllo elemento DOM
try:
page.wait_for_selector("[data-testid=user-menu]", timeout=3000)
return True
except PlaywrightTimeoutError:
return False
L’except mira precisamente alla scadenza del timeout: un except: generico inghiottirebbe anche un’interruzione da tastiera o un vero errore di programmazione, che invece vuoi vedere emergere.
Sicurezza delle credenziali
"Non memorizzare mai password nel codice sorgente, nei prompt o nei log."
In pratica, questa regola si traduce in alcune abitudini che costano quasi nulla una volta adottate. Le credenziali vivono in variabili d’ambiente, alimentate in sviluppo da un file .env che escludi immediatamente dal controllo versione tramite .gitignore: questa omissione è una causa classica di fughe di segreti su repository pubblici. In produzione, sostituisci questo file con un secrets manager, come Vault o AWS Secrets Manager, che fornisce i valori on demand e traccia gli accessi. Solo il tuo codice li legge, mai il modello. Prevedi la rotazione regolare di password e token API, così che una vecchia fuga non apra più nulla. Infine, filtra i log per non registrarvi mai dati sensibili: un agente che registra fedelmente ogni tasto premuto copia anche ciò che gli è stato fatto digitare.
Punti chiave
- Il modello non vede mai un segreto: il tuo codice inserisce password e codice 2FA con Playwright
- Salva lo stato della sessione con
storage_statee tratta quel file come un segreto - Il TOTP è automatizzato lato codice, riservato a un account di servizio con diritti limitati
- Esegui il login SSO una volta manualmente, poi riutilizza la sessione salvata
- Verifica sempre lo stato di login prima di avviare un flusso di lavoro