Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Hallitse tunnistautumista ja istuntoja

Oppitunti 8 / 14 Päivitetty 3. marraskuuta 2026 Kehittäjä
Tällä sivulla
  1. Tunnistautumisen haaste
  2. Lomakepohjainen kirjautuminen
  3. Istunnon tilan uudelleenkäyttö
  4. Kaksivaiheisen tunnistautumisen (2FA) käsittely
  5. SSO:n (Single Sign-On) käsittely
  6. Kirjautumistilan havaitseminen
  7. Tunnistetietojen turvallisuus
  8. Keskeiset asiat

Oppitunti kirjoitettu uudelleen 3. marraskuuta 2026 perustuen OpenAI:n Computer use -oppaaseen ja Playwrightin tunnistautumisdokumentaatioon. Edellinen versio sisällytti salasanat ja 2FA-koodit suoraan mallille lähetettyyn kehotteeseen – myös ympäristömuuttujien kautta, mikä ei estä niiden siirtymistä – ja delegoi SSO-kirjautumisen agentille. Nyt koodisi hallitsee salaiset tiedot, istunton tila tallennetaan käyttäen storage_state:a ja SSO suoritetaan kerran manuaalisesti. Lähteet: Computer use · Playwright, authentication.

Tunnistautumisen haaste

Useimmat automaatiotyönkulut vaativat kirjautumista palveluun. Niin kauan kuin agenttisi pysyy julkisilla sivuilla, kaikki toimii hyvin; hetkellä, jolloin sen täytyy avata CRM, back office tai sähköpostilaatikko, se törmää kirjautumismuuriin. Lomakkeet, 2FA, SSO ja pysyvät istunnot vaativat kukin erilaista käsittelyä, mutta yksi sääntö hallitsee niitä kaikkia: malli ei koskaan näe salaista tietoa.

Lomakepohjainen kirjautuminen

Kiusaus on diktaata sekvenssi agentille, tunnistetiedot mukaan lukien:

# ÄLÄ TEE NÄIN: salasana päätyy API:lle lähetettävään pyyntöön
task = """
Kirjaudu sivustolle:
1. Klikkaa sähköpostikenttää ja kirjoita: [email protected]
2. Klikkaa salasanakenttää ja kirjoita: MyPassword123
3. Klikkaa "Kirjaudu"-painiketta
"""

Salasanan lukeminen ympäristömuuttujasta ennen sen lisäämistä kehotteeseen ei muuta mitään: se jättää infrastruktuurisi edelleen pyyntöön, se säilytetään vastauksen yhteydessä – vastaukset tallennetaan oletuksena (Oppitunti 12) – ja se voi vuotaa lokeihisi. OpenAI suosittelee tunnistetietojen pitämistä poissa sivun tekstistä ja kuvakaappauksista. Ratkaisu on saada koodisi täyttämään kirjautumislomake Playwrightilla ja luovuttamaan ohjat agentille vasta istunnon avaamisen jälkeen.

import os

def log_in(page, login_url: str):
    """Koodisi suorittaa kirjautumisen: malli ei koskaan näe salasanaa."""
    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")

Sovita Email- ja Password-labelit omaan sovellukseesi. Tämä on yksi harvoista paikoista työnkulussa, jossa valitsin on täysin perusteltu: kirjautumissivu muuttuu harvoin, ja turvallisuusriskit painavat enemmän kuin joustavuus.

Istunnon tilan uudelleenkäyttö

Joka suorituksella kirjautuminen tuhlaa aikaa ja voi joskus laukaista turvallisuushälytyksiä palvelun puolella. Playwright voi tallentaa kontekstin tilan – evästeet, paikallisen tallennustilan, IndexedDB:n – tiedostoon ja luoda sitten uuden kontekstin kyseisestä tiedostosta.

import os

def save_session(context, filepath="session.json"):
    """Tallentaa nykyisen istunnon tilan."""
    context.storage_state(path=filepath)

def new_context_with_session(browser, filepath="session.json"):
    """Luo kontekstin tallennetusta istunnosta, jos sellainen on olemassa."""
    options = {"viewport": {"width": 1280, "height": 720}}
    if os.path.exists(filepath):
        options["storage_state"] = filepath
    return browser.new_context(**options)

Työnkulkuun integroituna tämä luo kaksivaiheisen logiikan: aloita tallennetusta istunnosta, varmista sen olevan edelleen voimassa ja siirry kirjautumiseen uudelleen vain, jos se epäonnistuu. Tila tallennetaan uudelleen tehtävän jälkeen, koska monet palvelut uusivat istuntotunnuksensa prosessin aikana.

from playwright.sync_api import sync_playwright

def authenticated_workflow(task: str, login_url: str):
    """Työnkulku istunnon uudelleenkäytöllä."""
    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("Istunto palautettu onnistuneesti")
        else:
            log_in(page, login_url)  # sinun koodisi, ei agentin
            if not is_logged_in(page):
                raise RuntimeError("Kirjautuminen mahdotonta: tarkista tunnistetiedot tai 2FA")
        save_session(context)

        result = run_agent(task, page=page)
        save_session(context)  # päivitä tila
        return result
    finally:
        browser.close()
        pw.stop()

Kohtele istuntotiedostoa kuin salasanaa: Playwright varoittaa, että se voi sisältää evästeitä ja otsikoita, jotka mahdollistavat tilin impersonoinnin, ja neuvoo vahvasti olemaan versioimatta sitä, edes yksityisessä repositoriossa. Säilytä se salaisuuksiesi joukossa.

Kaksivaiheisen tunnistautumisen (2FA) käsittely

2FA muodostaa haasteen, koska se vaatii usein ihmisen väliintuloa, olipa kyseessä SMS-koodi tai tunnistussovellus. Se on juuri sen tarkoitus: se on suunniteltu niin, ettei automaatti voi ohittaa sitä yksin. Kaksi lähestymistapaa rinnakkain riippuen käytetystä tekijästä, ja tekijän valinta palvelutiliä luotaessa määrittää, voiko työnkulkuusi suorittaa ilman valvontaa.

Automatisoitu TOTP

Jos tili käyttää TOTP-sovellusta kuten Google Authenticator tai Authy, näytetty koodi on vain jaetun salaisuuden ja kellonajan funktio. Koodisi voi siis generoida ja syöttää sen itse näyttämättä sitä mallille.

import os

import pyotp

def enter_totp_code(page):
    """Syöttää nykyisen TOTP-koodin: salaisuus ja koodi pysyvät koodissasi."""
    totp = pyotp.TOTP(os.environ["TOTP_SECRET"])
    page.get_by_label("Verification code").fill(totp.now())
    page.get_by_role("button", name="Verify").click()

Harkitse mitä teet: TOTP-salaisuuden tallentaminen salasanan viereen pelkistää 2FA:n yhdeksi tekijäksi, sillä molemmat salaisuudet asuvat samassa paikassa. Varaa tämä lähestymistapa omistetulle palvelutilille, jonka oikeudet on rajoitettu ehdottomaan minimiin.

Manuaalinen odotus

Ei-automatisoitavat tekijät, kuten SMS tai push-ilmoitukset, vaativat eksplisiittisen tauon. Agentti pysähtyy, operaattori vahvistaa puhelimellaan, ja silmukka jatkuu siitä mihin jäi. Tämä on hyväksyttävä ratkaisu manuaalisesti käynnistetylle prosessille, paljon vähemmän yön yli ajettavalle cron-työlle.

def wait_for_2fa(page):
    """Pysäyttää agentin ja odottaa manuaalista vahvistusta."""
    print("2FA vaaditaan. Vahvista manuaalisesti ja paina Enter.")
    input("Jatka painamalla Enter...")
    # Agentti jatkaa vahvistuksen jälkeen

SSO:n (Single Sign-On) käsittely

SSO-kirjautumiset (Google, Microsoft, SAML) ohjaavat ulkoiseen identiteettitarjoajaan: agentti vaihtaisi verkkotunnusta kesken virran ja joutuisi syöttämään tunnistetiedot sinne. Älä delegoi tätä vaihetta agentille. Suorita SSO-kirjautuminen kerran manuaalisesti näkyvässä selaimessa, jota Playwright ohjaa, ja tallenna sitten istunnon tila: myöhemmät suoritukset alkavat tästä tilasta.

def manual_sso_login(login_url: str, filepath="session.json"):
    """Ihminen kirjautuu näkyvässä selaimessa; istunto tallennetaan."""
    pw = sync_playwright().start()
    browser = pw.chromium.launch(headless=False)
    context = browser.new_context()
    page = context.new_page()
    page.goto(login_url)
    input("Kirjaudu avatussa ikkunassa ja paina Enter...")
    save_session(context, filepath)
    browser.close()
    pw.stop()

Kun istunto lopulta vanhenee, työnkulun on pysähdyttävä ja pyydettävä tätä ihmisen kirjautumista uudelleen. Lisää tämä ohje agentin ohjeistukseen: jos se löytää itsensä identiteettitarjoajan sivulta, se pysähtyy ja raportoi sen sen sijaan, että yrittäisi mitään.

Kirjautumistilan havaitseminen

Kaikki tämä mekanismi lepää kysymyksen varassa, johon sinun on pystyttävä vastaamaan luotettavasti: olemmeko kirjautuneina? Erillinen funktio ylittää kaksi signaalia: ensin nykyisen URL-osoitteen, sillä uudelleenohjaus osoitteeseen /login on yksiselitteinen, ja sitten sellaisen elementin olemassaolon, joka on varattu tunnistautuneille käyttäjille, tyypillisesti tilivalikon. Ensimmäinen testi on välitön, toinen kattaa sovellukset, jotka näyttävät kirjautumissivun muuttamatta URL-osoitetta.

from playwright.sync_api import TimeoutError as PlaywrightTimeoutError

def is_logged_in(page) -> bool:
    """Tarkistaa onko istunto aktiivinen."""
    # URL-tarkistus
    if "/login" in page.url or "/signin" in page.url:
        return False

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

except kohdistuu tarkasti aikakatkaisun umpeutumiseen: paljas except: nielaisi myös näppäimistökeskeytyksen tai todellisen ohjelmointivirheen, jotka haluat nähdä nousevan pintaan.

Tunnistetietojen turvallisuus

"Älä koskaan tallenna salasanoja lähdekoodiisi, kehotteisiisi tai lokeihisi."

— Perustavanlaatuinen turvallisuussääntö

Käytännössä tämä sääntö hajoaa muutamaksi tavaksi, jotka eivät maksa melkein mitään omaksumisen jälkeen. Tunnistetiedot elävät ympäristömuuttujissa, syötettynä kehitysvaiheessa .env-tiedostosta, jonka suljet välittömästi versionhallinnasta .gitignore-tiedoston kautta – tämä laiminlyönti on klassinen syy salaisuuksien vuotamiseen julkisissa repositorioissa. Tuotannossa korvaa tämä tiedosto salaisuuksien hallintajärjestelmällä, kuten Vault tai AWS Secrets Manager, joka toimittaa arvot pyydettäessä ja jäljittää pääsyn. Vain koodisi lukee niitä, ei koskaan malli. Suunnittele salasanojen ja API-tunnusten säännöllinen kierrätys, jotta vanha vuoto ei enää avaa mitään. Lopulta suodata lokisi niin, etteivät ne koskaan tallenna arkaluonteisia tietoja sinne: agentti, joka lokittaa uskollisesti jokaisen näppäinpainalluksen, kopioi myös sen mitä sen käskettiin kirjoittaa.

Keskeiset asiat

  • Malli ei koskaan näe salaista tietoa: koodisi syöttää salasanan ja 2FA-koodin Playwrightilla
  • Tallenna istunnon tila käyttäen storage_state:a ja kohtele tätä tiedostoa salaisuutena
  • TOTP automatisoidaan koodin puolella, varattuna palvelutilille, jolla on rajoitetut oikeudet
  • Suorita SSO-kirjautuminen kerran manuaalisesti ja käytä sitten tallennettua istuntoa uudelleen
  • Tarkista aina kirjautumistila ennen työnkulun käynnistämistä