Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Tvarkyti autentifikavimą ir sesijas

Paskaita 8 iš 14 Atnaujinta 2026 m. lapkričio 3 d. Kūrėjas
Šiame puslapyje
  1. Autentifikavimo iššūkis
  2. Prisijungimas naudojant formas
  3. Sesijos būsenos pakartotinis naudojimas
  4. Dviejų veiksnių autentifikavimo (2FA) tvarkymas
  5. SSO (vienkartinio prisijungimo) tvarkymas
  6. Prisijungimo būsenos nustatymas
  7. Prisijungimo duomenų saugumas
  8. Svarbiausi punktai

Pamoka perrašyta 2026 m. lapkričio 3 d. remiantis OpenAI Computer use gairėmis ir Playwright autentifikavimo dokumentacija. Ankstesnė versija slaptažodžius ir 2FA kodus tiesiogiai įtraukdavo į modeliu siunčiamą užklausą – įskaitant per aplinkos kintamuosius, kas jų perdavimo neužkerta – ir perduodavo SSO prisijungimą agentui. Dabar tavo kodas tvarko paslaptis, sesijos būsena išsaugoma naudojant storage_state, o SSO atliekamas vieną kartą rankiniu būdu. Šaltiniai: Computer use · Playwright, authentication.

Autentifikavimo iššūkis

Daugumai automatizavimo darbo eigų reikia būti prisijungus prie paslaugos. Kol tavo agentas lieka viešuose puslapiuose, viskas veikia sklandžiai; tačiau kai tik jam reikia atidaryti CRM, administravimo skydelį ar el. pašto dėžutę, jis atsitrenkia į prisijungimo sieną. Formos, 2FA, SSO ir nuolatinės sesijos reikalauja skirtingo tvarkymo, tačiau visas jas valdo viena taisyklė: modelis niekada nemato paslapčių.

Prisijungimas naudojant formas

Gunda nurodyti agentui veiksmų seką, įskaitant prisijungimo duomenis:

# NEDARYK TO: slaptažodis patenka į API siunčiamą užklausą
task = """
Prisijunk prie svetainės:
1. Spustelėk el. pašto laukelį ir įvesk: [email protected]
2. Spustelėk slaptažodžio laukelį ir įvesk: MyPassword123
3. Spustelėk mygtuką „Log in“
"""

Slaptažodžio nuskaitymas iš aplinkos kintamojo prieš įterpiant jį į užklausą nieko nekeičia: tavo infrastruktūra vis tiek lieka užklausoje, ji išsaugoma kartu su atsakymu (atsakymai pagal numatytuosius nustatymus saugomi – žr. 12 pamoką) ir gali nutekėti į tavo žurnalus. OpenAI rekomenduoja nelaikyti prisijungimo duomenų puslapio tekste ar ekrano kopijose. Sprendimas – kad tavo kodas užpildytų prisijungimo formą naudodamas Playwright, o agentui perduotų valdymą tik atidarius sesiją.

import os

def log_in(page, login_url: str):
    """Prisijungimą atlieka tavo kodas: modelis slaptažodžio nemato."""
    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")

Pritaikyk etiketes Email ir Password savo programai. Tai viena iš nedaugelio darbo eigos vietų, kur selektorius yra visiškai pateisinamas: prisijungimo puslapiai retai keičiasi, o saugumo rizika nusveria lankstumą.

Sesijos būsenos pakartotinis naudojimas

Prisijungimas kiekvieno vykdymo metu eikvoja laiką ir kartais gali sukelti saugumo įspėjimus paslaugos pusėje. Playwright gali išsaugoti konteksto būseną – slapukus, vietinę saugyklą, IndexedDB – į failą, o tada sukurti naują kontekstą iš to failo.

import os

def save_session(context, filepath="session.json"):
    """Išsaugo dabartinę sesijos būseną."""
    context.storage_state(path=filepath)

def new_context_with_session(browser, filepath="session.json"):
    """Sukuria kontekstą iš išsaugotos sesijos, jei tokia yra."""
    options = {"viewport": {"width": 1280, "height": 720}}
    if os.path.exists(filepath):
        options["storage_state"] = filepath
    return browser.new_context(**options)

Integruota į darbo eigą, tai sukuria dviejų žingsnių logiką: pradėk nuo išsaugotos sesijos, patikrink, ar ji vis dar galioja, ir tik jei tai nepavyksta, prisijunk iš naujo. Būsena išsaugoma dar kartą po užduoties, nes daugelis paslaugų jos metu atnaujina savo sesijos žetoną.

from playwright.sync_api import sync_playwright

def authenticated_workflow(task: str, login_url: str):
    """Darbo eiga su sesijos pakartotiniu naudojimu."""
    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("Sesija sėkmingai atkurta")
        else:
            log_in(page, login_url)  # tavo kodas, ne agento
            if not is_logged_in(page):
                raise RuntimeError("Prisijungti neįmanoma: patikrink prisijungimo duomenis arba 2FA")
        save_session(context)

        result = run_agent(task, page=page)
        save_session(context)  # atnaujink būseną
        return result
    finally:
        browser.close()
        pw.stop()

Elkis su sesijos failu kaip su slaptažodžiu: Playwright įspėja, kad jame gali būti slapukų ir antraščių, leidžiančių apsimetinėti paskyra, ir griežtai rekomenduoja jo neįtraukti į versijų valdymą, net ir į privatų saugyklą. Saugok jį kartu su savo paslaptimis.

Dviejų veiksnių autentifikavimo (2FA) tvarkymas

2FA kelia iššūkį, nes dažnai reikalauja žmogaus įsikišimo, nesvarbu, ar tai SMS kodas, ar autentifikatoriaus programėlė. Tokia ir yra jos paskirtis: ji sukurta taip, kad automatonas jos negalėtų apeiti vienas. Egzistuoja du požiūriai, priklausomai nuo naudojamo veiksnio, o veiksnio pasirinkimas kuriant paslaugos paskyrą lemia, ar tavo darbo eiga gali vykti be priežiūros.

Automatizuotas TOTP

Jei paskyra naudoja TOTP programėlę, pvz., „Google Authenticator“ ar „Authy“, rodomas kodas yra tik bendros paslapties ir laiko funkcija. Todėl tavo kodas gali jį sugeneruoti ir įvesti pats, nerodydamas jo modeliui.

import os

import pyotp

def enter_totp_code(page):
    """Įveda dabartinį TOTP kodą: paslaptis ir kodas lieka tavo kode."""
    totp = pyotp.TOTP(os.environ["TOTP_SECRET"])
    page.get_by_label("Verification code").fill(totp.now())
    page.get_by_role("button", name="Verify").click()

Pagalvok, ką darai: TOTP paslapties saugojimas kartu su slaptažodžiu sumažina 2FA iki vieno veiksnio, nes abi paslaptys gyvena toje pačioje vietoje. Šį metodą taikyk tik specialiai paslaugos paskyrai, kurios teisės apribotos iki absoliučaus minimumo.

Rankinis laukimas

Neautomatinami veiksniai, tokie kaip SMS ar stumiami pranešimai, reikalauja aiškios pauzės. Agentas sustoja, operatorius patvirtina savo telefone, tada ciklas tęsiasi nuo tos vietos, kur sustojo. Tai priimtinas sprendimas rankiniu būdu paleistam procesui, tačiau daug mažiau tinkamas naktiniam „cron“ darbui.

def wait_for_2fa(page):
    """Sustabdo agentą ir laukia rankinio patvirtinimo."""
    print("Reikalingas 2FA. Patvirtinkite rankiniu būdu, tada paspauskite Enter.")
    input("Paspauskite Enter norėdami tęsti...")
    # Agentas tęsia darbą po patvirtinimo

SSO (vienkartinio prisijungimo) tvarkymas

SSO prisijungimai („Google“, „Microsoft“, SAML) nukreipia į išorinį tapatybės teikėją: agentas darbo eigos viduryje pakeistų domeną ir turėtų ten įvesti prisijungimo duomenis. Neperduok šio žingsnio agentui. Atlik SSO prisijungimą vieną kartą rankiniu būdu matomoje naršyklėje, valdomoje Playwright, tada išsaugok sesijos būseną: vėlesni vykdymai prasidės nuo šios būsenos.

def manual_sso_login(login_url: str, filepath="session.json"):
    """Žmogus prisijungia atidarytoje naršyklėje; sesija išsaugoma."""
    pw = sync_playwright().start()
    browser = pw.chromium.launch(headless=False)
    context = browser.new_context()
    page = context.new_page()
    page.goto(login_url)
    input("Prisijunkite atidarytame lange, tada paspauskite Enter...")
    save_session(context, filepath)
    browser.close()
    pw.stop()

Kai sesija galiausiai baigs galioti, darbo eiga turi sustoti ir vėl paprašyti šio žmogaus prisijungimo. Įtrauk šią instrukciją į agento gaires: jei jis atsiduria prieš tapatybės teikėjo puslapį, jis turi sustoti ir apie tai pranešti, o ne bandyti ką nors daryti.

Prisijungimo būsenos nustatymas

Visa ši mechanika remiasi klausimu, į kurį turi gebėti patikimai atsakyti: ar esame prisijungę? Speciali funkcija tikrina du signalus: pirmiausia dabartinį URL, nes nukreipimas į /login yra vienareikšmis, tada elemento, skirto autentifikuotiems naudotojams (paprastai paskyros meniu), buvimą. Pirmasis testas yra momentinis, antrasis apima programas, kurios rodo prisijungimo puslapį nepakeisdamos URL.

from playwright.sync_api import TimeoutError as PlaywrightTimeoutError

def is_logged_in(page) -> bool:
    """Tikrina, ar sesija aktyvi."""
    # URL tikrinimas
    if "/login" in page.url or "/signin" in page.url:
        return False

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

except tiksliai taikomas laiko limito pasibaigimui: paprastas except: taip pat „nurytų“ klaviatūros pertraukimą ar realią programavimo klaidą, o tu nori, kad jos iškiltų į paviršių.

Prisijungimo duomenų saugumas

„Niekada nelaikyk slaptažodžių savo源代码, užklausose ar žurnaluose.“

— Pagrindinė saugumo taisyklė

Praktiškai ši taisyklė išsiskaido į kelis įpročius, kurie beveik nieko nekainuoja, kai jų laikomasi. Prisijungimo duomenys gyvena aplinkos kintamuosiuose, kūrimo metu maitinami iš .env failo, kurį iškart neįtrauki į versijų valdymą naudodamas .gitignore – šis praleidimas yra klasikinė paslapčių nutekėjimo viešose saugyklose priežastis. Gamyboje pakeisk šį failą paslapčių valdytoju, pvz., „Vault“ ar „AWS Secrets Manager“, kuris pateikia reikšmes pagal poreikį ir fiksuoja prieigą. Jas skaito tik tavo kodas, niekada – modelis. Suplanuok reguliarų slaptažodžių ir API žetonų keitimą, kad senas nutekėjimas nieko neatidarytų. Galiausiai, filtruok savo žurnalus, kad juose niekada nebūtų registruojami jautrūs duomenys: agentas, kuris sąžiningai registruoja kiekvieną klavišo paspaudimą, taip pat nukopijuoja tai, ką buvo priverstas įvesti.

Svarbiausi punktai

  • Modelis niekada nemato paslapčių: tavo kodas įveda slaptažodį ir 2FA kodą naudodamas Playwright
  • Išsaugok sesijos būseną su storage_state ir elkis su tuo failu kaip su paslaptimi
  • TOTP automatizuojamas kodo pusėje, skirtas tik paslaugos paskyrai su ribotomis teisėmis
  • SSO prisijungimą atlik vieną kartą rankiniu būdu, tada pakartotinai naudok išsaugotą sesiją
  • Prieš paleisdamas darbo eigą visada patikrink prisijungimo būseną