Управление на автентикацията и сесиите
На тази страница
Урокът е пренаписан на 3 ноември 2026 г. въз основа на ръководството на OpenAI за Computer use и документацията на Playwright за автентикация. Предишната версия поставяше пароли и 2FA кодове директно в промпта, изпращан до модела — включително чрез променливи на средата, което не предотвратява тяхното предаване — и делегираше SSO входа на агента. Сега Вашият код управлява тайните, състоянието на сесията се запазва чрез
storage_state, а SSO се изпълнява веднъж ръчно. Източници: Computer use · Playwright, authentication.
Предизвикателството с автентикацията
Повечето работни потоци за автоматизация изискват влизане в услуга. Докато Вашият агент остава на публични страници, всичко работи добре; в момента, в който трябва да отвори CRM, бек-офис или пощенска кутия, той се сблъсква със стена за вход. Формуляри, 2FA, SSO и постоянни сесии изискват различно управление, но едно правило важи за всички: моделът никога не вижда тайна.
Вход чрез формуляр
Изкушението е да диктувате последователността на агента, включително идентификационните данни:
# НЕ ПРАВЕТЕ ТОВА: паролата отива в заявката, изпратена до API
task = """
Влезте в сайта:
1. Кликнете върху полето за имейл и напишете: [email protected]
2. Кликнете върху полето за парола и напишете: MyPassword123
3. Кликнете върху бутона "Log in"
"""
Четенето на паролата от променлива на средата преди вмъкването ѝ в промпта не променя нищо: инфраструктурата Ви все още я оставя в заявката, тя се запазва с отговора — отговорите се съхраняват по подразбиране (Урок 12) — и може да изтече във Вашите логове. OpenAI препоръчва да държите идентификационните данни извън текста на страницата и скрийншотите. Решението е Вашият код да попълни формата за вход с Playwright, след което да предаде контрола на агента, след като сесията е отворена.
import os
def log_in(page, login_url: str):
"""Входът се изпълнява от Вашия код: моделът никога не вижда паролата."""
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")
Адаптирайте етикетите Email и Password към Вашето приложение. Това е едно от малкото места в работния поток, където селекторът е напълно оправдан: страницата за вход рядко се променя, а залогът за сигурност надвишава нуждата от гъвкавост.
Повторно използване на състоянието на сесията
Влизането при всяко изпълнение губи време и понякога може да задейства предупреждения за сигурност от страна на услугата. Playwright може да запази състоянието на контекста — бисквитки, локално хранилище, IndexedDB — във файл, след което да създаде нов контекст от този файл.
import os
def save_session(context, filepath="session.json"):
"""Запазва текущото състояние на сесията."""
context.storage_state(path=filepath)
def new_context_with_session(browser, filepath="session.json"):
"""Създава контекст от запазена сесия, ако съществува такава."""
options = {"viewport": {"width": 1280, "height": 720}}
if os.path.exists(filepath):
options["storage_state"] = filepath
return browser.new_context(**options)
Интегрирано в работния поток, това създава двустъпкова логика: стартиране от запазената сесия, проверка дали все още е валидна и преминаване през входа отново само ако това се провали. Състоянието се запазва отново след задачата, защото много услуги подновяват своя токен за сесия по време на изпълнението.
from playwright.sync_api import sync_playwright
def authenticated_workflow(task: str, login_url: str):
"""Работен поток с повторно използване на сесията."""
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("Сесията е възстановена успешно")
else:
log_in(page, login_url) # Вашият код, не агентът
if not is_logged_in(page):
raise RuntimeError("Входът е невъзможен: проверете идентификационните данни или 2FA")
save_session(context)
result = run_agent(task, page=page)
save_session(context) # актуализиране на състоянието
return result
finally:
browser.close()
pw.stop()
Третирайте файла със сесията като парола: Playwright предупреждава, че той може да съдържа бисквитки и хедъри, които позволяват имитиране на акаунт, и силно съветва срещу неговото версиониране, дори в частно хранилище. Съхранявайте го заедно с Вашите тайни.
Управление на двуфакторната автентикация (2FA)
2FA представлява предизвикателство, защото често изисква човешка намеса, независимо дали става въпрос за SMS код или приложение за автентикация. Точно това е целта му: проектиран е така, че автоматизиран процес да не може да го заобиколи сам. Съществуват два подхода в зависимост от използвания фактор, а изборът на фактор при създаването на сервизния акаунт определя дали Вашият работен поток може да се изпълнява без надзор.
Автоматизиран TOTP
Ако акаунтът използва TOTP приложение като Google Authenticator или Authy, показаният код е просто функция на споделената тайна и часовника. Следователно Вашият код може да го генерира и въведе сам, без да го показва на модела.
import os
import pyotp
def enter_totp_code(page):
"""Въвежда текущия TOTP код: тайната и кодът остават във Вашия код."""
totp = pyotp.TOTP(os.environ["TOTP_SECRET"])
page.get_by_label("Verification code").fill(totp.now())
page.get_by_role("button", name="Verify").click()
Обмислете какво правите: съхраняването на TOTP тайната заедно с паролата свежда 2FA до един фактор, тъй като и двете тайни живеят на едно и също място. Запазете този подход за специализиран сервизен акаунт, с права, ограничени до строгия минимум.
Ръчно изчакване
Фактори, които не могат да се автоматизират, като SMS или push известия, изискват изрична пауза. Агентът спира, операторът валидира на телефона си, след което цикълът възобновява оттам, където е спрял. Това е приемливо решение за процес, стартиран ръчно, но много по-малко за нощна cron задача.
def wait_for_2fa(page):
"""Паузира агента и чака ръчна валидация."""
print("Изисква се 2FA. Валидирайте ръчно, след което натиснете Enter.")
input("Натиснете Enter, за да продължите...")
# Агентът възобновява след валидацията
Управление на SSO (Единна точка за вход)
SSSO входовете (Google, Microsoft, SAML) пренасочват към външен доставчик на идентичност: агентът би сменил домейна по средата на потока и би трябвало да въведе идентификационни данни там. Не делегирайте тази стъпка на агента. Извършете SSO входа веднъж, ръчно, във видим браузър, контролиран от Playwright, след което запазете състоянието на сесията: последващите изпълнения стартират от това състояние.
def manual_sso_login(login_url: str, filepath="session.json"):
"""Човек влиза във видим браузър; сесията се запазва."""
pw = sync_playwright().start()
browser = pw.chromium.launch(headless=False)
context = browser.new_context()
page = context.new_page()
page.goto(login_url)
input("Влезте в отворения прозорец, след което натиснете Enter...")
save_session(context, filepath)
browser.close()
pw.stop()
Когато сесията най-накрая изтече, работният поток трябва да спре и да поиска този човешки вход отново. Добавете тази инструкция към насоките за агента: ако се озове пред страница на доставчик на идентичност, той спира и докладва за това, вместо да опитва каквото и да е.
Откриване на състоянието на входа
Цялата тази механика почива на въпрос, на който трябва да можете да отговорите надеждно: влезли ли сме? Специална функция кръстосва два сигнала: първо текущия URL, тъй като пренасочването към /login е недвусмислено, и второ наличието на елемент, запазен за автентикирани потребители, обикновено менюто на акаунта. Първият тест е мигновен, вторият покрива приложения, които показват страницата за вход, без да променят URL адреса.
from playwright.sync_api import TimeoutError as PlaywrightTimeoutError
def is_logged_in(page) -> bool:
"""Проверява дали сесията е активна."""
# Проверка на URL
if "/login" in page.url or "/signin" in page.url:
return False
# Проверка на DOM елемент
try:
page.wait_for_selector("[data-testid=user-menu]", timeout=3000)
return True
except PlaywrightTimeoutError:
return False
Блокът except цели точно изтичането на времето за изчакване: гол except: би погълнал и прекъсване от клавиатурата или реална програмна грешка, които искате да изплуват на повърхността.
Сигурност на идентификационните данни
"Никога не съхранявайте пароли във Вашия изходен код, Вашите промптове или Вашите логове."
На практика това правило се разпада на няколко навика, които струват почти нищо, след като се възприемат. Идентификационните данни живеят в променливи на средата, захранвани при разработка от .env файл, който незабавно изключвате от контрола на версиите чрез .gitignore — това пропускане е класическа причина за изтичане на тайни в публични хранилища. В производствена среда заменете този файл с мениджър на тайни, като Vault или AWS Secrets Manager, който доставя стойности при поискване и проследява достъпа. Само Вашият код ги чете, никога моделът. Планирайте редовна ротация на паролите и API токените, така че старо изтичане да не отваря повече нищо. Накрая, филтрирайте Вашите логове, за да не записвате никога чувствителни данни там: агент, който добросъвестно логира всяко натискане на клавиш, също копира онова, което е накаран да напише.
Ключови изводи
- Моделът никога не вижда тайна: Вашият код въвежда паролата и 2FA кода с Playwright
- Запазете състоянието на сесията с
storage_stateи третирайте този файл като тайна - TOTP се автоматизира от страната на кода, запазен за сервизен акаунт с ограничени права
- Извършете SSO входа веднъж ръчно, след което използвайте повторно запазената сесия
- Винаги проверявайте състоянието на входа преди стартиране на работен поток