Authentifizierung und Sitzungen verwalten
Auf dieser Seite
Lektion am 3. November 2026 neu geschrieben basierend auf dem Computer use-Guide von OpenAI und der Authentifizierungs-Dokumentation von Playwright. Die vorherige Version platzierte Passwörter und 2FA-Codes direkt im an das Modell gesendeten Prompt – auch über Umgebungsvariablen, was deren Übertragung nicht verhindert – und überließ den SSO-Login dem Agenten. Nun übernimmt Ihr Code die Verwaltung von Geheimnissen, der Sitzungszustand wird mit
storage_stategespeichert, und der SSO-Login wird einmal manuell durchgeführt. Quellen: Computer use · Playwright, authentication.
Die Herausforderung der Authentifizierung
Die meisten Automatisierungsabläufe erfordern eine Anmeldung bei einem Dienst. Solange Ihr Agent auf öffentlichen Seiten bleibt, funktioniert alles einwandfrei; sobald er jedoch versucht, ein CRM, ein Back-Office oder einen E-Mail-Posteingang zu öffnen, stößt er auf eine Login-Sperre. Formulare, 2FA, SSO und persistente Sitzungen erfordern jeweils unterschiedliche Handhabungen, aber eine Regel gilt für alle: das Modell sieht niemals ein Geheimnis.
Formularbasierte Anmeldung
Die Versuchung besteht darin, die Reihenfolge dem Agenten vorzugeben, inklusive der Anmeldedaten:
# TUN SIE DIES NICHT: Das Passwort geht in den an die API gesendeten Request
task = """
Melden Sie sich auf der Website an:
1. Klicken Sie auf das E-Mail-Feld und tippen Sie: [email protected]
2. Klicken Sie auf das Passwort-Feld und tippen Sie: MyPassword123
3. Klicken Sie auf die Schaltfläche "Anmelden"
"""
Das Auslesen des Passworts aus einer Umgebungsvariable, bevor es in den Prompt eingefügt wird, ändert nichts daran: Es bleibt die Infrastruktur im Request, es wird mit der Antwort gespeichert – Antworten werden standardmäßig gespeichert (Lektion 12) – und es kann in Ihre Protokolle gelangen. OpenAI empfiehlt, Anmeldedaten aus Seitentexten und Screenshots herauszuhalten. Die Lösung besteht darin, dass Ihr Code das Login-Formular mit Playwright ausfüllt und erst dann den Agenten übergibt, sobald die Sitzung geöffnet ist.
import os
def log_in(page, login_url: str):
"""Anmeldung wird von Ihrem Code durchgeführt: Das Modell sieht das Passwort nie."""
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")
Passen Sie die Labels Email und Password an Ihre Anwendung an. Dies ist einer der wenigen Stellen im Workflow, an denen ein Selektor vollständig gerechtfertigt ist: Eine Login-Seite ändert sich selten, und die Sicherheitsrisiken wiegen schwerer als die Flexibilität.
Wiederverwendung des Sitzungszustands
Das Anmelden bei jeder Ausführung verschwendet Zeit und kann auf Seiten des Dienstes manchmal Sicherheitswarnungen auslösen. Playwright kann den Zustand eines Kontexts – Cookies, Local Storage, IndexedDB – in eine Datei speichern und daraus einen neuen Kontext erstellen.
import os
def save_session(context, filepath="session.json"):
"""Speichert den aktuellen Sitzungszustand."""
context.storage_state(path=filepath)
def new_context_with_session(browser, filepath="session.json"):
"""Erstellt einen Kontext aus einem gespeicherten Sitzungszustand, falls vorhanden."""
options = {"viewport": {"width": 1280, "height": 720}}
if os.path.exists(filepath):
options["storage_state"] = filepath
return browser.new_context(**options)
Integriert in den Workflow, dies erzeugt eine zweistufige Logik: Starten Sie vom gespeicherten Sitzungszustand, überprüfen Sie, ob dieser noch gültig ist, und gehen Sie nur dann erneut durch den Login, wenn dies fehlschlägt. Der Zustand wird nach der Aufgabe erneut gespeichert, da viele Dienste ihren Sitzungstoken im Laufe der Zeit erneuern.
from playwright.sync_api import sync_playwright
def authenticated_workflow(task: str, login_url: str):
"""Workflow mit Wiederverwendung der Sitzung."""
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("Sitzung erfolgreich wiederhergestellt")
else:
log_in(page, login_url) # Ihr Code, nicht der Agent
if not is_logged_in(page):
raise RuntimeError("Anmeldung unmöglich: überprüfen Sie die Anmeldedaten oder die 2FA")
save_session(context)
result = run_agent(task, page=page)
save_session(context) # Zustand aktualisieren
return result
finally:
browser.close()
pw.stop()
Behandeln Sie die Sitzungsdatei wie ein Passwort: Playwright warnt, dass sie Cookies und Header enthalten kann, die eine Konten-Identifizierung ermöglichen, und rät dringend davon ab, sie auch in einem privaten Repository zu versionieren. Speichern Sie sie zusammen mit Ihren Geheimnissen.
Handhabung von Zwei-Faktor-Authentifizierung (2FA)
2FA stellt eine Herausforderung dar, da sie oft menschliches Eingreifen erfordert, sei es ein SMS-Code oder eine Authenticator-App. Genau dies ist ihr Zweck: Sie ist so konzipiert, dass ein Automat sie nicht allein umgehen kann. Zwei Ansätze koexistieren, abhängig vom verwendeten Faktor, und die Wahl des Faktors bei der Erstellung des Dienstkontos bestimmt, ob Ihr Workflow unbewacht laufen kann.
Automatisierte TOTP
Wenn das Konto eine TOTP-App wie Google Authenticator oder Authy verwendet, ist der angezeigte Code lediglich eine Funktion des gemeinsamen Geheimnisses und der Uhrzeit. Ihr Code kann ihn daher selbst generieren und eingeben, ohne ihn dem Modell anzuzeigen.
import os
import pyotp
def enter_totp_code(page):
"""Gibt den aktuellen TOTP-Code ein: Das Geheimnis und der Code bleiben in Ihrem Code."""
totp = pyotp.TOTP(os.environ["TOTP_SECRET"])
page.get_by_label("Verification code").fill(totp.now())
page.get_by_role("button", name="Verify").click()
Überlegen Sie, was Sie tun: Das Speichern des TOTP-Geheimnisses zusammen mit dem Passwort reduziert 2FA auf einen einzigen Faktor, da beide Geheimnisse an derselben Stelle leben. Reservieren Sie diesen Ansatz für ein dediziertes Dienstkonto mit auf das strikte Minimum beschränkten Rechten.
Manueller Wartezeit
Nicht automatisierbare Faktoren, wie SMS oder Push-Benachrichtigungen, erfordern eine explizite Pause. Der Agent stoppt, ein Operator validiert auf seinem Telefon, und der Zyklus setzt dort fort, wo er aufgehört hat. Dies ist eine akzeptable Lösung für einen manuell gestarteten Prozess, viel weniger für einen nächtlichen Cron-Job.
def wait_for_2fa(page):
"""Pausiert den Agenten und wartet auf manuelle Validierung."""
print("2FA erforderlich. Validieren Sie manuell und drücken Sie dann Enter.")
input("Drücken Sie Enter, um fortzufahren...")
# Der Agent setzt sich nach der Validierung fort
Handhabung von SSO (Single Sign-On)
SSO-Anmeldungen (Google, Microsoft, SAML) leiten zu einem externen Identitätsanbieter weiter: Der Agent würde mitten im Flow Domänen wechseln und müsste dort Anmeldedaten eingeben. Überlassen Sie diesen Schritt nicht dem Agenten. Führen Sie den SSO-Login einmal manuell in einem sichtbaren Browser durch, der von Playwright gesteuert wird, und speichern Sie den Sitzungszustand: Nachfolgende Ausführungen starten von diesem Zustand.
def manual_sso_login(login_url: str, filepath="session.json"):
"""Ein Mensch meldet sich in einem sichtbaren Browser an; die Sitzung wird gespeichert."""
pw = sync_playwright().start()
browser = pw.chromium.launch(headless=False)
context = browser.new_context()
page = context.new_page()
page.goto(login_url)
input("Melden Sie sich im geöffneten Fenster an und drücken Sie dann Enter...")
save_session(context, filepath)
browser.close()
pw.stop()
Wenn die Sitzung schließlich abläuft, muss der Workflow stoppen und diese menschliche Anmeldung erneut anfordern. Fügen Sie diese Anweisung den Richtlinien des Agenten hinzu: Wenn er sich vor einer Seite eines Identitätsanbieters befindet, stoppt er und meldet dies, anstatt etwas zu versuchen.
Erkennung des Login-Zustands
All diese Mechaniken beruhen auf einer Frage, die Sie zuverlässig beantworten können müssen: Sind wir angemeldet? Eine dedizierte Funktion prüft zwei Signale, zuerst die aktuelle URL, da eine Umleitung zu /login unmissverständlich ist, dann das Vorhandensein eines Elements, das für angemeldete Benutzer reserviert ist, typischerweise das Kontomenu. Der erste Test ist sofort, der zweite deckt Anwendungen ab, die die Login-Seite anzeigen, ohne die URL zu ändern.
from playwright.sync_api import TimeoutError as PlaywrightTimeoutError
def is_logged_in(page) -> bool:
"""Überprüft, ob die Sitzung aktiv ist."""
# URL-Prüfung
if "/login" in page.url or "/signin" in page.url:
return False
# DOM-Element-Prüfung
try:
page.wait_for_selector("[data-testid=user-menu]", timeout=3000)
return True
except PlaywrightTimeoutError:
return False
Der except-Block zielt genau auf das Ablaufdatum des Timeouts ab: Ein nackter except: würde auch einen Tastaturunterbruch oder einen echten Programmfehler schlucken, die Sie sehen möchten, dass nach oben durchblubbern.
Sicherheit von Anmeldedaten
"Speichern Sie Passwörter niemals in Ihrem Quellcode, Ihren Prompts oder Ihren Protokollen."
In der Praxis zerfällt diese Regel in einige Gewohnheiten, die fast nichts kosten, sobald sie angenommen werden. Anmeldedaten leben in Umgebungsvariablen, die in der Entwicklung durch eine .env-Datei zugeführt werden, die Sie sofort aus der Versionskontrolle über .gitignore ausschließen – dieser Ausschluss ist eine klassische Ursache für Geheimnis-Lecks in öffentlichen Repositories. In der Produktion ersetzen Sie diese Datei durch einen Secrets Manager, wie Vault oder AWS Secrets Manager, der Werte auf Anfrage liefert und Zugriffe protokolliert. Nur Ihr Code liest sie, niemals das Modell. Planen Sie regelmäßige Rotationen von Passwörtern und API-Tokens, damit ein altes Leck nichts mehr öffnet. Filtern Sie schließlich Ihre Protokolle, um sensible Daten dort niemals aufzuzeichnen: Ein Agent, der jede Tastenanschlag treu protokolliert, kopiert auch das, wozu er angehalten wurde, zu tippen.
Kernaussagen
- Das Modell sieht niemals ein Geheimnis: Ihr Code gibt Passwort und 2FA-Code mit Playwright ein
- Speichern Sie den Sitzungszustand mit
storage_stateund behandeln Sie diese Datei wie ein Geheimnis - TOTP wird auf der Code-Seite automatisiert, reserviert für ein Dienstkonto mit begrenzten Rechten
- Führen Sie den SSO-Login einmal manuell durch und nutzen Sie dann den gespeicherten Sitzungszustand
- Prüfen Sie immer den Login-Zustand, bevor Sie einen Workflow starten