.png)
.svg){kind=icon}
22 mars 2025
•
9
min lire
Gestion des cookies dans Puppeteer : préservation de session, émulation d'authentification et limitations
Georges Miloradovitch
Chercheur, rédacteur et intervieweur de cas d'utilisation
Vous souhaitez rationaliser la gestion des sessions et les tests d'authentification avec Marionnettiste? Voici ce que vous devez savoir pour gérer efficacement les cookies :
Petit conseil: Enregistrez les cookies au format JSON, utilisez des contextes de navigateur distincts et surveillez les dates d'expiration pour éviter les problèmes.
Découvrez comment définir, récupérer et sécuriser les cookies dans Puppeteer tout en tenant compte de ses limites.
Les cookies servent à stocker des informations d'état lors des interactions. Dans Puppeteer, ils fonctionnent comme des cookies web classiques, mais sont gérés par programmation à l'aide de méthodes spécifiques, au niveau de la page et du navigateur.
Lorsqu'un site web installe un cookie, celui-ci est automatiquement inclus dans les en-têtes des futures requêtes adressées à ce site, garantissant ainsi la continuité de la session. Puppeteer propose deux méthodes principales pour gérer les cookies :
| Méthode | Objectif | Domaine |
|---|---|---|
| page.cookies() | Récupère les cookies de la page actuelle | Spécifique à la page |
| page.setCookie() | Définit les cookies avant la navigation sur la page | Spécifique à la page |
| contexte.addCookies() | Définit des cookies pour plusieurs pages | Contexte du navigateur |
En comprenant ces méthodes, vous pouvez gérer efficacement les cookies, qu'il s'agisse de les définir, de les récupérer ou de les supprimer.
Les cookies sont dotés de plusieurs attributs qui définissent leur comportement et leurs paramètres de sécurité :
| Propriété | Description | Exemple d'utilisation |
|---|---|---|
| Nom | Identifiant du cookie | sessionId |
| Valeur | Données stockées dans le cookie | user123token |
| Domaine | Domaine où le cookie est valide | .example.com |
| Chemin | Chemin URL du cookie | /dashboard |
| Expire le | Date et heure d'expiration | 03/30/2025 12:00 PM EST |
| Sécurisés | Limite l'utilisation aux connexions HTTPS | true or false |
| HttpOnly | Restreint l'accès au côté serveur uniquement | true or false |
| MêmeSite | Contrôle le comportement intersite | Strict, Lax, ou None |
Les cookies dans Puppeteer peuvent être conservés jusqu'à leur expiration ou uniquement le temps de la session de navigation en cours. De plus, les cookies définis dans un contexte de navigateur ne sont pas partagés avec un autre, garantissant ainsi l'isolation entre les tâches.
Pour les meilleures pratiques :
Ensuite, apprenez à gérer ces cookies par programmation dans Puppeteer.
Apprenez à gérer les cookies dans Puppeteer grâce à ces méthodes pratiques. Ces techniques sont essentielles à la gestion des données de session et de l'authentification, qui seront approfondies dans les tâches connexes.
Utilisez page.setCookie() Pour définir un ou plusieurs cookies. Cela permet de maintenir efficacement l'état de la session. Voici comment procéder :
// 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'
}
]);
Paramètres clés des cookies à garder à l’esprit :
| Paramètre | Requis | Description |
|---|---|---|
| prénom | Oui | L'identifiant du cookie |
| Plus-value | Oui | Données stockées dans le cookie |
| domaine | Oui | Le domaine auquel il s'applique |
| chemin | Non | Chemin d'URL auquel il s'applique |
| expire | Non | Horodatage d'expiration |
| http uniquement | Non | Limite l'utilisation du serveur |
| sécurisée | Non | Nécessite HTTPS |
Récupérer les cookies avec le page.cookies() Méthode. Vous pouvez récupérer tous les cookies ou vous concentrer sur un domaine spécifique :
// Get all cookies
const allCookies = await page.cookies();
// Get cookies for a specific domain
const domainCookies = await page.cookies('https://example.com');
Pour extraire la valeur d'un cookie spécifique, utilisez une fonction d'assistance comme celle-ci :
async function getCookieValue(page, cookieName) {
const cookies = await page.cookies();
const targetCookie = cookies.find(cookie => cookie.name === cookieName);
return targetCookie ? targetCookie.value : null;
}
Vous pouvez supprimer les cookies individuellement ou en masse :
// Remove a specific cookie
await page.deleteCookie({
name: 'sessionToken',
domain: '.example.com'
});
// Clear all cookies
await page.deleteCookie(...await page.cookies());
Pour une maintenance continue, pensez à automatiser la suppression des cookies expirés :
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
});
}
}
}
Toujours utiliser await avec des opérations de cookies pour assurer une exécution correcte et éviter les conditions de course.
Pour maintenir la persistance des sessions, vous pouvez enregistrer les cookies dans un fichier JSON et les recharger si nécessaire. Voici une méthode pratique :
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);
}
Considérations clés:
Pour aller plus loin dans la gestion des cookies, la gestion active des sessions garantit la validité de l'authentification des utilisateurs. Voici comment gérer efficacement les sessions :
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)
);
}
Bonnes pratiques pour la gestion des sessions :
Pour les sessions de longue durée, pensez à les diviser en segments plus petits avec des ensembles de cookies distincts pour améliorer la fiabilité et réduire les problèmes potentiels.
Les cookies peuvent simplifier et sécuriser le processus d’authentification lorsqu’ils sont associés à des techniques de gestion de session.
Gagnez du temps en utilisant des cookies pour stocker et réutiliser les jetons d'authentification, évitant ainsi de remplir plusieurs fois les formulaires de connexion. Voici un exemple :
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)
)
};
}
Une fois l’authentification de base établie, vous pouvez intégrer l’authentification multifacteur pour plus de sécurité.
La gestion de l'authentification multifacteur (AMF) avec cookies implique le suivi des états de vérification. Voici comment procéder :
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;
}
}
Renforcez ces processus en suivant les pratiques de sécurité clés.
Pour garantir une gestion sécurisée des cookies d’authentification, tenez compte des mesures suivantes :
| Mesure de sécurité | Implantation |
|---|---|
| Expiration des cookies | Surveiller le expires attribuer et actualiser les jetons avant leur expiration. |
| Isolation de domaine | Utilisez des contextes de navigateur distincts pour différents domaines d’authentification. |
| Transport sécurisé | Mettez le Secure indicateur pour restreindre les cookies à la transmission HTTPS uniquement. |
| Contrôle d'accès | Utilisez l'option HttpOnly indicateur pour empêcher les scripts côté client d'accéder aux cookies. |
| Stratégie de sauvegarde | Créez des sauvegardes des cookies avant d'effectuer des modifications. |
Voici un exemple de sécurisation programmatique des cookies d'authentification :
async function secureAuthCookies(page) {
const cookies = await page.cookies();
return cookies.map(cookie => ({
...cookie,
secure: true,
httpOnly: true,
sameSite: 'Strict'
}));
}
Pour maintenir des états d’authentification sécurisés, concentrez-vous sur ces pratiques :
Lorsque vous utilisez Puppeteer pour la gestion des cookies, il existe des contraintes importantes à prendre en compte. Les comprendre vous aidera à mieux planifier et à éviter les problèmes potentiels.
Puppeteer hérite de certaines limitations liées aux mesures de sécurité des navigateurs, ce qui peut affecter la gestion des cookies. Par exemple, il n'existe aucun événement intégré pour détecter les modifications de cookies ; des vérifications manuelles sont donc nécessaires.
| Restriction | Impact positif | Solution |
|---|---|---|
| Aucun événement de modification de cookie | Impossible de détecter automatiquement les modifications des cookies | Configurer des contrôles périodiques pour surveiller l'état des cookies |
| Isolation du contexte | Les cookies dans un contexte de navigateur ne sont pas accessibles dans un autre | Créer des systèmes de gestion des cookies distincts pour chaque contexte |
| Opérations asynchrones | Des conditions de course peuvent survenir lors de la gestion des cookies | Utilisez async/await avec une gestion des erreurs appropriée |
| Aucune sauvegarde intégrée | Aucun moyen natif de sauvegarder les cookies | Sauvegarder manuellement les cookies si nécessaire |
Ces contraintes rendent indispensable la mise en œuvre de pratiques de gestion des cookies rigoureuses.
Un autre défi réside dans la gestion des cookies entre domaines ou sous-domaines. Une configuration incorrecte des attributs de domaine peut entraîner des problèmes d'authentification. Voici un exemple de validation des cookies pour un domaine spécifique :
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;
});
}
La gestion du cycle de vie des cookies est essentielle pour maintenir la stabilité des sessions et éviter les interruptions. Voici quelques stratégies pour gérer les problèmes courants liés au cycle de vie :
1. Gestion des expirations
Surveillez les dates d’expiration des cookies et actualisez-les avant leur expiration :
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. Nettoyage des cookies
Nettoyez régulièrement les cookies obsolètes pour garantir des performances optimales et éviter les erreurs de session :
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. Récupération de l'État
La récupération de l'état des cookies est essentielle pour maintenir des sessions ininterrompues. Voici comment restaurer les cookies à partir d'une sauvegarde :
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);
}
}
Exploitez pleinement la gestion des cookies de Puppeteer en comprenant ses atouts et ses limites. Une gestion adéquate des cookies est essentielle pour maintenir des sessions persistantes, garantir une authentification fiable et optimiser les processus d'automatisation.
Voici un aperçu rapide des aspects essentiels et des pratiques recommandées pour gérer efficacement les cookies :
| Aspect | Best Practice | Pourquoi ça compte |
|---|---|---|
| Persistance de la session | Enregistrer les cookies dans des fichiers JSON | Conserve l'état de la session entre les exécutions |
| Mises à jour des cookies | Surveiller les dates d'expiration | Évite les expirations de session inattendues |
| Contextes du navigateur | Utiliser des contextes distincts | Améliore l'isolement et la sécurité |
| Gestion des erreurs | Ajouter des blocs try-catch | Gère les erreurs liées aux cookies en douceur |
Pour assurer le succès :
Lors du lancement de Puppeteer, utilisez le userDataDir Possibilité de conserver les données de session entre les exécutions. L'intégration de mécanismes de gestion des erreurs et de mesures de sécurité vous aidera à créer des workflows d'automatisation stables et efficaces, garantissant une authentification cohérente.
