Prejsť na hlavný obsah
Slovenčina— Vyberte jazyk
Menu

Správa overovania a relácií

Lekcia 8 z 14 Aktualizované 3. novembra 2026 Vývojár
Na tejto strane
  1. Výzva overovania
  2. Prihlásenie cez formulár
  3. Opätovné použitie stavu relácie
  4. Správa dvojfaktorového overovania (2FA)
  5. Správa SSO (Single Sign-On)
  6. Detekcia stavu prihlásenia
  7. Bezpečnosť prihlasovacích údajov
  8. Kľúčové poznatky

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_state a 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."

— Základné bezpečnostné pravidlo

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_state a 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