Upravljanje avtentikacije in sej
Na tej strani
Lekcija ponovno napisana 3. novembra 2026 na podlagi vodnika Computer use podjetja OpenAI in dokumentacije za avtentikacijo Playwright. Prejšnja različica je gesla in kode 2FA vključevala neposredno v poziv, poslan modelu – tudi prek spremenljivk okolja, kar ne preprečuje njihovega prenosa – in delegirala prijavo SSO na agenta. Zdaj tvoja koda upravlja tajne podatke, stanje seje se shrani z uporabo
storage_state, prijava SSO pa se opravi enkrat ročno. Viri: Computer use · Playwright, authentication.
Izzav avtentikacije
Večina delovnih tokov avtomatizacije zahteva prijavo v storitev. Dokler tvoj agent ostane na javnih straneh, vse deluje brez težav; v trenutku, ko mora odpreti CRM, back office ali e-poštni nabiralnik, naleti na zid za prijavo. Obrazci, 2FA, SSO in trajne seje zahtevajo različne pristope, vendar jih vse ureja eno pravilo: model nikoli ne vidi tajnega podatka.
Prijava preko obrazca
Zapeljivo je agentu narekovati zaporedje, vključno s poverilnicami:
# TEGA NE DELAJ: geslo gre v zahtevo, poslano API-ju
task = """
Prijavi se na spletno mesto:
1. Klikni polje za e-pošto in vpiši: [email protected]
2. Klikni polje za geslo in vpiši: MyPassword123
3. Klikni gumb "Log in"
"""
Branje gesla iz spremenljivke okolja pred vstavitvijo v poziv ničesar ne spremeni: tvoja infrastruktura ga še vedno vključi v zahtevo, shrani se z odgovorom (odgovori so privzeto shranjeni, lekcija 12) in lahko uhaja v tvoje dnevnike. OpenAI priporoča, da poverilnic ne vključuješ v besedilo strani ali posnetke zaslona. Rešitev je, da tvoja koda izpolni obrazec za prijavo s Playwrightom in šele nato, ko je seja odprta, predaja nadzor agentu.
import os
def log_in(page, login_url: str):
"""Prijavo opravi tvoja koda: model nikoli ne vidi gesla."""
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")
Prilagodi oznaki Email in Password svoji aplikaciji. To je eno redkih mest v delovnem toku, kjer je selektor popolnoma upravičen: stran za prijavo se redko spreminja, varnostni vidiki pa tehtajo več od fleksibilnosti.
Ponovna uporaba stanja seje
Prijava ob vsakem izvajanju zapravlja čas in lahko včasih sproži varnostna opozorila na strani storitve. Playwright lahko shrani stanje konteksta – piškotke, lokalno shrambo, IndexedDB – v datoteko in nato iz te datoteke ustvari nov kontekst.
import os
def save_session(context, filepath="session.json"):
"""Shrani trenutno stanje seje."""
context.storage_state(path=filepath)
def new_context_with_session(browser, filepath="session.json"):
"""Ustvari kontekst iz shranjene seje, če ta obstaja."""
options = {"viewport": {"width": 1280, "height": 720}}
if os.path.exists(filepath):
options["storage_state"] = filepath
return browser.new_context(**options)
Integrirano v delovni tok to ustvari dvostopenjsko logiko: začni s shranjeno sejo, preveri, ali je še veljavna, in se ponovno prijavi le, če to ne uspe. Stanje se po opravilu ponovno shrani, saj mnoge storitve med delovanjem obnovijo svoj sejni žeton.
from playwright.sync_api import sync_playwright
def authenticated_workflow(task: str, login_url: str):
"""Delovni tok s ponovno uporabo seje."""
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("Seja je bila uspešno obnovljena")
else:
log_in(page, login_url) # tvoja koda, ne agent
if not is_logged_in(page):
raise RuntimeError("Prijava ni mogoča: preveri poverilnice ali 2FA")
save_session(context)
result = run_agent(task, page=page)
save_session(context) # posodobi stanje
return result
finally:
browser.close()
pw.stop()
Z datoteko seje ravnavaj kot z geslom: Playwright opozarja, da lahko vsebuje piškotke in glave, ki omogočajo lažno predstavljanje računa, in močno odsvetuje njeno verzioniranje, celo v zasebnem repozitoriju. Shrani jo skupaj s svojimi tajnimi podatki.
Obravnava dvofaktorske avtentikacije (2FA)
2FA predstavlja izziv, saj pogosto zahteva človekovo posredovanje, bodisi kodo SMS bodisi aplikacijo za avtentikacijo. To je ravno njen namen: zasnovana je tako, da je avtomat ne more samostojno obiti. Soobstajata dva pristopa, odvisno od uporabljenega faktorja, izbira faktorja ob ustvarjanju računa storitve pa določa, ali se lahko tvoj delovni tok izvaja brez nadzora.
Avtomatizirani TOTP
Če račun uporablja aplikacijo TOTP, kot sta Google Authenticator ali Authy, je prikazana koda le funkcija skupne skrivnosti in ure. Tvoja koda jo lahko zato sama generira in vpiše, ne da bi jo pokazala modelu.
import os
import pyotp
def enter_totp_code(page):
"""Vpiše trenutno kodo TOTP: skrivnost in koda ostaneta v tvoji kodi."""
totp = pyotp.TOTP(os.environ["TOTP_SECRET"])
page.get_by_label("Verification code").fill(totp.now())
page.get_by_role("button", name="Verify").click()
Razmisli, kaj počneš: shranjevanje skrivnosti TOTP skupaj z geslom reducira 2FA na en faktor, saj oba tajna podatka živita na istem mestu. Ta pristop rezerviraj za namenski račun storitve z pravicami, omejenimi na strogi minimum.
Ročno čakanje
Faktorji, ki jih ni mogoče avtomatizirati, kot so SMS ali potisna obvestila, zahtevajo izrecen premor. Agent se ustavi, operater potrdi na svojem telefonu, nato se zanka nadaljuje tam, kjer je zastala. To je sprejemljiva rešitev za ročno zagnan proces, veliko manj pa za nočno opravilo cron.
def wait_for_2fa(page):
"""Zaustavi agenta in počaka na ročno potrditev."""
print("Zahtevan je 2FA. Potrdite ročno, nato pritisnite Enter.")
input("Pritisnite Enter za nadaljevanje...")
# Agent se nadaljuje po potrditvi
Obravnava SSO (Enotna prijava)
Prijave SSO (Google, Microsoft, SAML) preusmerijo na zunanji ponudnika identitete: agent bi sredi toka spremenil domeno in bi moral tam vnesti poverilnice. Tega koraka ne delegiraj agentu. Prijavo SSO opravi enkrat ročno v vidnem brskalniku, ki ga nadzoruje Playwright, nato shrani stanje seje: poznejša izvajanja začnejo iz tega stanja.
def manual_sso_login(login_url: str, filepath="session.json"):
"""Človek se prijavi v odprtem brskalniku; seja se shrani."""
pw = sync_playwright().start()
browser = pw.chromium.launch(headless=False)
context = browser.new_context()
page = context.new_page()
page.goto(login_url)
input("Prijavite se v odprtem oknu, nato pritisnite Enter...")
save_session(context, filepath)
browser.close()
pw.stop()
Ko seja sčasoma poteče, se mora delovni tok ustaviti in ponovno zahtevati to človeško prijavo. To navodilo dodaj smernicam agenta: če se znajde pred stranjo ponudnika identitete, se ustavi in to sporoči, namesto da bi poskušal karkoli storiti.
Zaznavanje stanja prijave
Vsa ta mehanika sloni na vprašanju, na katerega moraš biti sposoben zanesljivo odgovoriti: ali smo prijavljeni? Namenska funkcija preveri dva signala: najprej trenutni URL, saj je preusmeritev na /login nedvoumna, nato prisotnost elementa, rezerviranega za avtenticirane uporabnike, običajno meni računa. Prvi test je trenutni, drugi pokriva aplikacije, ki prikažejo stran za prijavo brez spremembe URL-ja.
from playwright.sync_api import TimeoutError as PlaywrightTimeoutError
def is_logged_in(page) -> bool:
"""Preveri, ali je seja aktivna."""
# Preverjanje URL-ja
if "/login" in page.url or "/signin" in page.url:
return False
# Preverjanje elementa DOM
try:
page.wait_for_selector("[data-testid=user-menu]", timeout=3000)
return True
except PlaywrightTimeoutError:
return False
Klausula except cilja natančno na potek časovne omejitve: gola except: bi pogoltnila tudi prekinitveno kodo tipkovnice ali dejansko programsko napako, ki ju želiš videti, da se pojavita na površje.
Varnost poverilnic
"Gesel nikoli ne shranjuj v izvorno kodo, svoje pozive ali dnevnike."
V praksi se to pravilo razgradi v nekaj navad, ki po sprejetju skoraj nič ne stanejo. Poverilnice živijo v spremenljivkah okolja, ki jih v razvoju napaja datoteka .env, ki jo takoj izključiš iz nadzora različic prek .gitignore – ta opust je klasičen vzrok uhajanja skrivnosti v javne repozitorije. V proizvodnji to datoteko zamenjaj z upraviteljem skrivnosti, kot sta Vault ali AWS Secrets Manager, ki vrednosti dostavi na zahtevo in sledi dostopu. Samo tvoja koda jih bere, nikoli model. Načrtuj redno rotacijo gesel in žetonov API, tako da staro uhajanje ne odpre več ničesar. Nazadnje, filtriraj svoje dnevnike, da nikoli ne zabeležijo občutljivih podatkov: agent, ki vestno beleži vsak pritisk tipke, kopira tudi tisto, kar je bil naprošen, da vpiše.
Ključne ugotovitve
- Model nikoli ne vidi tajnega podatka: tvoja koda vpiše geslo in kodo 2FA s Playwrightom
- Shrani stanje seje z
storage_statein s to datoteko ravnavaj kot s tajnim podatkom - TOTP je avtomatiziran na strani kode, rezerviran za račun storitve z omejenimi pravicami
- Prijavo SSO opravi enkrat ročno, nato ponovno uporabi shranjeno sejo
- Pred zagonom delovnega toka vedno preveri stanje prijave