Autentimise ja seansside haldamine
Sellel lehel
Õppetund kirjutati ümber 3. novembril 2026, tuginedes OpenAI Computer use juhendile ja Playwright’i autentimise dokumentatsioonile. Eelmises versioonis sisestati paroolid ja 2FA-koodid otse mudelile saadetavasse vihjesse – sealhulgas keskkonnamuutujate kaudu, mis ei takista nende edastamist – ja delegeeriti SSO-sisselogimine agendile. Nüüd haldab sinu kood salajasi andmeid, seansi olek salvestatakse
storage_stateabil ja SSO tehakse üks kord käsitsi. Allikad: Computer use · Playwright, authentication.
Autentimise väljakutse
Enamik automatiseerimise töövooge eeldab teenusesse sisselogimist. Niikaua kui sinu agent püsib avalikel lehtedel, toimib kõik sujuvalt; hetkel, kui ta peab avama CRM-i, tagakontori või meiliposti, põrkab ta sisselogimise müüriga. Vormid, 2FA, SSO ja püsivad seansid nõuavad igaüks erinevat käsitlust, kuid kõiki neid valitseb üks reegel: mudel ei tohi kunagi näha saladust.
Vormipõhine sisselogimine
Kiusatus on dikteerida agendile tegevuste jada, kaasates sinna ka kasutajatunnused:
# ÄRA TEE NII: parool satub API-le saadetavasse päringusse
task = """
Logi saidile sisse:
1. Klõpsa meiliväljal ja kirjuta: [email protected]
2. Klõpsa parooliväljal ja kirjuta: MyPassword123
3. Klõpsa nuppu "Log in"
"""
Parooli lugemine keskkonnamuutujast enne selle vihjesse sisestamist ei muuda midagi: see jätab sinu taristu andmed ikkagi päringusse, need salvestatakse vastusega – vaikimisi salvestatakse vastused (vt õppetund 12) – ja need võivad lekkida sinu logidesse. OpenAI soovitab hoida kasutajatunnused eemal lehe tekstist ja ekraanitõmmistest. Lahendus on lasta sinu koodil täita sisselogimisvorm Playwright’i abil ja alles seejärel, kui seanss on avatud, anda teatepulk agendile üle.
import os
def log_in(page, login_url: str):
"""Sisselogimise teeb sinu kood: mudel ei näe kunagi parooli."""
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")
Kohanda sildid Email ja Password vastavalt oma rakendusele. See on üks väheseid kohti töövoos, kus selektori kasutamine on täielikult põhjendatud: sisselogimisleht muutub harva ja turvariskid kaaluvad üles paindlikkuse.
Seansi oleku taaskasutamine
Igal käivitamisel sisselogimine raiskab aega ja võib teenuse poolel vallandada turvahoiatusi. Playwright suudab salvestada konteksti oleku – küpsised, kohalik mälu, IndexedDB – faili ja seejärel luua uue konteksti sellest failist lähtuvalt.
import os
def save_session(context, filepath="session.json"):
"""Salvestab praeguse seansi oleku."""
context.storage_state(path=filepath)
def new_context_with_session(browser, filepath="session.json"):
"""Loob konteksti salvestatud seansist, kui see on olemas."""
options = {"viewport": {"width": 1280, "height": 720}}
if os.path.exists(filepath):
options["storage_state"] = filepath
return browser.new_context(**options)
Töövoogu integreerituna tekib kaheastmeline loogika: alusta salvestatud seansist, kontrolli selle kehtivust ja logi uuesti sisse ainult siis, kui see kontroll ei õnnestu. Olek salvestatakse uuesti pärast ülesande täitmist, sest paljud teenused uuendavad oma seansitokenit protsessi käigus.
from playwright.sync_api import sync_playwright
def authenticated_workflow(task: str, login_url: str):
"""Töövoog seansi taaskasutusega."""
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("Seanss taastati edukalt")
else:
log_in(page, login_url) # sinu kood, mitte agent
if not is_logged_in(page):
raise RuntimeError("Sisselogimine võimatu: kontrolli kasutajatunnuseid või 2FA-d")
save_session(context)
result = run_agent(task, page=page)
save_session(context) # uuenda olekut
return result
finally:
browser.close()
pw.stop()
Kohtle seansifaili nagu parooli: Playwright hoiatab, et see võib sisaldada küpsiseid ja päiseid, mis võimaldavad kontot võltsida, ning soovitab tungivalt seda mitte versioonihaldusse panna, isegi mitte privatses hoidlas. Hoia seda koos oma teiste saladustega.
Kahefaktorilise autentimise (2FA) haldamine
2FA on väljakutse, kuna see nõuab sageli inimsekkumist, olgu selleks SMS-kood või autentimisrakendus. See ongi selle eesmärk: see on loodud nii, et automaat seda üksi mööda hiilida ei saaks. Sõltuvalt kasutatavast tegurist eksisteerivad kaks lähenemist ja teenusekonto loomisel tehtud valik määrab, kas sinu töövoog saab toimida ilma järelevalveta.
Automatiseeritud TOTP
Kui konto kasutab TOTP-rakendust nagu Google Authenticator või Authy, on kuvatav kood vaid jagatud saladuse ja kellaaja funktsioon. Sinu kood saab selle seetõttu ise genereerida ja sisestada, näitamata seda mudelile.
import os
import pyotp
def enter_totp_code(page):
"""Sisestab praeguse TOTP-koodi: saladus ja kood jäävad sinu koodi."""
totp = pyotp.TOTP(os.environ["TOTP_SECRET"])
page.get_by_label("Verification code").fill(totp.now())
page.get_by_role("button", name="Verify").click()
Mõtle, mida sa teed: TOTP-saladuse hoidmine koos parooliga taandab 2FA ühele tegurile, kuna mõlemad saladused asuvad samas kohas. Kasuta seda lähenemist ainult pühendatud teenusekontol, mille õigused on piiratud absoluutse miinimumini.
Käsitsi ootamine
Mitteautomatiseeritavad tegurid, nagu SMS või push-teated, nõuavad selget pausi. Agent peatub, operaator kinnitab tegevuse oma telefonil ja seejärel jätkub tsükkel sealt, kus see pooleli jäi. See on vastuvõetav lahendus käsitsi käivitatud protsessi jaoks, kuid palju vähem sobiv näiteks öise cron-töö jaoks.
def wait_for_2fa(page):
"""Peatab agendi ja ootab käsitsi kinnitamist."""
print("Vajalik on 2FA. Kinnita käsitsi ja vajuta siis Enter.")
input("Jätkamiseks vajuta Enter...")
# Agent jätkab pärast kinnitamist
SSO (ühtne sisselogimine) haldamine
SSO-sisselogimised (Google, Microsoft, SAML) suunavad ümber välisele identiteedipakkujale: agent vahetaks voos domeeni ja peaks seal sisestama kasutajatunnused. Ära delegeeri seda sammu agendile. Soorita SSO-sisselogimine üks kord käsitsi nähtavas brauseris, mida juhib Playwright, ja salvesta seejärel seansi olek: järgmised käivitused algavad sellest olekust.
def manual_sso_login(login_url: str, filepath="session.json"):
"""Inimene logib sisse avatud brauseris; seanss salvestatakse."""
pw = sync_playwright().start()
browser = pw.chromium.launch(headless=False)
context = browser.new_context()
page = context.new_page()
page.goto(login_url)
input("Logi avatud aknas sisse ja vajuta siis Enter...")
save_session(context, filepath)
browser.close()
pw.stop()
Kui seanss lõpuks aegub, peab töövoog peatuma ja nõudma seda käsitsi sisselogimist uuesti. Lisa see juhend agendi reeglitesse: kui ta satub identiteedipakkujale kuuluva lehe ette, peatub ta ja teatab sellest, selle asemel et midagi üritada.
Sisselogimise oleku tuvastamine
Kogu see mehhanism tugineb küsimusele, millele pead suutma usaldusväärselt vastata: kas oleme sisse logitud? Spetsiaalne funktsioon ristab kahte signaali: esmalt praegune URL, kuna ümbersuunamine aadressile /login on ühemõtteline, ja teiseks autentitud kasutajatele reserveeritud elemendi olemasolu, tavaliselt konto menüü. Esimene test on kohene, teine katab rakendused, mis kuvavad sisselogimislehte URL-i muutmata.
from playwright.sync_api import TimeoutError as PlaywrightTimeoutError
def is_logged_in(page) -> bool:
"""Kontrollib, kas seanss on aktiivne."""
# URL-i kontroll
if "/login" in page.url or "/signin" in page.url:
return False
# DOM-elemendi kontroll
try:
page.wait_for_selector("[data-testid=user-menu]", timeout=3000)
return True
except PlaywrightTimeoutError:
return False
except sihib täpselt ajalõpu saabumist: paljas except: neelaks ka klaviatuuri katkestuse või tegeliku programmeerimisvea, mida sa tahad näha ülespoole jõudvat.
Kasutajatunnuste turvalisus
"Ära kunagi salvesta paroole oma lähtekoodi, vihjetesse ega logidesse."
Praktikas tähendab see reegel mõne harjumuse omaksvõtmist, mis maksab peaaegu mitte midagi, kui need on once juurdunud. Kasutajatunnused elavad keskkonnamuutujates, arenduses toidetakse neid .env failist, mille sa kohe versioonihaldusest välja arvad .gitignore kaudu – see unustus on klassikaline saladuste lekkimise põhjus avalikes hoidlates. Tootmises asenda see fail saladuste halduriga, nagu Vault või AWS Secrets Manager, mis väljastab väärtused vajadusel ja jälgib juurdepääsu. Ainult sinu kood loeb neid, mitte kunagi mudel. Planeeri paroolide ja API-tokenite regulaarne rotatsioon, nii et vana leke enam midagi ei avaks. Lõpuks filtreeri oma logisid, et sinna kunagi tundlikke andmeid ei salvestataks: agent, mis logib truult iga klahvivajutuse, kopeerib ka selle, mida teda sunniti kirjutama.
Peamised punktid
- Mudel ei näe kunagi saladust: sinu kood sisestab parooli ja 2FA-koodi Playwright’i abil
- Salvesta seansi olek
storage_stateabil ja kohtle seda faili kui saladust - TOTP automatiseeritakse koodi tasandil, reserveeritud piiratud õigustega teenusekontole
- Soorita SSO-sisselogimine üks kord käsitsi ja taaskasuta seejärel salvestatud seanssi
- Kontrolli alati sisselogimise olekut enne töövoogu käivitamist