Správa overovania a relácií
Na tejto strane
Lekcia prepísaná 3. novembra 2026 na základe príručky Computer use od OpenAI a dokumentácie k overovaniu v Playwright. Predchádzajúca verzia vkládala heslá a kódy 2FA priamo do promptu odoslaného modelu – vrátane použitia premenných prostredia, čo ich neodstráni z prenosu – a delegovala prihlásenie cez SSO na agenta. Teraz tvoj kód zaobchádza s tajnými údajmi, stav relácie sa ukladá pomocou
storage_statea prihlásenie SSO sa vykoná raz manuálne. Zdroje: Computer use · Playwright, authentication.
Výzva overovania
Väčšina automatizačných workflow vyžaduje byť prihlásený do služby. Kým tvoj agent zostáva na verejných stránkach, všetko funguje hladko; v momente, keď potrebuje otvoriť CRM, back office alebo e-mailovú schránku, narazí na prihlasovaciu stenu. Formuláre, 2FA, SSO a trvalé relácie si vyžadujú odlišný prístup, no jedno pravidlo platí pre všetky: model nikdy nevidí tajný údaj.
Prihlásenie cez formulár
Pokúšať sa diktovať agentovi postup vrátane prihlasovacích údajov je lákavé, no chybné:
# NEROB TOTO: heslo sa dostane do požiadavky odoslanej do API
task = """
Prihlás sa na stránku:
1. Klikni na pole e-mail a napíš: [email protected]
2. Klikni na pole heslo a napíš: MyPassword123
3. Klikni na tlačidlo "Log in"
"""
Čítanie hesla z premennej prostredia pred jeho vložením do promptu nič nemení: stále opúšťa tvoju infraštruktúru v rámci požiadavky, zostáva uložené v odpovedi – odpovede sa štandardne ukladajú (Lekcia 12) – a môže uniknúť do tvojich logov. OpenAI odporúča držať prihlasovacie údaje mimo textu stránky a snímok obrazovky. Riešením je vyplniť prihlasovací formulár tvojím kódom pomocou Playwright a agentovi odovzdať kontrolu až po otvorení relácie.
import os
def log_in(page, login_url: str):
"""Prihlásenie vykoná tvoj kód: model nikdy nevidí heslo."""
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")
Prispôsob štítky Email a Password svojej aplikácii. Toto je jedno z mála miest vo workflow, kde je použitie selektora plne opodstatnené: prihlasovacia stránka sa mení zriedka a bezpečnostné riziká prevyšujú potrebu flexibility.
Opätovné použitie stavu relácie
Prihlasovanie pri každom spustení plytvá časom a môže niekedy spustiť bezpečnostné alerty na strane služby. Playwright dokáže uložiť stav kontextu – cookies, lokálne úložisko, IndexedDB – do súboru a následne vytvoriť nový kontext z tohto súboru.
import os
def save_session(context, filepath="session.json"):
"""Uloží aktuálny stav relácie."""
context.storage_state(path=filepath)
def new_context_with_session(browser, filepath="session.json"):
"""Vytvorí kontext z uloženej relácie, ak existuje."""
options = {"viewport": {"width": 1280, "height": 720}}
if os.path.exists(filepath):
options["storage_state"] = filepath
return browser.new_context(**options)
Integrované do workflow to vytvára dvojstupňovú logiku: začni z uloženej relácie, over jej platnosť a k prihláseniu pristúp znovu len v prípade zlyhania. Stav sa uloží aj po dokončení úlohy, pretože mnohé služby cestou obnovujú svoj token relácie.
from playwright.sync_api import sync_playwright
def authenticated_workflow(task: str, login_url: str):
"""Workflow s opätovným použitím relácie."""
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("Relácia úspešne obnovená")
else:
log_in(page, login_url) # tvoj kód, nie agent
if not is_logged_in(page):
raise RuntimeError("Prihlásenie zlyhalo: skontroluj údaje alebo 2FA")
save_session(context)
result = run_agent(task, page=page)
save_session(context) # aktualizuj stav
return result
finally:
browser.close()
pw.stop()
Zaobchádzaj so súborom relácie ako s heslom: Playwright varuje, že môže obsahovať cookies a hlavičky umožňujúce impersonáciu účtu, a dôrazne odporúča nezaradiť ho do verzionovania, ani v súkromnom repozitári. Ukladaj ho spolu so svojimi tajnými údajmi.
Správa dvojfaktorového overovania (2FA)
2FA predstavuje výzvu, pretože často vyžaduje ľudský zásah, či už ide o SMS kód alebo aplikáciu authenticator. Presne to je jej účelom: je navrhnutá tak, aby ju automat nedokázal sám obísť. Existujú dva prístupy v závislosti od použitého faktora a výber faktora pri vytváraní servisného účtu určuje, či môže tvoje workflow bežať bez obsluhy.
Automatizované TOTP
Ak účet používa aplikáciu TOTP ako Google Authenticator alebo Authy, zobrazený kód je len funkciou zdieľaného tajného kľúča a času. Tvoj kód ho teda môže vygenerovať a zadať sám, bez toho, aby ho ukázal modelu.
import os
import pyotp
def enter_totp_code(page):
"""Zadá aktuálny kód TOTP: tajný kľúč aj kód zostávajú v tvojom kóde."""
totp = pyotp.TOTP(os.environ["TOTP_SECRET"])
page.get_by_label("Verification code").fill(totp.now())
page.get_by_role("button", name="Verify").click()
Zváž, čo robíš: uloženie tajného kľúča TOTP vedľa hesla redukuje 2FA na jediný faktor, keďže obe tajomstvá žijú na tom istom mieste. Tento prístup vyhrad pre dedikovaný servisný účet s právami obmedzenými na nevyhnutné minimum.
Manuálne čakanie
Faktory, ktoré nemožno automatizovať, ako SMS alebo push notifikácie, si vyžadujú explicitnú pauzu. Agent sa zastaví, operátor potvrdí prihlásenie na svojom telefóne a potom sa cyklus obnoví tam, kde skončil. Toto je prijateľné riešenie pre proces spúšťaný manuálne, oveľa menej však pre nočný cron job.
def wait_for_2fa(page):
"""Pozastaví agenta a čaká na manuálne potvrdenie."""
print("Vyžaduje sa 2FA. Potvrď manuálne a potom stlač Enter.")
input("Stlač Enter pre pokračovanie...")
# Agent pokračuje po potvrdení
Správa SSO (Single Sign-On)
Prihlásenia SSO (Google, Microsoft, SAML) presmerujú na externého poskytovateľa identity: agent by počas toku zmenil doménu a musel by tam zadať prihlasovacie údaje. Tento krok nedeleguj na agenta. Prihlásenie SSO vykonaj raz manuálne vo viditeľnom prehliadači ovládanom Playwright a následne ulož stav relácie: následné spustenia začnú z tohto stavu.
def manual_sso_login(login_url: str, filepath="session.json"):
"""Človek sa prihlási vo viditeľnom prehliadači; relácia sa uloží."""
pw = sync_playwright().start()
browser = pw.chromium.launch(headless=False)
context = browser.new_context()
page = context.new_page()
page.goto(login_url)
input("Prihlás sa v otvorenom okne a potom stlač Enter...")
save_session(context, filepath)
browser.close()
pw.stop()
Keď relácia nakoniec vyprší, workflow sa musí zastaviť a vyžiadať si toto ľudské prihlásenie znova. Pridaj túto inštrukciu do pokynov pre agenta: ak sa ocitne pred stránkou poskytovateľa identity, zastaví sa a nahlási to namiesto toho, aby sa o niečo pokúšal.
Detekcia stavu prihlásenia
Celá táto mechanika stojí na otázke, na ktorú musíš vedieť spoľahlivo odpovedať: sme prihlásení? Vyhradená funkcia skríži dva signály: najprv aktuálnu URL, keďže presmerovanie na /login je jednoznačné, a potom prítomnosť prvku vyhradeného pre autentifikovaných používateľov, typicky menu účtu. Prvý test je okamžitý, druhý pokrýva aplikácie, ktoré zobrazia prihlasovaciu stránku bez zmeny URL.
from playwright.sync_api import TimeoutError as PlaywrightTimeoutError
def is_logged_in(page) -> bool:
"""Skontroluje, či je relácia aktívna."""
# Kontrola URL
if "/login" in page.url or "/signin" in page.url:
return False
# Kontrola prvku v DOM
try:
page.wait_for_selector("[data-testid=user-menu]", timeout=3000)
return True
except PlaywrightTimeoutError:
return False
Blok except cieli presne na vypršanie časového limitu: holé except: by tiež zhltilo prerušenie klávesnicou alebo skutočnú chybu v programovaní, ktoré chceš vidieť prebublávať nahor.
Bezpečnosť prihlasovacích údajov
"Nikdy neukladaj heslá do zdrojového kódu, svojich promptov ani logov."
V praxi sa toto pravidlo rozkladá na niekoľko návykov, ktoré po zaužívaní stoja takmer nič. Prihlasovacie údaje žijú v premenných prostredia, ktoré sa vo vývoji načítavajú zo súboru .env, ktorý okamžite vylúčiš z verzionovania cez .gitignore – toto opomenutie je klasickou príčinou úniku tajných údajov vo verejných repozitároch. V produkcii tento súbor nahraď správcom tajných údajov, ako je Vault alebo AWS Secrets Manager, ktorý doručuje hodnoty na požiadanie a sleduje prístup. Číta ich len tvoj kód, nikdy nie model. Naplánuj si pravidelnú rotáciu hesiel a API tokenov, aby starý únik už nič neotvoril. Nakoniec filtruj svoje logy, aby sa do nich nikdy nedostali citlivé údaje: agent, ktorý verne loguje každý stlačení kláves, kopíruje aj to, čo bol nútený napísať.
Kľúčové poznatky
- Model nikdy nevidí tajný údaj: tvoje heslo a kód 2FA zadáva tvoj kód pomocou Playwright
- Ukladaj stav relácie pomocou
storage_statea zaobchádzaj s týmto súborom ako s tajným údajom - TOTP sa automatizuje na strane kódu a vyhradzuje sa pre servisný účet s obmedzenými právami
- Prihlásenie SSO vykonaj raz manuálne a následne opakovane používaj uloženú reláciu
- Pred spustením workflow vždy skontroluj stav prihlásenia