Obsługa uwierzytelniania i sesji
Na tej stronie
Lekcja przepisana 3 listopada 2026 na podstawie przewodnika Computer use od OpenAI oraz dokumentacji uwierzytelniania Playwright. Poprzednia wersja umieszczała hasła i kody 2FA bezpośrednio w prompcie wysyłanym do modelu – w tym poprzez zmienne środowiskowe, co nie zapobiega ich transmisji – oraz delegowała logowanie SSO na agenta. Teraz Twój kod zarządza sekretami, stan sesji jest zapisywany za pomocą
storage_state, a logowanie SSO wykonuje się raz ręcznie. Źródła: Computer use · Playwright, authentication.
Wyzwanie związane z uwierzytelnianiem
Większość przepływów pracy automatyzacji wymaga bycia zalogowanym do usługi. Dopóki Twój agent porusza się po stronach publicznych, wszystko działa poprawnie; w momencie, gdy musi otworzyć CRM, panel administracyjny lub skrzynkę e-mail, natrafia na ścianę logowania. Formularze, 2FA, SSO i trwałe sesje wymagają różnego podejścia, ale jedna zasada rządzi nimi wszystkimi: model nigdy nie widzi sekretu.
Logowanie przez formularz
Pokusa polega na podyktowaniu agentowi sekwencji kroków, łącznie z danymi uwierzytelniającymi:
# NIE RÓB TEGO: hasło trafia do żądania wysyłanego do API
task = """
Zaloguj się na stronę:
1. Kliknij pole e-mail i wpisz: [email protected]
2. Kliknij pole hasła i wpisz: MyPassword123
3. Kliknij przycisk "Log in"
"""
Odczytanie hasła ze zmiennej środowiskowej przed wstawieniem go do promptu nic nie zmienia: nadal pozostawia to Twoją infrastrukturę w żądaniu, dane są przechowywane wraz z odpowiedzią (odpowiedzi są domyślnie zapisywane, zob. Lekcja 12) i mogą wycieknąć do logów. OpenAI zaleca utrzymywanie danych uwierzytelniających poza tekstem strony i zrzutami ekranu. Rozwiązaniem jest wypełnienie formularza logowania przez Twój kod przy użyciu Playwright, a następnie przekazanie sterowania agentowi dopiero po otwarciu sesji.
import os
def log_in(page, login_url: str):
"""Logowanie wykonywane przez Twój kod: model nigdy nie widzi hasła."""
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")
Dostosuj etykiety Email i Password do swojej aplikacji. Jest to jedno z nielicznych miejsc w przepływie pracy, gdzie użycie selektora jest w pełni uzasadnione: strona logowania rzadko się zmienia, a stawka bezpieczeństwa przewyższa potrzebę elastyczności.
Ponowne wykorzystanie stanu sesji
Logowanie przy każdym wykonaniu marnuje czas i może czasem wyzwalać alerty bezpieczeństwa po stronie usługi. Playwright potrafi zapisać stan kontekstu – ciasteczka, lokalny magazyn, IndexedDB – do pliku, a następnie utworzyć nowy kontekst na podstawie tego pliku.
import os
def save_session(context, filepath="session.json"):
"""Zapisuje bieżący stan sesji."""
context.storage_state(path=filepath)
def new_context_with_session(browser, filepath="session.json"):
"""Tworzy kontekst z zapisanej sesji, jeśli taka istnieje."""
options = {"viewport": {"width": 1280, "height": 720}}
if os.path.exists(filepath):
options["storage_state"] = filepath
return browser.new_context(**options)
Zintegrowane z przepływem pracy, tworzy to logikę dwuetapową: zacznij od zapisanej sesji, zweryfikuj, czy jest nadal ważna, i przejdź przez logowanie ponownie tylko w razie niepowodzenia. Stan jest zapisywany ponownie po zadaniu, ponieważ wiele usług odnawia swój token sesji w trakcie działania.
from playwright.sync_api import sync_playwright
def authenticated_workflow(task: str, login_url: str):
"""Przepływ pracy z ponownym wykorzystaniem sesji."""
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("Sesja przywrócona pomyślnie")
else:
log_in(page, login_url) # Twój kod, nie agent
if not is_logged_in(page):
raise RuntimeError("Logowanie niemożliwe: sprawdź dane lub 2FA")
save_session(context)
result = run_agent(task, page=page)
save_session(context) # aktualizacja stanu
return result
finally:
browser.close()
pw.stop()
Traktuj plik sesji jak hasło: Playwright ostrzega, że może on zawierać ciasteczka i nagłówki pozwalające na podszywanie się pod konto, i stanowczo odradza wersjonowanie go, nawet w prywatnym repozytorium. Przechowuj go razem ze swoimi sekretami.
Obsługa uwierzytelniania dwuskładnikowego (2FA)
2FA stanowi wyzwanie, ponieważ często wymaga interwencji człowieka, czy to kodu SMS, czy aplikacji uwierzytelniającej. Takie jest właśnie jej przeznaczenie: została zaprojektowana tak, aby automat nie mógł jej samodzielnie obejść. Współistnieją dwa podejścia w zależności od użytego czynnika, a wybór czynnika podczas tworzenia konta usługi decyduje o tym, czy Twój przepływ pracy może działać bez nadzoru.
Zautomatyzowane TOTP
Jeśli konto korzysta z aplikacji TOTP, takiej jak Google Authenticator lub Authy, wyświetlany kod jest jedynie funkcją współdzielonego sekretu i zegara. Twój kod może więc go wygenerować i wprowadzić samodzielnie, nie pokazując go modelowi.
import os
import pyotp
def enter_totp_code(page):
"""Wprowadza bieżący kod TOTP: sekret i kod pozostają w Twoim kodzie."""
totp = pyotp.TOTP(os.environ["TOTP_SECRET"])
page.get_by_label("Verification code").fill(totp.now())
page.get_by_role("button", name="Verify").click()
Zastanów się, co robisz: przechowywanie sekretu TOTP obok hasła redukuje 2FA do pojedynczego czynnika, ponieważ oba sekrety znajdują się w tym samym miejscu. Zarezerwuj to podejście dla dedykowanego konta usługi, z uprawnieniami ograniczonymi do absolutnego minimum.
Ręczne oczekiwanie
Czynniki nieautomatyzowalne, takie jak SMS lub powiadomienia push, wymagają wyraźnej pauzy. Agent zatrzymuje się, operator zatwierdza dostęp na swoim telefonie, a pętla wznawia działanie od momentu przerwania. Jest to rozwiązanie akceptowalne dla procesu uruchamianego ręcznie, znacznie mniej dla nocnego zadania cron.
def wait_for_2fa(page):
"""Wstrzymuje agenta i czeka na ręczne zatwierdzenie."""
print("Wymagane 2FA. Zatwierdź ręcznie, a następnie naciśnij Enter.")
input("Naciśnij Enter, aby kontynuować...")
# Agent wznawia działanie po zatwierdzeniu
Obsługa SSO (Single Sign-On)
Logowania SSO (Google, Microsoft, SAML) przekierowują do zewnętrznego dostawcy tożsamości: agent zmieniłby domenę w trakcie przepływu i musiałby wprowadzić tam dane uwierzytelniające. Nie deleguj tego kroku na agenta. Wykonaj logowanie SSO raz, ręcznie, w widocznej przeglądarce kontrolowanej przez Playwright, a następnie zapisz stan sesji: kolejne wykonania startują z tego stanu.
def manual_sso_login(login_url: str, filepath="session.json"):
"""Człowiek loguje się w widocznej przeglądarce; sesja jest zapisywana."""
pw = sync_playwright().start()
browser = pw.chromium.launch(headless=False)
context = browser.new_context()
page = context.new_page()
page.goto(login_url)
input("Zaloguj się w otwartym oknie, a następnie naciśnij Enter...")
save_session(context, filepath)
browser.close()
pw.stop()
Gdy sesja w końcu wygaśnie, przepływ pracy musi się zatrzymać i ponownie zażądać tego ręcznego logowania. Dodaj tę instrukcję do wytycznych agenta: jeśli znajdzie się przed stroną dostawcy tożsamości, musi się zatrzymać i zgłosić ten fakt, zamiast próbować cokolwiek zrobić.
Wykrywanie stanu logowania
Cała ta mechanika opiera się na pytaniu, na które musisz być w stanie rzetelnie odpowiedzieć: czy jesteśmy zalogowani? Dedykowana funkcja krzyżuje dwa sygnały: najpierw bieżący adres URL, ponieważ przekierowanie do /login jest jednoznaczne, a następnie obecność elementu zarezerwowanego dla uwierzytelnionych użytkowników, typowo menu konta. Pierwszy test jest natychmiastowy, drugi pokrywa aplikacje, które wyświetlają stronę logowania bez zmiany adresu URL.
from playwright.sync_api import TimeoutError as PlaywrightTimeoutError
def is_logged_in(page) -> bool:
"""Sprawdza, czy sesja jest aktywna."""
# Sprawdzenie URL
if "/login" in page.url or "/signin" in page.url:
return False
# Sprawdzenie elementu DOM
try:
page.wait_for_selector("[data-testid=user-menu]", timeout=3000)
return True
except PlaywrightTimeoutError:
return False
Klauzula except celuje precyzyjnie w wygaśnięcie limitu czasu: gołe except: połknęłoby również przerwanie z klawiatury lub rzeczywisty błąd programistyczny, które chcesz zobaczyć wypływające na powierzchnię.
Bezpieczeństwo danych uwierzytelniających
"Nigdy nie przechowuj haseł w kodzie źródłowym, promptach ani logach."
W praktyce zasada ta przekłada się na kilka nawyków, które po wdrożeniu kosztują niemal nic. Dane uwierzytelniające żyją w zmiennych środowiskowych, zasilanych w fazie rozwoju przez plik .env, który natychmiast wyłączasz z kontroli wersji poprzez .gitignore – to przeoczenie jest klasyczną przyczyną wycieków sekretów w publicznych repozytoriach. W środowisku produkcyjnym zastąp ten plik menedżerem sekretów, takim jak Vault lub AWS Secrets Manager, który dostarcza wartości na żądanie i śledzi dostęp. Tylko Twój kod je odczytuje, nigdy model. Zaplanuj regularną rotację haseł i tokenów API, tak aby stary wyciek nie otwierał już niczego. Na koniec filtruj swoje logi, aby nigdy nie rejestrować tam wrażliwych danych: agent, który wiernie loguje każde naciśnięcie klawisza, kopiuje również to, co kazano mu wpisać.
Kluczowe wnioski
- Model nigdy nie widzi sekretu: Twój kod wprowadza hasło i kod 2FA za pomocą Playwright
- Zapisuj stan sesji za pomocą
storage_statei traktuj ten plik jak sekret - TOTP jest automatyzowane po stronie kodu, zarezerwowane dla konta usługi o ograniczonych uprawnieniach
- Wykonaj logowanie SSO raz ręcznie, a następnie ponownie wykorzystaj zapisaną sesję
- Zawsze sprawdzaj stan logowania przed uruchomieniem przepływu pracy