Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Hitelesítés és munkamenetek kezelése

8. lecke 14 közül Frissítve 2026. november 3. Fejlesztő
Ezen az oldalon
  1. A hitelesítés kihívása
  2. Űrlapalapú bejelentkezés
  3. Munkamenet-állapot újrafelhasználása
  4. Kétfaktoros hitelesítés (2FA) kezelése
  5. SSO (Egyszeri bejelentkezés) kezelése
  6. Bejelentkezési állapot észlelése
  7. Hitelesítő adatok biztonsága
  8. Főbb megállapítások

A leckét 2026. november 3-án írtuk át az OpenAI Computer use útmutatója és a Playwright hitelesítési dokumentációja alapján. A korábbi verzió közvetlenül a modellnek küldett promptba helyezte el a jelszavakat és a kétfaktoros hitelesítés (2FA) kódjait – beleértve a környezeti változókon keresztüli átadást is, ami nem akadályozza meg az adatok továbbítását –, és az SSO-bejelentkezést az ágensre bízta. Mostantól a kódod kezeli a titkos adatokat, a munkamenet állapotát a storage_state segítségével mented, és az SSO-t egyszer manuálisan végzed el. Források: Computer use · Playwright, authentication.

A hitelesítés kihívása

A legtöbb automatizálási munkafolyamat megköveteli, hogy bejelentkezz egy szolgáltatásba. Amíg az ágensed nyilvános oldalakon marad, minden rendben működik; ahogy azonban CRM-re, back office rendszerre vagy e-mail fiókra van szüksége, falba ütközik a bejelentkezési képernyőnél. Az űrlapok, a 2FA, az SSO és a tartós munkamenetek mindegyike eltérő kezelést igényel, de egy szabály minderre vonatkozik: a modell soha nem lát titkos adatot.

Űrlapalapú bejelentkezés

A kísértés nagy, hogy lépésről lépésre diktáld az ágensnek a teendőket, beleértve a hitelesítő adatokat is:

# NE CSINÁLD ÍGY: a jelszó bekerül az API-nak küldött kérésbe
task = """
Jelentkezz be az oldalra:
1. Kattints az e-mail mezőre, és írd be: [email protected]
2. Kattints a jelszó mezőre, és írd be: MyPassword123
3. Kattints a "Bejelentkezés" gombra
"""

Ha a jelszót a promptba illesztés előtt környezeti változóból olvasod be, az semmin sem változtat: az adat így is benne marad a kérésben, megőrződik a válaszban – a válaszok alapértelmezetten tárolódnak (12. lecke) –, és kiszivároghat a naplófájlokba is. Az OpenAI azt javasolja, hogy a hitelesítő adatokat tartsd távol az oldalszövegtől és a képernyőképektől. A megoldás az, hogy a kódod tölti ki a bejelentkezési űrlapot a Playwright segítségével, és csak a munkamenet megnyitása után adja át az irányítást az ágensnek.

import os

def log_in(page, login_url: str):
    """A bejelentkezést a kódod végzi: a modell soha nem látja a jelszót."""
    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")

Igazítsd az Email és Password címkéket az alkalmazásodhoz. Ez a munkafolyamat azon kevés helyeinek egyike, ahol a szelektor használata teljesen indokolt: a bejelentkezési oldal ritkán változik, és a biztonsági kockázat felülírja a rugalmasság igényét.

Munkamenet-állapot újrafelhasználása

Ha minden futtatáskor újra bejelentkezel, az időpocsékolás, és biztonsági riasztásokat is kiválthat a szolgáltató oldalán. A Playwright képes elmenteni egy kontextus állapotát – sütik, helyi tároló, IndexedDB – egy fájlba, majd ebből a fájlból új kontextust létrehozni.

import os

def save_session(context, filepath="session.json"):
    """Elmenti a jelenlegi munkamenet állapotát."""
    context.storage_state(path=filepath)

def new_context_with_session(browser, filepath="session.json"):
    """Létrehoz egy kontextust egy elmentett munkamenetből, ha létezik ilyen."""
    options = {"viewport": {"width": 1280, "height": 720}}
    if os.path.exists(filepath):
        options["storage_state"] = filepath
    return browser.new_context(**options)

A munkafolyamatba integrálva ez egy kétlépéses logikát hoz létre: az elmentett munkamenetből indulsz, ellenőrzöd, hogy még érvényes-e, és csak akkor lépsz be újra, ha ez sikertelen. A feladat után az állapotot ismét elmented, mivel sok szolgáltatás menet közben megújítja a munkamenet-tokenjét.

from playwright.sync_api import sync_playwright

def authenticated_workflow(task: str, login_url: str):
    """Munkafolyamat munkamenet-újrafelhasználással."""
    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("A munkamenet sikeresen helyreállt")
        else:
            log_in(page, login_url)  # a te kódod, nem az ágensé
            if not is_logged_in(page):
                raise RuntimeError("Bejelentkezés lehetetlen: ellenőrizd a hitelesítő adatokat vagy a 2FA-t")
        save_session(context)

        result = run_agent(task, page=page)
        save_session(context)  # állapot frissítése
        return result
    finally:
        browser.close()
        pw.stop()

Kezeld a munkamenetfájlt úgy, mint egy jelszót: a Playwright figyelmeztet, hogy tartalmazhat olyan sütiket és fejléceket, amelyek lehetővé teszik a fiók megszemélyesítését, és határozottan javasolja, hogy ne verziókezd, még privát tárolóban sem. Tárold a titkos adataiddal együtt.

Kétfaktoros hitelesítés (2FA) kezelése

A 2FA kihívást jelent, mert gyakran emberi beavatkozást igényel, legyen szó SMS-kódról vagy hitelesítő alkalmazásról. Pontosan ez a célja: úgy tervezték, hogy egy automata egyedül ne tudja megkerülni. Két megközelítés létezik attól függően, hogy milyen faktort használsz, és a szolgáltatásfiók létrehozásakor választott faktor határozza meg, hogy a munkafolyamatod futtatható-e felügyelet nélkül.

Automatizált TOTP

Ha a fiók TOTP alkalmazást használ, mint például a Google Authenticator vagy az Authy, a megjelenített kód csupán a megosztott titok és az idő függvénye. A kódod ezért képes előállítani és beírni ezt anélkül, hogy megmutatná a modellnek.

import os

import pyotp

def enter_totp_code(page):
    """Beírja az aktuális TOTP kódot: a titok és a kód a kódodban marad."""
    totp = pyotp.TOTP(os.environ["TOTP_SECRET"])
    page.get_by_label("Verification code").fill(totp.now())
    page.get_by_role("button", name="Verify").click()

Gondold át, mit csinálsz: ha a TOTP titkot a jelszó mellett tárolod, a 2FA-t egyetlen faktorra redukálod, mivel mindkét titok ugyanott van. Ezt a megközelítést csak dedikált szolgáltatásfiókokra tartogasd, szigorúan minimálisra korlátozott jogosultságokkal.

Manuális várakozás

A nem automatizálható faktorok, mint az SMS vagy a push értesítések, explicit szüneteltetést igényelnek. Az ágens megáll, egy operátor jóváhagyja a belépést a telefonján, majd a ciklus ott folytatódik, ahol abbamaradt. Ez elfogadható megoldás manuálisan indított folyamatoknál, de éjszakai cron feladatoknál sokkal kevésbé ideális.

def wait_for_2fa(page):
    """Szünetelteti az ágenst, és vár a manuális jóváhagyásra."""
    print("2FA szükséges. Hagyd jóvá manuálisan, majd nyomj Entert.")
    input("Nyomj Entert a folytatáshoz...")
    # Az ágens a jóváhagyás után folytatja

SSO (Egyszeri bejelentkezés) kezelése

Az SSO-bejelentkezések (Google, Microsoft, SAML) átirányítanak egy külső identitásszolgáltatóhoz: az ágens domain-t váltana menet közben, és ott kellene megadnia a hitelesítő adatokat. Ne bízd ezt a lépést az ágensre. Végezd el az SSO-bejelentkezést egyszer, manuálisan, egy látható, Playwright által vezérelt böngészőben, majd mentsd el a munkamenet állapotát: a későbbi futtatások ebből az állapotból indulnak.

def manual_sso_login(login_url: str, filepath="session.json"):
    """Egy ember bejelentkezik egy látható böngészőben; a munkamenet elmentésre kerül."""
    pw = sync_playwright().start()
    browser = pw.chromium.launch(headless=False)
    context = browser.new_context()
    page = context.new_page()
    page.goto(login_url)
    input("Jelentkezz be a megnyílt ablakban, majd nyomj Entert...")
    save_session(context, filepath)
    browser.close()
    pw.stop()

Amikor a munkamenet végül lejár, a munkafolyamatnak meg kell állnia, és újra kérnie kell ezt az emberi bejelentkezést. Add hozzá ezt az utasítást az ágens irányelveihez: ha egy identitásszolgáltató oldalán találja magát, álljon meg és jelentse ezt, ahelyett, hogy bármit is megpróbálna tenni.

Bejelentkezési állapot észlelése

Ez a teljes mechanika egy kérdésre épül, amire megbízhatóan választ kell tudnod adni: be vagyunk jelentkezve? Egy dedikált függvény két jelet vizsgál: először az aktuális URL-t, mivel a /login címre történő átirányítás egyértelmű, majd egy olyan elem jelenlétét, amely csak bejelentkezett felhasználók számára elérhető, jellemzően a fiókmenüt. Az első teszt azonnali, a második pedig lefedi azokat az alkalmazásokat, amelyek az URL megváltoztatása nélkül jelenítik meg a bejelentkezési oldalt.

from playwright.sync_api import TimeoutError as PlaywrightTimeoutError

def is_logged_in(page) -> bool:
    """Ellenőrzi, hogy a munkamenet aktív-e."""
    # URL ellenőrzés
    if "/login" in page.url or "/signin" in page.url:
        return False

    # DOM elem ellenőrzés
    try:
        page.wait_for_selector("[data-testid=user-menu]", timeout=3000)
        return True
    except PlaywrightTimeoutError:
        return False

Az except kifejezetten az időtúllépés lejártát célozza meg: egy puszta except: elnyelné a billentyűzet-megszakítást vagy egy valódi programozási hibát is, amelyeket látnod kell, hogy felszínre kerüljenek.

Hitelesítő adatok biztonsága

"Soha ne tárolj jelszavakat a forráskódban, a promptokban vagy a naplókban."

— Alapvető biztonsági szabály

A gyakorlatban ez a szabály néhány szokássá válik, amelyek szinte semmibe sem kerülnek, ha egyszer befogadtad őket. A hitelesítő adatok környezeti változókban élnek, fejlesztés során egy .env fájlból töltődnek fel, amelyet azonnal ki kell zárnod a verziókezelésből a .gitignore segítségével – ez a mulasztás a titkos adatok nyilvános tárolókba kerülésének klasszikus oka. Éles környezetben cseréld le ezt a fájlt egy titokkezelőre, mint például a Vault vagy az AWS Secrets Manager, amelyek igény szerint szolgáltatják az értékeket és naplózzák a hozzáférést. Csak a kódod olvassa őket, soha nem a modell. Tervezd meg a jelszavak és API-tokenek rendszeres cseréjét, így egy régi szivárgás már nem nyit meg semmit. Végül szűrd a naplóidat, hogy soha ne rögzítsenek érzékeny adatokat: egy ágens, amely hűségesen naplóz minden billentyűleütést, ugyanúgy lemásolja azt is, amit begépelni utasítottak.

Főbb megállapítások

  • A modell soha nem lát titkos adatot: a kódod írja be a jelszót és a 2FA kódot a Playwright segítségével
  • Mentsd el a munkamenet állapotát a storage_state segítségével, és kezeld ezt a fájlt titokként
  • A TOTP automatizálható a kód oldalán, de csak korlátozott jogosultságú szolgáltatásfiókra használd
  • Az SSO-bejelentkezést végezd el egyszer manuálisan, majd használd újra az elmentett munkamenetet
  • Mielőtt elindítasz egy munkafolyamatot, mindig ellenőrizd a bejelentkezési állapotot