Una plataforma de código bajo que combina la simplicidad sin código con el poder del código completo 🚀
Empieza ahora gratis
Gestión de cookies en Puppeteer: conservación de sesiones, emulación de autenticación y limitaciones
Marzo 22, 2025
9
min leer

Gestión de cookies en Puppeteer: conservación de sesiones, emulación de autenticación y limitaciones

George Miloradovich
Investigador, redactor y entrevistador de casos prácticos
Tabla de contenidos.

¿Quiere optimizar la gestión de sesiones y las pruebas de autenticación con Titiritero? Esto es lo que necesita saber sobre cómo gestionar las cookies de manera eficaz:

  • Por qué son importantes las cookies: Almacenan datos de sesión, preferencias y detalles de inicio de sesión.
  • Lo que puedes hacer: Guarde sesiones, pruebe la autenticación, administre estados e incluso imite el comportamiento del usuario real.
  • Como administrar: Puppeteer le permite configurar, obtener y eliminar cookies mediante programación.
  • Desafíos a tener en cuenta: Riesgos de seguridad, limitaciones del navegador y gestión del ciclo de vida de las cookies.

Características Clave:

  • Persistencia de la sesión: Guardar y volver a cargar las cookies para mantener los estados de inicio de sesión.
  • Automatización de la autenticación: Utilice cookies para evitar pasos repetitivos de inicio de sesión.
  • Casos de uso prácticos: Automatice carritos de compra, pruebe roles de usuario y más.

Consejo rápido: Guarde las cookies en formato JSON, utilice contextos de navegador separados y controle las fechas de vencimiento para evitar problemas.

Aprenda a configurar, recuperar y proteger las cookies en Puppeteer y al mismo tiempo abordar sus limitaciones.

Titiritero

Las cookies se utilizan para almacenar información de estado durante las interacciones. En Puppeteer, funcionan como cookies web normales, pero se gestionan programáticamente mediante métodos específicos, tanto a nivel de página como de contexto del navegador.

Cuando un sitio web instala una cookie, esta se incluye automáticamente en los encabezados de las futuras solicitudes a ese sitio, lo que garantiza la continuidad de la sesión. Puppeteer ofrece dos métodos principales para gestionar las cookies:

Método Propósito <b></b><b></b>
página.cookies() Recupera cookies de la página actual Específico de la página
página.setCookie() Establece cookies antes de navegar por la página Específico de la página
contexto.addCookies() Establece cookies para varias páginas Contexto del navegador

Al comprender estos métodos, podrá administrar las cookies de manera efectiva, ya sea configurándolas, recuperándolas o eliminándolas.

Las cookies vienen con varios atributos que definen su comportamiento y configuración de seguridad:

Propiedad Descripción original Ejemplo de uso
Nombre Identificador de la cookie sessionId
Value alto Datos almacenados en la cookie user123token
Dominio Dominio donde la cookie es válida .example.com
Path Ruta URL de la cookie /dashboard
Expira Fecha y hora de vencimiento 03/30/2025 12:00 PM EST
Seguro Limita el uso a conexiones HTTPS true or false
HttpOnly Restringe el acceso únicamente al lado del servidor true or false
MismoSitio Controla el comportamiento entre sitios Strict, Laxo None

Las cookies en Puppeteer pueden persistir hasta su vencimiento o durar únicamente durante la sesión actual del navegador. Además, las cookies configuradas en un navegador no se comparten con otro, lo que garantiza el aislamiento entre tareas.

Para mejores prácticas:

  • Guarde las cookies en formato JSON para reutilizarlas fácilmente.
  • Actualice las cookies periódicamente para evitar problemas de caducidad.
  • Utilice contextos de navegador separados para diferentes tareas de automatización.
  • Vigila el tamaño de las cookies para evitar límites de almacenamiento.

A continuación, aprenderá a administrar estas cookies mediante programación en Puppeteer.

Tutorial de Puppeteer de Node.js n.° 9: Guardar y reutilizar cookies

Administración de cookies en Puppeteer

Aprenda a gestionar las cookies en Puppeteer con estos métodos prácticos. Estas técnicas son esenciales para la gestión de datos de sesión y la autenticación, que se analizarán con más detalle en tareas relacionadas.

Configuración de cookies

Use page.setCookie() Para definir una o más cookies. Esto ayuda a mantener el estado de la sesión eficazmente. Así es como se hace:

// 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'
  }
]);

Parámetros clave de las cookies a tener en cuenta:

Parámetro Requerido Descripción original
nombre El identificador de la cookie
propuesta de Datos almacenados en la cookie
dominio El dominio al que se aplica
camino No Ruta URL a la que se aplica
vence No Marca de tiempo de expiración
Sólo http No Restringe el uso del servidor
seguro No Requiere HTTPS

Obtener cookies

Recuperar cookies con el page.cookies() Método. Puedes recuperar todas las cookies o centrarte en un dominio específico:

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

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

Para extraer el valor de una cookie específica, utilice una función auxiliar como esta:

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

Eliminación de cookies

Puedes eliminar las cookies individualmente o en masa:

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

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

Para un mantenimiento continuo, considere automatizar la eliminación de cookies caducadas:

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
      });
    }
  }
}

Siempre usa await con operaciones de cookies para garantizar la correcta ejecución y evitar condiciones de carrera.

sbb-itb-23997f1

Gestión de sesiones

Para mantener la persistencia de las sesiones, puedes guardar las cookies en un archivo JSON y recargarlas cuando sea necesario. Aquí tienes una forma práctica de hacerlo:

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);
}

Consideraciones clave:

  • Actualizar las cookies después de acciones críticas.
  • Validar el archivo antes de cargar las cookies.
  • Guarde el archivo en un lugar seguro.
  • Compruebe periódicamente la integridad del archivo.

Gestión del estado de la sesión

Para llevar la gestión de cookies al siguiente nivel, la gestión activa de sesiones garantiza la validez de la autenticación del usuario. Así es como se pueden gestionar las sesiones eficazmente:

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)
  );
}

Mejores prácticas para la gestión de sesiones:

  • Realizar un seguimiento de los tiempos de expiración de las cookies.
  • Maneje las interrupciones inesperadas de la sesión con elegancia.
  • Almacene las cookies de forma segura para evitar accesos no autorizados.
  • Utilice contextos de navegador separados para diferentes tareas.

Para sesiones de larga duración, considere dividirlas en segmentos más pequeños con conjuntos de cookies distintos para mejorar la confiabilidad y reducir posibles problemas.

Autenticación con cookies

Las cookies pueden simplificar y asegurar el proceso de autenticación cuando se combinan con técnicas de gestión de sesiones.

Automatización de inicio de sesión

Ahorre tiempo usando cookies para almacenar y reutilizar tokens de autenticación, eliminando así la necesidad de rellenar formularios de inicio de sesión repetidamente. A continuación, un ejemplo:

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)
    )
  };
}

Una vez establecida la autenticación básica, puede incorporar autenticación multifactor para mayor seguridad.

Autenticación de múltiples factores

Gestionar la autenticación multifactor (MFA) con cookies implica el seguimiento de los estados de verificación. Aquí te explicamos cómo hacerlo:

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;
  }
}

Fortalezca estos procesos siguiendo prácticas de seguridad clave.

Mejores prácticas de seguridad

Para garantizar una gestión segura de las cookies de autenticación, tenga en cuenta estas medidas:

Medida de seguridad Implementación
Caducidad de las cookies Supervisar el expires Atribuir y actualizar tokens antes de que caduquen.
Aislamiento de dominio Utilice contextos de navegador separados para diferentes dominios de autenticación.
Transporte seguro Seleccione las Secure bandera para restringir las cookies a la transmisión únicamente mediante HTTPS.
Control de Acceso Ingrese al HttpOnly bandera para bloquear los scripts del lado del cliente para que no accedan a las cookies.
Estrategia de respaldo Crear copias de seguridad de las cookies antes de realizar modificaciones.

A continuación se muestra un ejemplo de cómo proteger las cookies de autenticación mediante programación:

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

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

Para mantener estados de autenticación seguros, concéntrese en estas prácticas:

  • Actualice periódicamente los tokens de autenticación.
  • Manejar adecuadamente los errores de autenticación.
  • Supervisar los dominios de cookies para detectar cambios no autorizados.
  • Utilice cadenas de agente de usuario realistas para evitar la detección.

Limitaciones conocidas

Al usar Puppeteer para la gestión de cookies, existen algunas limitaciones importantes que debe tener en cuenta. Comprenderlas le ayudará a planificar mejor y a evitar posibles problemas.

Restricciones del navegador

Puppeteer hereda ciertas limitaciones de las medidas de seguridad del navegador, lo que puede afectar la gestión de las cookies. Por ejemplo, no hay eventos integrados para detectar cambios en las cookies, por lo que es necesario realizar comprobaciones manuales.

Restricción Impacto Solución
Sin eventos de cambio de cookies No se pueden detectar modificaciones de cookies automáticamente Configurar comprobaciones periódicas para supervisar el estado de las cookies
Aislamiento de contexto Las cookies en un contexto de navegador no pueden ser accedidas en otro Crear sistemas de gestión de cookies independientes para cada contexto
Operaciones asíncronas Pueden producirse condiciones de carrera durante el manejo de cookies Use async/await con un manejo adecuado de errores
Sin copia de seguridad incorporada No existe una forma nativa de realizar copias de seguridad de las cookies Realice copias de seguridad manuales de las cookies según sea necesario

Estas limitaciones hacen que sea esencial implementar prácticas cuidadosas de gestión de cookies.

Límites de acceso al dominio

Otro desafío radica en la gestión de cookies entre dominios o subdominios. Configurar incorrectamente los atributos de dominio puede provocar problemas de autenticación. A continuación, se muestra un ejemplo de cómo validar las cookies para un dominio específico:

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;
  });
}

Gestionar el ciclo de vida de las cookies es crucial para mantener la estabilidad de la sesión y evitar interrupciones. A continuación, se presentan algunas estrategias para gestionar problemas comunes del ciclo de vida:

1. Gestión de caducidad

Supervise las fechas de caducidad de las cookies y actualícelas antes de que caduquen:

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. Limpieza de cookies

Limpie periódicamente las cookies obsoletas para garantizar un rendimiento óptimo y evitar errores de sesión:

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. Recuperación del Estado

Recuperar el estado de las cookies es esencial para mantener sesiones ininterrumpidas. A continuación, le indicamos cómo restaurar las cookies desde una copia de seguridad:

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);
  }
}

Resum

Saque el máximo provecho de la gestión de cookies de Puppeteer comprendiendo sus ventajas y desventajas. Una gestión adecuada de las cookies es clave para mantener sesiones persistentes, garantizar una autenticación fiable y optimizar los flujos de trabajo de automatización.

A continuación, se presenta un breve resumen de los aspectos esenciales y las prácticas recomendadas para gestionar las cookies de manera eficaz:

Aspecto Mejores Prácticas Por qué es Importante
Persistencia de sesión Guardar cookies en archivos JSON Mantiene el estado de la sesión entre ejecuciones
Actualizaciones de cookies Monitorizar fechas de caducidad Evita tiempos de espera de sesión inesperados
Contextos del navegador Utilice contextos separados Mejora el aislamiento y la seguridad.
Gestión de errores Agregar bloques try-catch Maneja sin problemas los errores relacionados con las cookies

Para asegurar el éxito:

  • Verifique periódicamente la validez de las cookies y realice un seguimiento de su ciclo de vida.
  • Cifre las cookies almacenadas para mantenerlas seguras.
  • Siga protocolos de manejo seguro para proteger datos confidenciales.

Al iniciar Puppeteer, utilice el userDataDir Opción para conservar los datos de sesión entre ejecuciones. Incorporar mecanismos de gestión de errores y medidas de seguridad le ayudará a crear flujos de trabajo de automatización estables y eficientes que mantengan una autenticación consistente.

Artículos relacionados con

Blogs relacionados

Caso de uso

Respaldado por