Eine Low-Code-Plattform, die die Einfachheit von No-Code mit der Leistung von Full-Code verbindet 🚀
Jetzt kostenlos starten
Cookie-Verwaltung in Puppeteer: Sitzungserhaltung, Authentifizierungsemulation und Einschränkungen
22. März 2025
9
min lesen

Cookie-Verwaltung in Puppeteer: Sitzungserhaltung, Authentifizierungsemulation und Einschränkungen

Georgi Miloradowitsch
Forscher, Texter und Usecase-Interviewer
Inhaltsverzeichnis

Möchten Sie die Sitzungsverwaltung und Authentifizierungstests optimieren mit Puppenspieler? Folgendes müssen Sie über den effektiven Umgang mit Cookies wissen:

  • Warum Cookies wichtig sind: Sie speichern Sitzungsdaten, Einstellungen und Anmeldedaten.
  • Was du tun kannst: Speichern Sie Sitzungen, testen Sie die Authentifizierung, verwalten Sie Zustände und ahmen Sie sogar das echte Benutzerverhalten nach.
  • Wie man verwaltet: Mit Puppeteer können Sie Cookies programmgesteuert setzen, abrufen und löschen.
  • Herausforderungen, auf die Sie achten sollten: Sicherheitsrisiken, Browsereinschränkungen und Cookie-Lebenszyklusverwaltung.

Hauptmerkmale

  • Sitzungspersistenz: Speichern und laden Sie Cookies neu, um den Anmeldestatus beizubehalten.
  • Authentifizierungsautomatisierung: Verwenden Sie Cookies, um wiederholte Anmeldeschritte zu umgehen.
  • Praktische Anwendungsfälle: Automatisieren Sie Einkaufswagen, testen Sie Benutzerrollen und mehr.

Quick-Tipp: Speichern Sie Cookies im JSON-Format, verwenden Sie separate Browserkontexte und überwachen Sie Ablaufdaten, um Probleme zu vermeiden.

Erfahren Sie, wie Sie in Puppeteer Cookies setzen, abrufen und sichern und gleichzeitig die Einschränkungen berücksichtigen.

Puppenspieler

Cookies werden verwendet, um Statusinformationen während Interaktionen zu speichern. In Puppeteer funktionieren sie wie normale Web-Cookies, werden aber programmgesteuert mit spezifischen Methoden sowohl auf Seiten- als auch auf Browserkontextebene verwaltet.

Wenn eine Website ein Cookie setzt, wird es automatisch in die Header zukünftiger Anfragen an diese Website aufgenommen, um die Kontinuität der Sitzung zu gewährleisten. Puppeteer bietet zwei Hauptmethoden für den Umgang mit Cookies:

Methode Sinn Geltungsbereich
Seite.Cookies() Ruft Cookies von der aktuellen Seite ab Seitenspezifisch
page.setCookie() Setzt Cookies vor der Seitennavigation Seitenspezifisch
context.addCookies() Setzt Cookies für mehrere Seiten Browserkontext

Wenn Sie diese Methoden verstehen, können Sie Cookies effektiv verwalten – sei es beim Setzen, Abrufen oder Entfernen.

Cookies verfügen über mehrere Attribute, die ihr Verhalten und ihre Sicherheitseinstellungen definieren:

Immobilien Beschreibung Anwendungsbeispiel
Name Kennung für das Cookie sessionId
Wert Im Cookie gespeicherte Daten user123token
Domain Domain, in der das Cookie gültig ist .example.com
Path URL-Pfad für das Cookie /dashboard
Läuft ab Ablaufdatum und -zeit 03/30/2025 12:00 PM EST
und geschützt Beschränkt die Nutzung auf HTTPS-Verbindungen true or false
HttpOnly Beschränkt den Zugriff nur auf die Serverseite true or false
GleicheSite Steuert das standortübergreifende Verhalten Strict, Lax, oder auch None

Cookies in Puppeteer können entweder bis zu ihrem Ablaufdatum oder nur für die aktuelle Browsersitzung bestehen bleiben. Darüber hinaus werden in einem Browserkontext gesetzte Cookies nicht mit einem anderen Browserkontext geteilt, wodurch die Trennung zwischen Aufgaben gewährleistet wird.

Für bewährte Methoden:

  • Speichern Sie Cookies im JSON-Format zur einfachen Wiederverwendung.
  • Aktualisieren Sie Cookies regelmäßig, um Ablaufprobleme zu vermeiden.
  • Verwenden Sie separate Browserkontexte für unterschiedliche Automatisierungsaufgaben.
  • Behalten Sie die Cookie-Größe im Auge, um Speicherbeschränkungen zu vermeiden.

Als Nächstes erfahren Sie, wie Sie diese Cookies in Puppeteer programmgesteuert verwalten.

Nodejs Puppeteer Tutorial Nr. 9 – Cookies speichern und wiederverwenden

Verwalten von Cookies in Puppeteer

Erfahren Sie mit diesen praktischen Methoden, wie Sie Cookies in Puppeteer verwalten. Diese Techniken sind unerlässlich für die Verwaltung von Sitzungsdaten und die Authentifizierung, die in verwandten Aufgaben näher erläutert werden.

Cookies setzen

Wasser page.setCookie() um ein oder mehrere Cookies zu definieren. Dies trägt dazu bei, den Sitzungsstatus effektiv aufrechtzuerhalten. So geht's:

// Setting a single cookie
await page.setCookie({
  name: 'sessionToken',
  value: 'abc123xyz',
  domain: '.example.com',
  path: '/',
  expires: Math.floor(Date.now() / 1000) + 3600, // 1 hour from now
  httpOnly: true,
  secure: true,
  sameSite: 'Strict'
});

// Setting multiple cookies
await page.setCookie([
  {
    name: 'userPrefs',
    value: 'darkMode',
    domain: '.example.com'
  },
  {
    name: 'language',
    value: 'en-US',
    domain: '.example.com'
  }
]);

Wichtige Cookie-Parameter, die Sie beachten sollten:

Parameter Erforderlich Beschreibung
Name Ja Die Kennung des Cookies
Wert Ja Im Cookie gespeicherte Daten
Domain Ja Die Domäne, für die es gilt
Weg Nein URL-Pfad, auf den es sich bezieht
abläuft Nein Ablaufzeitstempel
httpOnly Nein Beschränkt sich auf die Servernutzung
Verbindung Nein Erfordert HTTPS

Cookies erhalten

Abrufen von Cookies mit dem page.cookies() Methode. Sie können alle Cookies abrufen oder sich auf eine bestimmte Domäne konzentrieren:

// Get all cookies
const allCookies = await page.cookies();

// Get cookies for a specific domain
const domainCookies = await page.cookies('https://example.com');

Um den Wert eines bestimmten Cookies zu extrahieren, verwenden Sie eine Hilfsfunktion wie diese:

async function getCookieValue(page, cookieName) {
  const cookies = await page.cookies();
  const targetCookie = cookies.find(cookie => cookie.name === cookieName);
  return targetCookie ? targetCookie.value : null;
}

Cookies entfernen

Sie können Cookies entweder einzeln oder auf einmal löschen:

// Remove a specific cookie
await page.deleteCookie({
  name: 'sessionToken',
  domain: '.example.com'
});

// Clear all cookies
await page.deleteCookie(...await page.cookies());

Erwägen Sie für die laufende Wartung die Automatisierung der Entfernung abgelaufener Cookies:

async function cleanupExpiredCookies(page) {
  const cookies = await page.cookies();
  const now = Date.now() / 1000;

  for (const cookie of cookies) {
    if (cookie.expires && cookie.expires < now) {
      await page.deleteCookie({
        name: cookie.name,
        domain: cookie.domain
      });
    }
  }
}

Verwenden Sie immer await mit Cookie-Operationen, um eine ordnungsgemäße Ausführung sicherzustellen und Race Conditions zu vermeiden.

sbb-itb-23997f1

Sitzungsverwaltung

Um Sitzungen persistent zu halten, können Sie Cookies in einer JSON-Datei speichern und bei Bedarf neu laden. So funktioniert es:

const fs = require('fs');

async function saveCookies(page, filePath) {
  const cookies = await page.cookies();
  fs.writeFileSync(filePath, JSON.stringify(cookies, null, 2));
}

async function loadCookies(page, filePath) {
  const cookieData = fs.readFileSync(filePath);
  const cookies = JSON.parse(cookieData);
  await page.setCookie(...cookies);
}

Wichtige Überlegungen:

  • Aktualisieren Sie Cookies nach kritischen Aktionen.
  • Validieren Sie die Datei, bevor Sie Cookies laden.
  • Speichern Sie die Datei an einem sicheren Ort.
  • Überprüfen Sie regelmäßig die Integrität der Datei.

Sitzungsstatusverwaltung

Die aktive Sitzungsverwaltung erweitert das Cookie-Management und stellt sicher, dass die Benutzerauthentifizierung gültig bleibt. So verwalten Sie Sitzungen effektiv:

async function manageSession(page, cookiePath) {
  let sessionValid = false;

  try {
    if (fs.existsSync(cookiePath)) {
      await loadCookies(page, cookiePath);
      sessionValid = await validateSession(page);
    }

    if (!sessionValid) {
      await performAuthentication(page);
      await saveCookies(page, cookiePath);
    }
  } catch (error) {
    console.error('Session management error:', error);
  }
}

async function validateSession(page) {
  const cookies = await page.cookies();
  return cookies.some(cookie => 
    cookie.name === 'sessionToken' && 
    cookie.expires > (Date.now() / 1000)
  );
}

Bewährte Methoden für die Sitzungsverwaltung:

  • Behalten Sie die Ablaufzeiten von Cookies im Auge.
  • Bewältigen Sie unerwartete Sitzungsunterbrechungen elegant.
  • Speichern Sie Cookies sicher, um unbefugten Zugriff zu verhindern.
  • Verwenden Sie separate Browserkontexte für unterschiedliche Aufgaben.

Erwägen Sie bei Sitzungen mit langer Laufzeit, diese in kleinere Segmente mit unterschiedlichen Cookie-Sets aufzuteilen, um die Zuverlässigkeit zu verbessern und potenzielle Probleme zu reduzieren.

Authentifizierung mit Cookies

Cookies können den Authentifizierungsprozess vereinfachen und sichern, wenn sie mit Sitzungsverwaltungstechniken kombiniert werden.

Login-Automatisierung

Sparen Sie Zeit, indem Sie Cookies zum Speichern und Wiederverwenden von Authentifizierungstoken verwenden. So müssen Sie Anmeldeformulare nicht mehr wiederholt ausfüllen. Hier ein Beispiel:

async function handleLogin(page, cookiePath) {
  const authenticationStatus = await validateAuthStatus(page);

  if (!authenticationStatus.isValid) {
    await performLogin(page);
    await saveCookiesToFile(page, cookiePath);
  }
}

async function validateAuthStatus(page) {
  const cookies = await page.cookies();
  return {
    isValid: cookies.some(cookie => 
      cookie.name === 'authToken' && 
      cookie.expires > (Date.now() / 1000)
    )
  };
}

Sobald die Basisauthentifizierung eingerichtet ist, können Sie für zusätzliche Sicherheit eine Multi-Faktor-Authentifizierung integrieren.

Multi-Faktor-Authentifizierung

Die Verwaltung der Multi-Faktor-Authentifizierung (MFA) mit Cookies umfasst die Verfolgung von Verifizierungszuständen. So können Sie damit umgehen:

async function handleMFAAuthentication(page) {
  try {
    await page.waitForSelector('#mfa-input');
    await page.type('#mfa-input', getMFAToken()); // Replace with your MFA token provider
    await page.click('#verify-button');
    await page.waitForNavigation();

    const cookies = await page.cookies();
    return cookies.some(c => c.name === 'mfa_verified');
  } catch (error) {
    console.error('MFA verification failed:', error);
    return false;
  }
}

Stärken Sie diese Prozesse, indem Sie wichtige Sicherheitspraktiken befolgen.

Best Practices für die Sicherheit

Um eine sichere Verwaltung von Authentifizierungscookies zu gewährleisten, sollten Sie die folgenden Maßnahmen in Betracht ziehen:

Sicherheitsmaßnahme Umsetzung
Cookie-Ablauf Überwachen Sie die expires Attribut- und Aktualisierungstoken, bevor sie ablaufen.
Domänenisolierung Verwenden Sie separate Browserkontexte für unterschiedliche Authentifizierungsdomänen.
Sicherer Transport Setze die Secure Flag, um Cookies auf die reine HTTPS-Übertragung zu beschränken.
Zugangskontrolle Verwenden Sie das HttpOnly Flag, um clientseitigen Skripten den Zugriff auf Cookies zu verweigern.
Backup-Strategie Erstellen Sie Sicherungskopien der Cookies, bevor Sie Änderungen vornehmen.

Hier ist ein Beispiel für die programmgesteuerte Sicherung von Authentifizierungs-Cookies:

async function secureAuthCookies(page) {
  const cookies = await page.cookies();

  return cookies.map(cookie => ({
    ...cookie,
    secure: true,
    httpOnly: true,
    sameSite: 'Strict'
  }));
}

Um sichere Authentifizierungszustände aufrechtzuerhalten, konzentrieren Sie sich auf diese Vorgehensweisen:

  • Aktualisieren Sie Authentifizierungstoken regelmäßig.
  • Behandeln Sie Authentifizierungsfehler ordnungsgemäß.
  • Überwachen Sie Cookiedomänen auf nicht autorisierte Änderungen.
  • Verwenden Sie realistische Benutzeragent-Zeichenfolgen, um eine Erkennung zu vermeiden.

Bekannte Einschränkungen

Bei der Verwendung von Puppeteer zur Cookie-Verwaltung sind einige wichtige Einschränkungen zu beachten. Wenn Sie diese verstehen, können Sie besser planen und potenzielle Probleme vermeiden.

Browser-Einschränkungen

Puppeteer unterliegt bestimmten Einschränkungen der Browser-Sicherheitsmaßnahmen, die sich auf die Verwaltung von Cookies auswirken können. Beispielsweise gibt es keine integrierten Ereignisse zur Erkennung von Cookie-Änderungen, sodass manuelle Überprüfungen erforderlich sind.

Beschränkung Impact der HXNUMXO Observatorien Workaround
Keine Cookie-Änderungsereignisse Cookie-Änderungen können nicht automatisch erkannt werden Richten Sie regelmäßige Überprüfungen zur Überwachung des Cookie-Status ein
Kontextisolierung Auf Cookies in einem Browserkontext kann in einem anderen nicht zugegriffen werden Erstellen Sie separate Cookie-Verwaltungssysteme für jeden Kontext
Asynchrone Operationen Bei der Cookie-Verarbeitung können Race Conditions auftreten Wasser async/await mit ordnungsgemäßer Fehlerbehandlung
Kein integriertes Backup Keine native Möglichkeit zum Sichern von Cookies Manuelles Sichern von Cookies nach Bedarf

Aufgrund dieser Einschränkungen ist die Implementierung sorgfältiger Cookie-Verwaltungspraktiken unerlässlich.

Domänenzugriffsbeschränkungen

Eine weitere Herausforderung besteht in der Verwaltung von Cookies über Domänen oder Subdomänen hinweg. Falsche Domänenattributkonfigurationen können zu Authentifizierungsproblemen führen. Hier ist ein Beispiel für die Validierung von Cookies für eine bestimmte Domäne:

async function validateDomainCookies(page, targetDomain) {
  const cookies = await page.cookies();
  return cookies.filter(cookie => {
    const cookieDomain = cookie.domain.startsWith('.') ? 
      cookie.domain.slice(1) : cookie.domain;
    return cookieDomain === targetDomain;
  });
}

Die Verwaltung des Lebenszyklus von Cookies ist entscheidend für die Aufrechterhaltung der Sitzungsstabilität und die Vermeidung von Unterbrechungen. Im Folgenden finden Sie einige Strategien zur Bewältigung häufiger Lebenszyklusprobleme:

1. Ablaufmanagement

Überwachen Sie das Ablaufdatum von Cookies und aktualisieren Sie sie, bevor sie ablaufen:

async function handleCookieExpiration(page) {
  const cookies = await page.cookies();
  const currentTime = Date.now() / 1000;

  for (const cookie of cookies) {
    if (cookie.expires && cookie.expires - currentTime < 300) {
      await refreshCookie(page, cookie);
    }
  }
}

2. Cookie-Bereinigung

Bereinigen Sie veraltete Cookies regelmäßig, um eine optimale Leistung sicherzustellen und Sitzungsfehler zu vermeiden:

async function performCookieCleanup(page) {
  try {
    const cookies = await page.cookies();
    const outdatedCookies = cookies.filter(cookie => 
      cookie.expires && (cookie.expires < Date.now() / 1000)
    );
    await page.deleteCookies(...outdatedCookies);
  } catch (error) {
    console.error('Cookie cleanup failed:', error);
  }
}

3. Zustandswiederherstellung

Die Wiederherstellung des Cookie-Status ist für die Aufrechterhaltung unterbrechungsfreier Sitzungen unerlässlich. So können Sie Cookies aus einer Sicherung wiederherstellen:

async function recoverCookieState(page, backupPath) {
  try {
    const currentCookies = await page.cookies();
    if (invalidCookieState(currentCookies)) {
      const backupCookies = await loadCookiesFromBackup(backupPath);
      await page.setCookie(...backupCookies);
    }
  } catch (error) {
    console.error('State recovery failed:', error);
  }
}

Zusammenfassung

Holen Sie das Beste aus dem Cookie-Management von Puppeteer heraus, indem Sie seine Stärken und Schwächen verstehen. Die richtige Cookie-Verwaltung ist entscheidend für die Aufrechterhaltung dauerhafter Sitzungen, die Gewährleistung einer zuverlässigen Authentifizierung und die Optimierung von Automatisierungs-Workflows.

Hier ist eine kurze Übersicht über die wesentlichen Aspekte und empfohlenen Vorgehensweisen für die effektive Verwaltung von Cookies:

Aspekt Beste Übung Warum es wichtig ist
Sitzungspersistenz Cookies in JSON-Dateien speichern Behält den Sitzungsstatus zwischen den Läufen bei
Cookie-Aktualisierungen Ablaufdaten überwachen Vermeidet unerwartete Sitzungs-Timeouts
Browserkontexte Verwenden Sie separate Kontexte Verbessert Isolierung und Sicherheit
Fehlerbehandlung Try-Catch-Blöcke hinzufügen Behandelt Cookie-bezogene Fehler reibungslos

Um den Erfolg sicherzustellen:

  • Überprüfen Sie regelmäßig die Gültigkeit von Cookies und verfolgen Sie deren Lebenszyklus.
  • Verschlüsseln Sie gespeicherte Cookies, um sie sicher aufzubewahren.
  • Befolgen Sie Protokolle zur sicheren Handhabung, um vertrauliche Daten zu schützen.

Beim Starten von Puppeteer verwenden Sie die userDataDir Möglichkeit zur Speicherung von Sitzungsdaten über mehrere Ausführungen hinweg. Durch die Integration von Fehlerbehandlungsmechanismen und Sicherheitsmaßnahmen können Sie stabile, effiziente Automatisierungs-Workflows erstellen, die eine konsistente Authentifizierung gewährleisten.

Zusammenhängende Artikel

Verwandte Blogs

Anwendungsfall

Unterstützt von