Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Hantera autentisering och sessioner

Lektion 8 av 14 Uppdaterad 3 november 2026 Utvecklare
På denna sida
  1. Utmaningen med autentisering
  2. Inloggning via formulär
  3. Återanvända sessionstillstånd
  4. Hantera tvåfaktorsautentisering (2FA)
  5. Hantera SSO (Single Sign-On)
  6. Upptäcka inloggningsstatus
  7. Säkerhet för inloggningsuppgifter
  8. Viktiga punkter

Lektionen omskriven den 3 november 2026 baserat på OpenAIs guide Computer use och Playwrights dokumentation om autentisering. Den tidigare versionen placerade lösenord och 2FA-koder direkt i prompten som skickades till modellen – även via miljövariabler, vilket inte hindrar att de överförs – och delegerade SSO-inloggning till agenten. Nu hanterar din kod hemligheter, sessionstillstånd sparas med storage_state, och SSO utförs en gång manuellt. Källor: Computer use · Playwright, authentication.

Utmaningen med autentisering

De flesta automatiseringsflöden kräver att du är inloggad på en tjänst. Så länge din agent stannar på offentliga sidor fungerar allt bra; så fort den behöver öppna ett CRM, ett backoffice eller en inkorg, stöter den på en inloggningsvägg. Formulär, 2FA, SSO och beständiga sessioner kräver var sin hantering, men en regel styr dem alla: modellen får aldrig se en hemlighet.

Inloggning via formulär

Frestanden är att diktera sekvensen för agenten, inklusive uppgifter:

# GÖR INTE DETTA: lösenordet hamnar i begäran som skickas till API:et
task = """
Logga in på webbplatsen:
1. Klicka på e-postfältet och skriv: [email protected]
2. Klicka på lösenordsfältet och skriv: MyPassword123
3. Klicka på knappen "Log in"
"""

Att läsa lösenordet från en miljövariabel innan det infogas i prompten ändrar ingenting: det lämnar fortfarande din infrastruktur i begäran, det sparas tillsammans med svaret – svar sparas som standard (lektion 12) – och det kan läcka ut i dina loggar. OpenAI rekommenderar att hålla inloggningsuppgifter borta från sidtext och skärmdumpar. Lösningen är att låta din kod fylla i inloggningsformuläret med Playwright, och sedan överlåta kontrollen till agenten när sessionen är öppen.

import os

def log_in(page, login_url: str):
    """Inloggning utförs av din kod: modellen ser aldrig lösenordet."""
    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")

Anpassa etiketterna Email och Password till din applikation. Detta är ett av de få ställen i flödet där en selektor är fullt motiverad: en inloggningssida ändras sällan, och säkerhetsriskerna väger tyngre än flexibiliteten.

Återanvända sessionstillstånd

Att logga in vid varje körning slöser tid och kan ibland utlösa säkerhetslarm på tjänstens sida. Playwright kan spara en contexts tillstånd – cookies, lokal lagring, IndexedDB – till en fil, och sedan skapa ett nytt context från den filen.

import os

def save_session(context, filepath="session.json"):
    """Sparar det aktuella sessionstillståndet."""
    context.storage_state(path=filepath)

def new_context_with_session(browser, filepath="session.json"):
    """Skapar ett context från ett sparat sessionstillstånd, om ett finns."""
    options = {"viewport": {"width": 1280, "height": 720}}
    if os.path.exists(filepath):
        options["storage_state"] = filepath
    return browser.new_context(**options)

Integrerat i flödet skapar detta en tvåstegslogik: starta från det sparade tillståndet, verifiera att det fortfarande är giltigt, och genomför bara inloggningen igen om det misslyckas. Tillståndet sparas igen efter uppgiften, eftersom många tjänster förnyar sin sessionstoken längs vägen.

from playwright.sync_api import sync_playwright

def authenticated_workflow(task: str, login_url: str):
    """Flöde med återanvändning av session."""
    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("Sessionen återställdes framgångsrikt")
        else:
            log_in(page, login_url)  # din kod, inte agenten
            if not is_logged_in(page):
                raise RuntimeError("Inloggning omöjlig: kontrollera uppgifter eller 2FA")
        save_session(context)

        result = run_agent(task, page=page)
        save_session(context)  # uppdatera tillstånd
        return result
    finally:
        browser.close()
        pw.stop()

Behandla sessionsfilen som ett lösenord: Playwright varnar för att den kan innehålla cookies och headers som möjliggör kontoimitation, och avråder starkt från att versionshantera den, även i ett privat repository. Lagra den tillsammans med dina hemligheter.

Hantera tvåfaktorsautentisering (2FA)

2FA utgör en utmaning eftersom det ofta kräver mänsklig inblandning, oavsett om det gäller en SMS-kod eller en autentiseringsapp. Det är precis syftet: det är designat så att en automat inte kan kringgå det ensam. Två metoder samexisterar beroende på vilken faktor som används, och valet av faktor när du skapar tjänstekontot avgör om ditt flöde kan köras oövervakat.

Automatiserad TOTP

Om kontot använder en TOTP-app som Google Authenticator eller Authy, är den visade koden bara en funktion av den delade hemligheten och klockan. Din kod kan därför generera och mata in den själv, utan att visa den för modellen.

import os

import pyotp

def enter_totp_code(page):
    """Matar in den aktuella TOTP-koden: hemligheten och koden stannar i din 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()

Tänk på vad du gör: att lagra TOTP-hemligheten tillsammans med lösenordet reducerar 2FA till en enda faktor, eftersom båda hemligheterna finns på samma ställe. Reservera denna metod för ett dedikerat tjänstekonto, med rättigheter begränsade till det strikt nödvändiga.

Manuell väntan

Icke-automatiserbara faktorer, som SMS eller push-notiser, kräver en explicit paus. Agenten stannar, en operatör validerar på sin telefon, och sedan återupptas loopen där den lämnades. Detta är en acceptabel lösning för en manuellt startad process, mycket mindre så för ett nattligt cron-jobb.

def wait_for_2fa(page):
    """Pausar agenten och väntar på manuell validering."""
    print("2FA krävs. Validera manuellt och tryck sedan på Enter.")
    input("Tryck på Enter för att fortsätta...")
    # Agenten återupptas efter validering

Hantera SSO (Single Sign-On)

SSO-inloggningar (Google, Microsoft, SAML) omdirigerar till en extern identitetsleverantör: agenten skulle byta domän mitt i flödet och behöva mata in uppgifter där. Delegera inte detta steg till agenten. Utför SSO-inloggningen en gång, manuellt, i en synlig webbläsare som styrs av Playwright, och spara sedan sessionstillståndet: efterföljande körningar startar från detta tillstånd.

def manual_sso_login(login_url: str, filepath="session.json"):
    """En människa loggar in i en synlig webbläsare; sessionen sparas."""
    pw = sync_playwright().start()
    browser = pw.chromium.launch(headless=False)
    context = browser.new_context()
    page = context.new_page()
    page.goto(login_url)
    input("Logga in i det öppnade fönstret och tryck sedan på Enter...")
    save_session(context, filepath)
    browser.close()
    pw.stop()

När sessionen så småningom löper ut måste flödet stoppas och begära denna mänskliga inloggning igen. Lägg till denna instruktion i agentens riktlinjer: om den hamnar framför en sida från en identitetsleverantör ska den stoppa och rapportera det istället för att försöka något.

Upptäcka inloggningsstatus

All denna mekanik vilar på en fråga du måste kunna besvara tillförlitligt: är vi inloggade? En dedikerad funktion korskontrollerar två signaler: först den aktuella URL:en, eftersom en omdirigering till /login är entydig, sedan förekomsten av ett element reserverat för autentiserade användare, vanligtvis kontomenyn. Det första testet är ögonblickligt, det andra täcker applikationer som visar inloggningssidan utan att ändra URL:en.

from playwright.sync_api import TimeoutError as PlaywrightTimeoutError

def is_logged_in(page) -> bool:
    """Kontrollerar om sessionen är aktiv."""
    # URL-kontroll
    if "/login" in page.url or "/signin" in page.url:
        return False

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

except-blocket riktar sig exakt mot tidsutgång: ett naket except: skulle också svälja en tangentbordsavbrott eller ett riktigt programmeringsfel, vilket du vill ska bubbla upp.

Säkerhet för inloggningsuppgifter

"Lagra aldrig lösenord i din källkod, dina prompter eller dina loggar."

— Grundläggande säkerhetsregel

I praktiken bryts denna regel ner i några vanor som kostar nästan inget när de väl är antagna. Inloggningsuppgifter lever i miljövariabler, matade under utveckling av en .env-fil som du omedelbart exkluderar från versionshantering via .gitignore – denna utelämnande är en klassisk orsak till läckage av hemligheter i offentliga repository. I produktion ersätter du denna fil med en hemlighetshanterare, som Vault eller AWS Secrets Manager, som levererar värden på begäran och spårar åtkomst. Endast din kod läser dem, aldrig modellen. Planera för regelbunden rotation av lösenord och API-token, så att en gammal läcka inte längre öppnar något. Filtrera slutligen dina loggar för att aldrig spela in känsliga data där: en agent som troget loggar varje tangenttryckning kopierar också det den fick skriva.

Viktiga punkter

  • Modellen ser aldrig en hemlighet: din kod matar in lösenord och 2FA-kod med Playwright
  • Spara sessionstillstånd med storage_state och behandla den filen som en hemlighet
  • TOTP automatiseras på kodsidan, reserverat för ett tjänstekonto med begränsade rättigheter
  • Utför SSO-inloggning en gång manuellt, och återanvänd sedan den sparade sessionen
  • Kontrollera alltid inloggningsstatus innan du startar ett flöde