Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Pārvaldīt autentifikāciju un sesijas

Nodarbība 8 no 14 Atjaunota 2026. gada 3. novembris Programmētājs
Šajā lapā
  1. Autentifikācijas izaicinājums
  2. Pieteikšanās, izmantojot veidlapu
  3. Sesijas stāvokļa atkārtota izmantošana
  4. Divu faktoru autentifikācijas (2FA) apstrāde
  5. SSO (vienotās pieteikšanās) apstrāde
  6. Pieteikšanās stāvokļa noteikšana
  7. Akreditācijas datu drošība
  8. Galvenās atziņas

Nodarbība pārrakstīta 2026. gada 3. novembrī, balstoties uz OpenAI Computer use rokasgrāmatu un Playwright autentifikācijas dokumentāciju. Iepriekšējā versijā paroles un 2FA kodi tika iekļauti tieši modelim nosūtītajā uzdevumā — tostarp izmantojot vides mainīgos, kas neatrisina to pārraides risku — un SSO pieteikšanās tika deleģēta aģentam. Tagad tavs kods pārvalda slepenos datus, sesijas stāvoklis tiek saglabāts, izmantojot storage_state, un SSO tiek veikts vienreiz manuāli. Avoti: Computer use · Playwright, authentication.

Autentifikācijas izaicinājums

Lielākajai daļai automatizācijas darbplūsmu ir nepieciešama pieteikšanās servisā. Kamēr tavs aģents darbojas publiskās lapās, viss norit gludi; tiklīdz tam jāatver CRM, aizmugures birojs vai e-pasta iesūtne, tas saskaras ar pieteikšanās sienu. Veidlapas, 2FA, SSO un noturīgas sesijas prasa atšķirīgu pieeju, taču visus tos vieno viens noteikums: modelis nekad neredz slepenos datus.

Pieteikšanās, izmantojot veidlapu

Kārdinājums ir diktēt aģentam darbību secību, iekļaujot tajā arī akreditācijas datus:

# NEDARIET TĀ: parole nonāk API pieprasījumā
task = """
Piesakies vietnē:
1. Noklikšķini uz e-pasta lauka un ieraksti: [email protected]
2. Noklikšķini uz paroles lauka un ieraksti: MyPassword123
3. Noklikšķini uz pogas "Log in"
"""

Paroles nolasīšana no vides mainīgā pirms tās ievietošanas uzdevumā neko nemaina: tā joprojām nonāk tavā infrastruktūrā pieprasījumā, tiek saglabāta kopā ar atbildi (atbildes pēc noklusējuma tiek glabātas, sk. 12. nodarbību) un var noplūst žurnālos. OpenAI iesaka turēt akreditācijas datus ārpus lapas teksta un ekrānuzņēmumiem. Risinājums ir tāds, ka tavs kods aizpilda pieteikšanās veidlapu, izmantojot Playwright, un nodev aģentam vadību tikai tad, kad sesija ir atvērta.

import os

def log_in(page, login_url: str):
    """Pieteikšanos veic tavs kods: modelis nekad neredz paroli."""
    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")

Pielāgo etiķetes Email un Password savai lietotnei. Šī ir viena no retajām vietām darbplūsmā, kur selektors ir pilnībā attaisnojams: pieteikšanās lapa reti mainās, un drošības apsvērumi ir svarīgāki par elastību.

Sesijas stāvokļa atkārtota izmantošana

Pieteikšanās katrā izpildes reizē tērē laiku un dažkārt var izraisīt drošības brīdinājumus servisa pusē. Playwright spēj saglabāt konteksta stāvokli — sīkfailus, lokālo krātuvi, IndexedDB — failā un pēc tam izveidot jaunu kontekstu no šī faila.

import os

def save_session(context, filepath="session.json"):
    """Saglabā pašreizējo sesijas stāvokli."""
    context.storage_state(path=filepath)

def new_context_with_session(browser, filepath="session.json"):
    """Izveido kontekstu no saglabātas sesijas, ja tāda eksistē."""
    options = {"viewport": {"width": 1280, "height": 720}}
    if os.path.exists(filepath):
        options["storage_state"] = filepath
    return browser.new_context(**options)

Integrējot to darbplūsmā, tiek izveidota divu soļu loģika: sāc no saglabātās sesijas, pārbaudi, vai tā joprojām ir derīga, un tikai tad, ja tas neizdodas, veic pieteikšanās procesu vēlreiz. Stāvoklis tiek saglabāts arī pēc uzdevuma izpildes, jo daudzi servisi ceļā atjauno savu sesijas tokeni.

from playwright.sync_api import sync_playwright

def authenticated_workflow(task: str, login_url: str):
    """Darbplūsma ar sesijas atkārtotu izmantošanu."""
    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 veiksmīgi atjaunota")
        else:
            log_in(page, login_url)  # tavs kods, nevis aģents
            if not is_logged_in(page):
                raise RuntimeError("Pieteikšanās neiespējama: pārbaudi akreditācijas datus vai 2FA")
        save_session(context)

        result = run_agent(task, page=page)
        save_session(context)  # atjauno stāvokli
        return result
    finally:
        browser.close()
        pw.stop()

Uztver sesijas failu kā paroli: Playwright brīdina, ka tas var saturēt sīkfailus un galvenes, kas ļauj uzdoties par kontu, un stingri iesaka to neiekļaut versiju kontrolei, pat privātā repozitorijā. Glabā to kopā ar saviem slepenajiem datiem.

Divu faktoru autentifikācijas (2FA) apstrāde

2FA rada izaicinājumu, jo tas bieži prasa cilvēka iejaukšanos, neatkarīgi no tā, vai tas ir SMS kods vai autentifikatora lietotne. Tieši tāds ir tā mērķis: tas ir izstrādāts tā, lai automāts to nevarētu apiet viens pats. Pastāv divas pieejas atkarībā no izmantotā faktora, un faktora izvēle, veidojot servisa kontu, nosaka, vai tava darbplūsma var darboties bez uzraudzības.

Automatizēts TOTP

Ja konts izmanto TOTP lietotni, piemēram, Google Authenticator vai Authy, parādītais kods ir tikai kopīgā noslēpuma un pulksteņa laika funkcija. Tavs kods tāpēc var to ģenerēt un ievadīt pats, nerādot to modelim.

import os

import pyotp

def enter_totp_code(page):
    """Ievada pašreizējo TOTP kodu: noslēpums un kods paliek tavā kodā."""
    totp = pyotp.TOTP(os.environ["TOTP_SECRET"])
    page.get_by_label("Verification code").fill(totp.now())
    page.get_by_role("button", name="Verify").click()

Padomā par to, ko dari: TOTP noslēpuma glabāšana kopā ar paroli samazina 2FA līdz vienam faktoram, jo abi noslēpumi atrodas vienā vietā. Rezervē šo pieeju specializētam servisa kontam ar tiesībām, kas ierobežotas līdz absolūtajam minimumam.

Manuāla gaidīšana

Faktori, kurus nevar automatizēt, piemēram, SMS vai push paziņojumi, prasa eksplicītu pauzi. Aģents apstājas, operators veic apstiprinājumu savā telefonā, un pēc tam cikls atsākas tur, kur tas apstājās. Šis ir pieņemams risinājums manuāli uzsāktam procesam, taču daudz mazāk piemērots nakts cron uzdevumam.

def wait_for_2fa(page):
    """Aptur aģentu un gaida manuālu apstiprinājumu."""
    print("Nepieciešams 2FA. Veic apstiprinājumu manuāli, pēc tam nospied Enter.")
    input("Nospied Enter, lai turpinātu...")
    # Aģents atsāk darbu pēc apstiprinājuma

SSO (vienotās pieteikšanās) apstrāde

SSO pieteikšanās (Google, Microsoft, SAML) novirza uz ārēju identitātes nodrošinātāju: aģents darbplūsmas vidū mainītu domēnu un tam būtu jāievada akreditācijas dati tur. Nedelegē šo soli aģentam. Veic SSO pieteikšanos vienreiz manuāli redzamā pārlūkā, ko kontrolē Playwright, un pēc tam saglabā sesijas stāvokli: turpmākās izpildes reizes sāksies no šī stāvokļa.

def manual_sso_login(login_url: str, filepath="session.json"):
    """Cilvēks piesakās redzamā pārlūkā; sesija tiek saglabāta."""
    pw = sync_playwright().start()
    browser = pw.chromium.launch(headless=False)
    context = browser.new_context()
    page = context.new_page()
    page.goto(login_url)
    input("Piesakies atvērtajā logā, pēc tam nospied Enter...")
    save_session(context, filepath)
    browser.close()
    pw.stop()

Kad sesija beidzot beigsies, darbplūsmai jāapstājas un jāpieprasa šī cilvēka pieteikšanās vēlreiz. Pievieno šo instrukciju aģenta vadlīnijām: ja tas nonāk pie identitātes nodrošinātāja lapas, tam jāapstājas un jāziņo par to, nevis jāmēģina kaut ko darīt.

Pieteikšanās stāvokļa noteikšana

Visa šī mehānika balstās uz jautājumu, uz kuru tev jāspēj droši atbildēt: vai esam pieteikušies? Specializēta funkcija pārbauda divus signālus: pirmkārt, pašreizējo URL, jo pāradresācija uz /login ir viennozīmīga, un, otrkārt, elementa esamību, kas paredzēts autentificētiem lietotājiem, parasti konta izvēlni. Pirmais tests ir acumirklīgs, otrais aptver lietotnes, kas rāda pieteikšanās lapu, nemainot URL.

from playwright.sync_api import TimeoutError as PlaywrightTimeoutError

def is_logged_in(page) -> bool:
    """Pārbauda, vai sesija ir aktīva."""
    # URL pārbaude
    if "/login" in page.url or "/signin" in page.url:
        return False

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

except bloks mērķtiecīgi aptver tikai noilguma beigas: kails except: norītu arī klaviatūras pārtraukumu vai reālu programmēšanas kļūdu, kuras tev ir jāredz izvirzāmies augšup.

Akreditācijas datu drošība

"Nekad neglabā paroles savā pirmkodā, uzdevumos vai žurnālos."

— Fundamentāls drošības noteikums

Praksē šis noteikums sadalās dažos ieradumos, kas gandrīz neko nemaksā, tiklīdz tie ir ieviesti. Akreditācijas dati dzīvo vides mainīgajos, izstrādes laikā tos nodrošina .env fails, ko tūlīt izslēdz no versiju kontroles, izmantojot .gitignore — šī kļūda ir klasisks iemesls noslēpumu noplūdēm publiskos repozitorijos. Ražošanas vidē aizstāj šo failu ar noslēpumu pārvaldnieku, piemēram, Vault vai AWS Secrets Manager, kas piegādā vērtības pēc pieprasījuma un reģistrē piekļuvi. Tikai tavs kods tos lasa, nekad modelis. Plāno regulāru paroļu un API tokenu rotāciju, lai veca noplūde vairs neatvērtu neko. Visbeidzot, filtrē savus žurnālus, lai tajos nekad netiktu ierakstīti sensitīvi dati: aģents, kas uzticami žurnālē katru taustiņsitieni, arī nokopē to, ko tam lika ierakstīt.

Galvenās atziņas

  • Modelis nekad neredz slepenos datus: tavs kods ievada paroli un 2FA kodu, izmantojot Playwright
  • Saglabā sesijas stāvokli ar storage_state un uztver šo failu kā slepenu
  • TOTP tiek automatizēts koda pusē un rezervēts servisa kontam ar ierobežotām tiesībām
  • Veic SSO pieteikšanos vienreiz manuāli, pēc tam atkārtoti izmanto saglabāto sesiju
  • Vienmēr pārbaudi pieteikšanās stāvokli pirms darbplūsmas uzsākšanas