Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Správa ověření a relací

Lekce 8 z 14 Aktualizováno 3. listopadu 2026 Vývojář
Na této stránce
  1. Výzva spojená s ověřováním
  2. Přihlášení pomocí formuláře
  3. Opětovné použití stavu relace
  4. Zpracování dvoufaktorového ověření (2FA)
  5. Zpracování SSO (Single Sign-On)
  6. Detekce stavu přihlášení
  7. Bezpečnost přihlašovacích údajů
  8. Klíčové poznatky

Lekce přepracována 3. listopadu 2026 na základě příručky Computer use od OpenAI a dokumentace k ověřování v Playwrightu. Předchozí verze vkládala hesla a kódy 2FA přímo do promptu odesílaného modelu – včetně použití proměnných prostředí, což jejich přenos nezabrání – a delegovala přihlášení přes SSO na agenta. Nyní tvůj kód zpracovává tajné údaje, stav relace se ukládá pomocí storage_state a přihlášení SSO se provede jednou ručně. Zdroje: Computer use · Playwright, authentication.

Výzva spojená s ověřováním

Většina automatizačních workflow vyžaduje přihlášení ke službě. Dokud tvůj agent zůstává na veřejných stránkách, vše funguje hladce; jakmile potřebuje otevřít CRM, back-office nebo e-mailovou schránku, narazí na přihlašovací zeď. Formuláře, 2FA, SSO a trvalé relace vyžadují odlišný přístup, ale jedno pravidlo platí pro všechny: model nikdy nevidí tajný údaj.

Přihlášení pomocí formuláře

Pokušení diktovat agentovi sekvenci včetně přihlašovacích údajů je velké:

# NEDĚLEJ TOHLE: heslo se dostane do požadavku odeslaného API
task = """
Přihlas se na stránku:
1. Klikni na pole e-mail a napiš: [email protected]
2. Klikni na pole heslo a napiš: MyPassword123
3. Klikni na tlačítko "Log in"
"""

Čtení hesla z proměnné prostředí před jeho vložením do promptu nic nemění: stále opouští tvou infrastrukturu v rámci požadavku, je uchováváno spolu s odpovědí (odpovědi se ve výchozím nastavení ukládají, viz Lekce 12) a může uniknout do tvých logů. OpenAI doporučuje udržovat přihlašovací údaje mimo text stránky a snímky obrazovky. Řešením je vyplnit přihlašovací formulář tvým kódem pomocí Playwrightu a předat řízení agentovi až po otevření relace.

import os

def log_in(page, login_url: str):
    """Přihlášení provádí tvůj 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")

Přizpůsob štítky Email a Password své aplikaci. Toto je jedno z mála míst ve workflow, kde je selektor plně oprávněný: přihlašovací stránka se mění zřídka a bezpečnostní rizika převažují nad potřebou flexibility.

Opětovné použití stavu relace

Přihlašování při každém spuštění plýtvá časem a může na straně služby někdy spustit bezpečnostní alerty. Playwright umí uložit stav kontextu – cookies, místní úložiště, IndexedDB – do souboru a následně z tohoto souboru vytvořit nový kontext.

import os

def save_session(context, filepath="session.json"):
    """Uloží aktuální stav relace."""
    context.storage_state(path=filepath)

def new_context_with_session(browser, filepath="session.json"):
    """Vytvoří kontext z uložené relace, pokud existuje."""
    options = {"viewport": {"width": 1280, "height": 720}}
    if os.path.exists(filepath):
        options["storage_state"] = filepath
    return browser.new_context(**options)

Integrováno do workflow to vytváří dvoukrokovou logiku: začni z uložené relace, ověř, zda je stále platná, a pouze pokud to selže, projdi znovu přihlášením. Stav se po dokončení úkolu znovu uloží, protože mnoho služeb během běhu obnovuje svůj relační token.

from playwright.sync_api import sync_playwright

def authenticated_workflow(task: str, login_url: str):
    """Workflow s opětovným použitím relace."""
    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("Relace úspěšně obnovena")
        else:
            log_in(page, login_url)  # tvůj kód, ne agent
            if not is_logged_in(page):
                raise RuntimeError("Přihlášení selhalo: zkontroluj údaje nebo 2FA")
        save_session(context)

        result = run_agent(task, page=page)
        save_session(context)  # aktualizace stavu
        return result
    finally:
        browser.close()
        pw.stop()

Zacházej se souborem relace jako s heslem: Playwright varuje, že může obsahovat cookies a hlavičky umožňující impersonaci účtu, a důrazně doporučuje neverzovat jej, ani v soukromém repozitáři. Ukládej jej společně se svými tajnými údaji.

Zpracování dvoufaktorového ověření (2FA)

2FA představuje výzvu, protože často vyžaduje lidský zásah, ať už jde o SMS kód nebo aplikaci authenticator. To je přesně její účel: je navržena tak, aby ji automat nemohl sám obejít. Existují dva přístupy v závislosti na použitém faktoru a volba faktoru při vytváření servisního účtu určuje, zda může tvoje workflow běžet bez obsluhy.

Automatizované TOTP

Pokud účet používá aplikaci TOTP, jako je Google Authenticator nebo Authy, zobrazený kód je pouze funkcí sdíleného tajného klíče a času. Tvůj kód jej tedy může sám vygenerovat a zadat, aniž by jej ukazoval modelu.

import os

import pyotp

def enter_totp_code(page):
    """Zadá aktuální kód TOTP: tajný klíč i kód zůstávají v tvém kódu."""
    totp = pyotp.TOTP(os.environ["TOTP_SECRET"])
    page.get_by_label("Verification code").fill(totp.now())
    page.get_by_role("button", name="Verify").click()

Zvaž, co děláš: uložení tajného klíče TOTP vedle hesla redukuje 2FA na jediný faktor, protože oba tajné údaje žijí na stejném místě. Vyhraď tento přístup pro vyhrazený servisní účet s právy omezenými na nezbytné minimum.

Ruční čekání

Faktory, které nelze automatizovat, jako jsou SMS nebo push notifikace, vyžadují explicitní pauzu. Agent se zastaví, operátor provede ověření na svém telefonu a poté smyčka pokračuje tam, kde skončila. Toto je přijatelné řešení pro proces spouštěný ručně, mnohem méně vhodné pro noční cron job.

def wait_for_2fa(page):
    """Pozastaví agenta a čeká na ruční ověření."""
    print("Je vyžadováno 2FA. Ověř ručně a poté stiskni Enter.")
    input("Pro pokračování stiskni Enter...")
    # Agent pokračuje po ověření

Zpracování SSO (Single Sign-On)

Přihlášení přes SSO (Google, Microsoft, SAML) přesměrovává na externího poskytovatele identity: agent by během toku změnil doménu a musel by tam zadat přihlašovací údaje. Tento krok na agenta nedeleguj. Proveď přihlášení SSO jednou ručně ve viditelném prohlížeči ovládaném Playwrightem a poté ulož stav relace: následná spuštění začnou z tohoto stavu.

def manual_sso_login(login_url: str, filepath="session.json"):
    """Člověk se přihlásí ve viditelném prohlížeči; relace se uloží."""
    pw = sync_playwright().start()
    browser = pw.chromium.launch(headless=False)
    context = browser.new_context()
    page = context.new_page()
    page.goto(login_url)
    input("Přihlas se v otevřeném okně a poté stiskni Enter...")
    save_session(context, filepath)
    browser.close()
    pw.stop()

Když relace jednou vyprší, workflow se musí zastavit a vyžádat si toto lidské přihlášení znovu. Přidej tuto instrukci do pokynů pro agenta: pokud se ocitne před stránkou poskytovatele identity, zastaví se a nahlásí to, místo aby se o něco pokoušel.

Detekce stavu přihlášení

Celý tento mechanismus stojí na otázce, na kterou musíš umět spolehlivě odpovědět: jsme přihlášeni? Vyhrazená funkce zkříží dva signály: nejprve aktuální URL, protože přesměrování na /login je jednoznačné, a poté přítomnost prvku vyhrazeného pro ověřené uživatele, typicky nabídky účtu. První test je okamžitý, druhý pokrývá aplikace, které zobrazují přihlašovací stránku bez změny URL.

from playwright.sync_api import TimeoutError as PlaywrightTimeoutError

def is_logged_in(page) -> bool:
    """Zkontroluje, zda je relace aktivní."""
    # Kontrola URL
    if "/login" in page.url or "/signin" in page.url:
        return False

    # Kontrola prvku DOM
    try:
        page.wait_for_selector("[data-testid=user-menu]", timeout=3000)
        return True
    except PlaywrightTimeoutError:
        return False

Výjimka except cílí přesně na vypršení časového limitu: holé except: by také polklo přerušení klávesnicí nebo skutečnou chybu v programování, které chceš vidět probublat nahoru.

Bezpečnost přihlašovacích údajů

"Nikdy neukládej hesla ve zdrojovém kódu, svých promptech ani logech."

— Základní bezpečnostní pravidlo

V praxi se toto pravidlo rozkládá na několik návyků, které po přijetí stojí téměř nic. Přihlašovací údaje žijí v proměnných prostředí, které jsou ve vývoji napájeny souborem .env, jenž okamžitě vyloučíš z verzování prostřednictvím .gitignore – toto opomenutí je klasickou příčinou úniků tajných údajů na veřejná úložiště. V produkci tento soubor nahraď správcem tajných údajů, jako je Vault nebo AWS Secrets Manager, který dodává hodnoty na vyžádání a sleduje přístup. Čte je pouze tvůj kód, nikdy model. Naplánuj pravidelnou rotaci hesel a API tokenů, aby starý únik již nic neotevíral. Nakonec filtruj své logy, aby se do nich nikdy nezaznamenávala citlivá data: agent, který věrně loguje každý stisk klávesy, také kopíruje to, co bylo nucen napsat.

Klíčové poznatky

  • Model nikdy nevidí tajný údaj: tvůj kód zadává heslo a kód 2FA pomocí Playwrightu
  • Ukládej stav relace pomocí storage_state a zacházej s tímto souborem jako s tajným údajem
  • TOTP se automatizuje na straně kódu a je vyhrazeno pro servisní účet s omezenými právy
  • Přihlášení SSO proveď jednou ručně a poté znovu používej uloženou relaci
  • Před spuštěním workflow vždy zkontroluj stav přihlášení