Håndtér godkendelse og sessioner
På denne side
Lektionen er omskrevet den 3. november 2026 baseret på OpenAIs guide til Computer use og Playwrights dokumentation om godkendelse. Den tidligere version placerede adgangskoder og 2FA-koder direkte i prompten sendt til modellen – herunder via miljøvariabler, hvilket ikke forhindrer, at de bliver transmitteret – og delegerede SSO-login til agenten. Nu håndterer din kode hemmeligheder, sessionstilstanden gemmes ved hjælp af
storage_state, og SSO udføres én gang manuelt. Kilder: Computer use · Playwright, authentication.
Udfordringen ved godkendelse
De fleste automatiseringsworkflows kræver, at du er logget ind på en tjeneste. Så længe din agent opholder sig på offentlige sider, fungerer alt fint; i det øjeblik den skal åbne et CRM, et backoffice eller en indbakke, rammer den en login-mur. Formularer, 2FA, SSO og vedvarende sessioner kræver hver sin håndtering, men én regel gælder for dem alle: modellen må aldrig se en hemmelighed.
Login via formular
Fristelsen er stor til at diktere sekvensen for agenten, inklusive legitimationsoplysninger:
# GØR IKKE DETTE: Adgangskoden havner i anmodningen sendt til API'et
task = """
Log ind på siden:
1. Klik på e-mail-feltet og skriv: [email protected]
2. Klik på adgangskodefeltet og skriv: MyPassword123
3. Klik på knappen "Log in"
"""
At læse adgangskoden fra en miljøvariabel, før den indsættes i prompten, ændrer ingenting: Det efterlader stadig din infrastruktur i anmodningen, det gemmes sammen med svaret – svar gemmes som standard (lektion 12) – og det kan lække til dine logs. OpenAI anbefaler at holde legitimationsoplysninger væk fra sidetekst og skærmbilleder. Løsningen er at lade din kode udfylde login-formularen med Playwright og derefter overdrage kontrollen til agenten, når sessionen er åben.
import os
def log_in(page, login_url: str):
"""Login udføres af din kode: Modellen ser aldrig adgangskoden."""
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")
Tilpas labelerne Email og Password til din applikation. Dette er et af de få steder i workflowet, hvor en selector er fuldt berettiget: En login-side ændrer sig sjældent, og sikkerhedsrisikoen opvejer behovet for fleksibilitet.
Genbrug af sessionstilstand
At logge ind ved hver kørsel spilder tid og kan nogle gange udløse sikkerhedsadvarsler på tjenestens side. Playwright kan gemme en contexts tilstand – cookies, lokal lagring, IndexedDB – til en fil og derefter oprette en ny context ud fra denne fil.
import os
def save_session(context, filepath="session.json"):
"""Gemmer den aktuelle sessionstilstand."""
context.storage_state(path=filepath)
def new_context_with_session(browser, filepath="session.json"):
"""Opretter en context fra en gemt session, hvis en findes."""
options = {"viewport": {"width": 1280, "height": 720}}
if os.path.exists(filepath):
options["storage_state"] = filepath
return browser.new_context(**options)
Integreret i workflowet skaber dette en to-trins logik: Start fra den gemte session, verificér at den stadig er gyldig, og gennemfør kun login igen, hvis det fejler. Tilstanden gemmes igen efter opgaven, da mange tjenester fornyer deres sessionstoken undervejs.
from playwright.sync_api import sync_playwright
def authenticated_workflow(task: str, login_url: str):
"""Workflow med genbrug af 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 gendannet succesfuldt")
else:
log_in(page, login_url) # din kode, ikke agenten
if not is_logged_in(page):
raise RuntimeError("Login umuligt: Tjek legitimationsoplysninger eller 2FA")
save_session(context)
result = run_agent(task, page=page)
save_session(context) # opdater tilstand
return result
finally:
browser.close()
pw.stop()
Behandl sessionsfilen som en adgangskode: Playwright advarer om, at den kan indeholde cookies og headers, der tillader konto-impersonering, og fraråder stærkt at versionere den, selv i et privat repository. Opbevar den sammen med dine hemmeligheder.
Håndtering af to-faktor-godkendelse (2FA)
2FA udgør en udfordring, fordi det ofte kræver menneskelig indgriben, uanset om det er en SMS-kode eller en authenticator-app. Det er netop formålet: Det er designet, så en automat ikke kan omgå det alene. To tilgange sameksisterer afhængigt af den faktor, der bruges, og valget af faktor, når servicekontoen oprettes, afgør, om dit workflow kan køre uden opsyn.
Automatiseret TOTP
Hvis kontoen bruger en TOTP-app som Google Authenticator eller Authy, er den viste kode blot en funktion af den delte hemmelighed og uret. Din kode kan derfor generere og indtaste den selv uden at vise den til modellen.
import os
import pyotp
def enter_totp_code(page):
"""Indtaster den aktuelle TOTP-kode: Hemmeligheden og koden bliver i din kode."""
totp = pyotp.TOTP(os.environ["TOTP_SECRET"])
page.get_by_label("Verification code").fill(totp.now())
page.get_by_role("button", name="Verify").click()
Overvej hvad du gør: At opbevare TOTP-hemmeligheden sammen med adgangskoden reducerer 2FA til én enkelt faktor, da begge hemmeligheder befinder sig samme sted. Reserver denne tilgang til en dedikeret servicekonto med rettigheder begrænset til det absolut nødvendige.
Manuel ventetid
Ikke-automatiserbare faktorer, såsom SMS eller push-notifikationer, kræver en eksplicit pause. Agenten stopper, en operatør validerer på sin telefon, og derefter genoptages løkken, hvor den slap. Dette er en acceptabel løsning for en manuelt startet proces, men langt mindre velegnet til et natligt cron-job.
def wait_for_2fa(page):
"""Pausere agenten og venter på manuel validering."""
print("2FA krævet. Valider manuelt, og tryk derefter på Enter.")
input("Tryk på Enter for at fortsætte...")
# Agenten genoptages efter validering
Håndtering af SSO (Single Sign-On)
SSO-logins (Google, Microsoft, SAML) omdirigerer til en ekstern identitetsudbyder: Agenten ville skifte domæne midt i flowet og skulle indtaste legitimationsoplysninger der. Deleger ikke dette trin til agenten. Udfør SSO-loginet én gang manuelt i en synlig browser styret af Playwright, og gem derefter sessionstilstanden: Efterfølgende kørsler starter fra denne tilstand.
def manual_sso_login(login_url: str, filepath="session.json"):
"""Et menneske logger ind i en synlig browser; sessionen gemmes."""
pw = sync_playwright().start()
browser = pw.chromium.launch(headless=False)
context = browser.new_context()
page = context.new_page()
page.goto(login_url)
input("Log ind i det åbnede vindue, og tryk derefter på Enter...")
save_session(context, filepath)
browser.close()
pw.stop()
Når sessionen udløber, skal workflowet stoppe og anmode om dette menneskelige login igen. Tilføj denne instruktion til agentens retningslinjer: Hvis den står over for en side fra en identitetsudbyder, skal den stoppe og rapportere det i stedet for at forsøge noget.
Registrering af login-tilstand
Hele denne mekanik hviler på et spørgsmål, du skal kunne besvare pålideligt: Er vi logget ind? En dedikeret funktion krydstjekker to signaler: Først den aktuelle URL, da en omdirigering til /login er utvetydig, og derefter tilstedeværelsen af et element reserveret til godkendte brugere, typisk kontomenuen. Den første test er øjeblikkelig, den anden dækker applikationer, der viser login-siden uden at ændre URL’en.
from playwright.sync_api import TimeoutError as PlaywrightTimeoutError
def is_logged_in(page) -> bool:
"""Tjekker om sessionen er aktiv."""
# URL-tjek
if "/login" in page.url or "/signin" in page.url:
return False
# DOM-element-tjek
try:
page.wait_for_selector("[data-testid=user-menu]", timeout=3000)
return True
except PlaywrightTimeoutError:
return False
except-blokken målretter præcist udløb af timeout: En nøgen except: ville også sluge et keyboard-interrupt eller en reel programmeringsfejl, hvilket du ønsker skal boble op.
Sikkerhed for legitimationsoplysninger
"Gem aldrig adgangskoder i din kildekode, dine prompts eller dine logs."
I praksis nedbrydes denne regel til nogle få vaner, der næsten ikke koster noget, når de først er indarbejdet. Legitimationsoplysninger lever i miljøvariabler, fodret i udviklingsfasen af en .env-fil, som du straks udelukker fra versionskontrol via .gitignore – denne udeladelse er en klassisk årsag til lækage af hemmeligheder på offentlige repositories. I produktion erstatter du denne fil med en hemmelighedsadministrator, såsom Vault eller AWS Secrets Manager, som leverer værdier på forespørgsel og sporer adgang. Kun din kode læser dem, aldrig modellen. Planlæg regelmæssig rotation af adgangskoder og API-tokens, så et gammelt læk ikke længere åbner noget. Filtrer endelig dine logs, så de aldrig registrerer følsomme data der: En agent, der trofast logger hvert tastetryk, kopierer også det, den blev bedt om at skrive.
Vigtige pointer
- Modellen ser aldrig en hemmelighed: Din kode indtaster adgangskode og 2FA-kode med Playwright
- Gem sessionstilstanden med
storage_stateog behandl den fil som en hemmelighed - TOTP automatiseres på kodesiden og reserveres til en servicekonto med begrænsede rettigheder
- Udfør SSO-login én gang manuelt, og genbrug derefter den gemte session
- Tjek altid login-tilstanden, før du starter et workflow