Tvarkyti autentifikavimą ir sesijas
Šiame puslapyje
Pamoka perrašyta 2026 m. lapkričio 3 d. remiantis OpenAI Computer use gairėmis ir Playwright autentifikavimo dokumentacija. Ankstesnė versija slaptažodžius ir 2FA kodus tiesiogiai įtraukdavo į modeliu siunčiamą užklausą – įskaitant per aplinkos kintamuosius, kas jų perdavimo neužkerta – ir perduodavo SSO prisijungimą agentui. Dabar tavo kodas tvarko paslaptis, sesijos būsena išsaugoma naudojant
storage_state, o SSO atliekamas vieną kartą rankiniu būdu. Šaltiniai: Computer use · Playwright, authentication.
Autentifikavimo iššūkis
Daugumai automatizavimo darbo eigų reikia būti prisijungus prie paslaugos. Kol tavo agentas lieka viešuose puslapiuose, viskas veikia sklandžiai; tačiau kai tik jam reikia atidaryti CRM, administravimo skydelį ar el. pašto dėžutę, jis atsitrenkia į prisijungimo sieną. Formos, 2FA, SSO ir nuolatinės sesijos reikalauja skirtingo tvarkymo, tačiau visas jas valdo viena taisyklė: modelis niekada nemato paslapčių.
Prisijungimas naudojant formas
Gunda nurodyti agentui veiksmų seką, įskaitant prisijungimo duomenis:
# NEDARYK TO: slaptažodis patenka į API siunčiamą užklausą
task = """
Prisijunk prie svetainės:
1. Spustelėk el. pašto laukelį ir įvesk: [email protected]
2. Spustelėk slaptažodžio laukelį ir įvesk: MyPassword123
3. Spustelėk mygtuką „Log in“
"""
Slaptažodžio nuskaitymas iš aplinkos kintamojo prieš įterpiant jį į užklausą nieko nekeičia: tavo infrastruktūra vis tiek lieka užklausoje, ji išsaugoma kartu su atsakymu (atsakymai pagal numatytuosius nustatymus saugomi – žr. 12 pamoką) ir gali nutekėti į tavo žurnalus. OpenAI rekomenduoja nelaikyti prisijungimo duomenų puslapio tekste ar ekrano kopijose. Sprendimas – kad tavo kodas užpildytų prisijungimo formą naudodamas Playwright, o agentui perduotų valdymą tik atidarius sesiją.
import os
def log_in(page, login_url: str):
"""Prisijungimą atlieka tavo kodas: modelis slaptažodžio nemato."""
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")
Pritaikyk etiketes Email ir Password savo programai. Tai viena iš nedaugelio darbo eigos vietų, kur selektorius yra visiškai pateisinamas: prisijungimo puslapiai retai keičiasi, o saugumo rizika nusveria lankstumą.
Sesijos būsenos pakartotinis naudojimas
Prisijungimas kiekvieno vykdymo metu eikvoja laiką ir kartais gali sukelti saugumo įspėjimus paslaugos pusėje. Playwright gali išsaugoti konteksto būseną – slapukus, vietinę saugyklą, IndexedDB – į failą, o tada sukurti naują kontekstą iš to failo.
import os
def save_session(context, filepath="session.json"):
"""Išsaugo dabartinę sesijos būseną."""
context.storage_state(path=filepath)
def new_context_with_session(browser, filepath="session.json"):
"""Sukuria kontekstą iš išsaugotos sesijos, jei tokia yra."""
options = {"viewport": {"width": 1280, "height": 720}}
if os.path.exists(filepath):
options["storage_state"] = filepath
return browser.new_context(**options)
Integruota į darbo eigą, tai sukuria dviejų žingsnių logiką: pradėk nuo išsaugotos sesijos, patikrink, ar ji vis dar galioja, ir tik jei tai nepavyksta, prisijunk iš naujo. Būsena išsaugoma dar kartą po užduoties, nes daugelis paslaugų jos metu atnaujina savo sesijos žetoną.
from playwright.sync_api import sync_playwright
def authenticated_workflow(task: str, login_url: str):
"""Darbo eiga su sesijos pakartotiniu naudojimu."""
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("Sesija sėkmingai atkurta")
else:
log_in(page, login_url) # tavo kodas, ne agento
if not is_logged_in(page):
raise RuntimeError("Prisijungti neįmanoma: patikrink prisijungimo duomenis arba 2FA")
save_session(context)
result = run_agent(task, page=page)
save_session(context) # atnaujink būseną
return result
finally:
browser.close()
pw.stop()
Elkis su sesijos failu kaip su slaptažodžiu: Playwright įspėja, kad jame gali būti slapukų ir antraščių, leidžiančių apsimetinėti paskyra, ir griežtai rekomenduoja jo neįtraukti į versijų valdymą, net ir į privatų saugyklą. Saugok jį kartu su savo paslaptimis.
Dviejų veiksnių autentifikavimo (2FA) tvarkymas
2FA kelia iššūkį, nes dažnai reikalauja žmogaus įsikišimo, nesvarbu, ar tai SMS kodas, ar autentifikatoriaus programėlė. Tokia ir yra jos paskirtis: ji sukurta taip, kad automatonas jos negalėtų apeiti vienas. Egzistuoja du požiūriai, priklausomai nuo naudojamo veiksnio, o veiksnio pasirinkimas kuriant paslaugos paskyrą lemia, ar tavo darbo eiga gali vykti be priežiūros.
Automatizuotas TOTP
Jei paskyra naudoja TOTP programėlę, pvz., „Google Authenticator“ ar „Authy“, rodomas kodas yra tik bendros paslapties ir laiko funkcija. Todėl tavo kodas gali jį sugeneruoti ir įvesti pats, nerodydamas jo modeliui.
import os
import pyotp
def enter_totp_code(page):
"""Įveda dabartinį TOTP kodą: paslaptis ir kodas lieka tavo 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()
Pagalvok, ką darai: TOTP paslapties saugojimas kartu su slaptažodžiu sumažina 2FA iki vieno veiksnio, nes abi paslaptys gyvena toje pačioje vietoje. Šį metodą taikyk tik specialiai paslaugos paskyrai, kurios teisės apribotos iki absoliučaus minimumo.
Rankinis laukimas
Neautomatinami veiksniai, tokie kaip SMS ar stumiami pranešimai, reikalauja aiškios pauzės. Agentas sustoja, operatorius patvirtina savo telefone, tada ciklas tęsiasi nuo tos vietos, kur sustojo. Tai priimtinas sprendimas rankiniu būdu paleistam procesui, tačiau daug mažiau tinkamas naktiniam „cron“ darbui.
def wait_for_2fa(page):
"""Sustabdo agentą ir laukia rankinio patvirtinimo."""
print("Reikalingas 2FA. Patvirtinkite rankiniu būdu, tada paspauskite Enter.")
input("Paspauskite Enter norėdami tęsti...")
# Agentas tęsia darbą po patvirtinimo
SSO (vienkartinio prisijungimo) tvarkymas
SSO prisijungimai („Google“, „Microsoft“, SAML) nukreipia į išorinį tapatybės teikėją: agentas darbo eigos viduryje pakeistų domeną ir turėtų ten įvesti prisijungimo duomenis. Neperduok šio žingsnio agentui. Atlik SSO prisijungimą vieną kartą rankiniu būdu matomoje naršyklėje, valdomoje Playwright, tada išsaugok sesijos būseną: vėlesni vykdymai prasidės nuo šios būsenos.
def manual_sso_login(login_url: str, filepath="session.json"):
"""Žmogus prisijungia atidarytoje naršyklėje; sesija išsaugoma."""
pw = sync_playwright().start()
browser = pw.chromium.launch(headless=False)
context = browser.new_context()
page = context.new_page()
page.goto(login_url)
input("Prisijunkite atidarytame lange, tada paspauskite Enter...")
save_session(context, filepath)
browser.close()
pw.stop()
Kai sesija galiausiai baigs galioti, darbo eiga turi sustoti ir vėl paprašyti šio žmogaus prisijungimo. Įtrauk šią instrukciją į agento gaires: jei jis atsiduria prieš tapatybės teikėjo puslapį, jis turi sustoti ir apie tai pranešti, o ne bandyti ką nors daryti.
Prisijungimo būsenos nustatymas
Visa ši mechanika remiasi klausimu, į kurį turi gebėti patikimai atsakyti: ar esame prisijungę? Speciali funkcija tikrina du signalus: pirmiausia dabartinį URL, nes nukreipimas į /login yra vienareikšmis, tada elemento, skirto autentifikuotiems naudotojams (paprastai paskyros meniu), buvimą. Pirmasis testas yra momentinis, antrasis apima programas, kurios rodo prisijungimo puslapį nepakeisdamos URL.
from playwright.sync_api import TimeoutError as PlaywrightTimeoutError
def is_logged_in(page) -> bool:
"""Tikrina, ar sesija aktyvi."""
# URL tikrinimas
if "/login" in page.url or "/signin" in page.url:
return False
# DOM elemento tikrinimas
try:
page.wait_for_selector("[data-testid=user-menu]", timeout=3000)
return True
except PlaywrightTimeoutError:
return False
except tiksliai taikomas laiko limito pasibaigimui: paprastas except: taip pat „nurytų“ klaviatūros pertraukimą ar realią programavimo klaidą, o tu nori, kad jos iškiltų į paviršių.
Prisijungimo duomenų saugumas
„Niekada nelaikyk slaptažodžių savo源代码, užklausose ar žurnaluose.“
Praktiškai ši taisyklė išsiskaido į kelis įpročius, kurie beveik nieko nekainuoja, kai jų laikomasi. Prisijungimo duomenys gyvena aplinkos kintamuosiuose, kūrimo metu maitinami iš .env failo, kurį iškart neįtrauki į versijų valdymą naudodamas .gitignore – šis praleidimas yra klasikinė paslapčių nutekėjimo viešose saugyklose priežastis. Gamyboje pakeisk šį failą paslapčių valdytoju, pvz., „Vault“ ar „AWS Secrets Manager“, kuris pateikia reikšmes pagal poreikį ir fiksuoja prieigą. Jas skaito tik tavo kodas, niekada – modelis. Suplanuok reguliarų slaptažodžių ir API žetonų keitimą, kad senas nutekėjimas nieko neatidarytų. Galiausiai, filtruok savo žurnalus, kad juose niekada nebūtų registruojami jautrūs duomenys: agentas, kuris sąžiningai registruoja kiekvieną klavišo paspaudimą, taip pat nukopijuoja tai, ką buvo priverstas įvesti.
Svarbiausi punktai
- Modelis niekada nemato paslapčių: tavo kodas įveda slaptažodį ir 2FA kodą naudodamas Playwright
- Išsaugok sesijos būseną su
storage_stateir elkis su tuo failu kaip su paslaptimi - TOTP automatizuojamas kodo pusėje, skirtas tik paslaugos paskyrai su ribotomis teisėmis
- SSO prisijungimą atlik vieną kartą rankiniu būdu, tada pakartotinai naudok išsaugotą sesiją
- Prieš paleisdamas darbo eigą visada patikrink prisijungimo būseną