Hitelesítés és munkamenetek kezelése
Ezen az oldalon
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_statesegí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."
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_statesegí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