Configuración de proxies en Puppeteer: autenticación, rotación y técnicas para evitar bloqueos

Los proxies son esenciales para la automatización con Puppeteer. Ocultan su IP, eluden las restricciones geográficas y ayudan a evitar bloqueos. Esto es lo que aprenderá sobre el uso de proxies en Puppeteer:

1. Configurar proxies: Añada proxies a su navegador y autentíquelos fácilmente.
2. Rotar proxies: Distribuya las solicitudes entre varias IP para evitar la detección.
3. Gestionar errores: Reintente solicitudes, administre bloqueos y cambie de proxy cuando sea necesario.
4. Optimizar la velocidad: Bloquee recursos innecesarios y rote los agentes de usuario para realizar scraping más rápido y discreto.

Comparación rápida de tipos de proxy

Integración de proxy de Puppeteer con Bright Data - Tutorial completo 2024

Configuración básica de proxy

Configurar un proxy es un paso clave para optimizar su automatización con Puppeteer. A continuación, le mostramos cómo empezar.

Añadir un servidor proxy

Puede configurar un servidor proxy durante el inicio del navegador en Puppeteer de esta forma:

const browser = await puppeteer.launch({
    args: ['--proxy-server=http://157.230.255.230:8118']
});
const page = await browser.newPage();

También es importante gestionar los errores al navegar mediante un proxy:

try {
    await page.goto('https://books.toscrape.com/', {
        timeout: 70000,
        waitUntil: 'networkidle2'
    });
} catch (err) {
    console.log(err);
}

A continuación, deberá proteger su conexión configurando la autenticación del proxy.

Pasos para la autenticación del proxy

Si su proxy requiere autenticación, puede utilizar el siguiente método:

await page.authenticate({
    username: 'your_proxy_username',
    password: 'your_proxy_password'
});

A continuación encontrará una comparación rápida de distintos métodos de autenticación:

Una vez que haya configurado su proxy y la autenticación, es momento de probarlo.

Probar la configuración del proxy

Asegúrese de que su proxy funcione siguiendo estos pasos:

• Pruebe la conexión con una URL de ejemplo.
• Confirme que se está utilizando la IP del proxy.
• Supervise el rendimiento de la configuración.

Aquí tiene un script de ejemplo para probar su proxy:

async function testProxy() {
    const browser = await puppeteer.launch({
        args: ['--proxy-server=http://157.230.255.230:8118']
    });
    const page = await browser.newPage();
    try {
        await page.goto('https://books.toscrape.com/', {
            timeout: 70000,
            waitUntil: 'networkidle2'
        });
        const content = await page.content();
        console.log('Proxy connection successful');
    } catch (err) {
        console.log('Proxy connection failed:', err);
    }
    await browser.close();
}

Las pruebas garantizan que la configuración de su proxy esté lista para utilizarse en sus tareas de automatización.

Métodos de rotación de proxies

Gestionar la rotación de proxies es esencial para evitar bloqueos de IP y limitaciones de frecuencia al realizar scraping o automatizar tareas en línea.

Crear una lista de proxies

Para empezar, cree una lista de proxies que pueda rotarse de forma eficiente. A continuación se muestra un ejemplo de cómo configurar y utilizar un grupo de proxies:

const proxyList = [
    {
        host: '157.230.255.230',
        port: '8118',
        username: 'user1',
        password: 'pass1'
    },
    // Add more proxy configurations
];

function getRandomProxy() {
    return proxyList[Math.floor(Math.random() * proxyList.length)];
}

Al configurar su lista de proxies, es importante comprender los distintos tipos de proxy y sus ventajas e inconvenientes:

Cada tipo tiene sus puntos fuertes y débiles, por lo que debe elegir según sus necesidades específicas, como velocidad, fiabilidad o presupuesto.

Cambiar proxies entre solicitudes

Para rotar proxies automáticamente, puede utilizar la siguiente configuración:

const ProxyChain = require('proxy-chain');

const server = new ProxyChain.Server({
    port: 8080,
    prepareRequestFunction: ({ request }) => {
        const proxy = getRandomProxy();
        return {
            upstreamProxyUrl: `http://${proxy.username}:${proxy.password}@${proxy.host}:${proxy.port}`
        };
    }
});

const browser = await puppeteer.launch({
    args: ['--proxy-server=http://localhost:8080']
});

Este enfoque garantiza que cada solicitud se enrute a través de un proxy diferente sin reiniciar el navegador, lo que hace que el proceso sea más eficiente.

Directrices para la rotación de proxies

Estas son algunas prácticas clave para mejorar su estrategia de rotación de proxies:

1. Estrategia de temporización

Introduzca retrasos aleatorios entre solicitudes para simular un comportamiento de navegación natural:

function getRotationDelay() {
    // Random delay between 2-5 seconds
    return Math.floor(Math.random() * 3000) + 2000;
}

async function rotateProxy() {
    await new Promise(resolve => setTimeout(resolve, getRotationDelay()));
    const proxy = getRandomProxy();
    // Apply new proxy configuration
}

2. Gestión de errores

Si un proxy falla, gestione el error adecuadamente cambiando a otro y reintentando la solicitud:

async function handleProxyError(error, page) {
    console.log(`Proxy error: ${error.message}`);
    await rotateProxy();
    return page.reload({ waitUntil: 'networkidle2' });
}

3. Gestión de sesiones

Para tareas que requieren consistencia de sesión, utilice el mismo proxy para las solicitudes relacionadas:

const sessionMap = new Map();

function getProxyForSession(sessionId) {
    if (!sessionMap.has(sessionId)) {
        sessionMap.set(sessionId, getRandomProxy());
    }
    return sessionMap.get(sessionId);
}

Con estas estrategias, puede gestionar proxies de forma eficiente y prepararse para desafíos más avanzados, como gestionar bloqueos, CAPTCHA y otros obstáculos.

sbb-itb-23997f1

Técnicas avanzadas de proxy

Proxies residenciales frente a proxies de centro de datos

Seleccionar el proxy adecuado es clave al trabajar con automatización de Puppeteer. Esta comparación le ayudará a decidir:

Los proxies residenciales son una opción sólida para tareas que requieren un alto anonimato, ya que se asemejan mucho a la actividad de usuarios reales [1].

Gestionar bloqueos y CAPTCHA

Para abordar bloqueos de sitios web y desafíos CAPTCHA, utilice mecanismos de rotación de proxies y reintentos. A continuación se muestra un ejemplo de cómo gestionar estos problemas:

const proxyManager = {
    rotationDelay: 2000,
    async handleBlock(page) {
        await page.waitForTimeout(this.rotationDelay);
        const newProxy = await this.getNextProxy();
        await page.authenticate(newProxy);
        return page.reload({ waitUntil: 'networkidle0' });
    },
    async detectBlock(response) {
        return response.status() === 403 || response.status() === 429;
    }
};

Cuando se detecta un bloqueo, reintentar con un nuevo proxy puede mantener su automatización funcionando sin problemas:

page.on('response', async (response) => {
    if (await proxyManager.detectBlock(response)) {
        await proxyManager.handleBlock(page);
    }
});

Estas estrategias ayudan a mantener la continuidad del flujo, incluso al encontrar dificultades.

Gestionar errores de proxy

Gestionar los errores de proxy de forma eficaz requiere ajustes de tiempo de espera, comprobaciones de validación y proxies de respaldo. Por ejemplo:

async function handleProxyError(error, page) {
    if (error.message.includes('net::ERR_PROXY_CONNECTION_FAILED')) {
        const newProxy = await getBackupProxy();
        await page.authenticate(newProxy);
        await page.setExtraHTTPHeaders({
            'User-Agent': generateRandomUserAgent()
        });
        return page.reload({ waitUntil: 'networkidle2' });
    }
}

Siga estas directrices para mejorar la gestión de errores:

• Configure tiempos de espera de conexión para evitar esperas prolongadas.
• Supervise continuamente el rendimiento de los proxies.
• Mantenga preparado un grupo de proxies de respaldo.

Configurar correctamente su navegador también influye en garantizar un rendimiento fluido:

const browser = await puppeteer.launch({
    args: ['--proxy-server=http://proxy-server:port'],
    timeout: 60000,
    waitUntil: 'networkidle0'
});

Por último, valide siempre sus proxies para asegurarse de que funcionan:

async function validateProxy(proxyConfig) {
    try {
        const response = await fetch('https://api.ipify.org?format=json', {
            proxy: `http://${proxyConfig.host}:${proxyConfig.port}`
        });
        return response.ok;
    } catch (error) {
        console.error(`Proxy validation failed: ${error.message}`);
        return false;
    }
}

Consejos de rendimiento para proxies

¿Quiere aprovechar al máximo Puppeteer? Estos consejos pueden ayudarle a ajustar la configuración de sus proxies y mejorar el rendimiento general.

Pruebas de velocidad y optimización

Reduzca los tiempos de carga bloqueando solicitudes innecesarias, como imágenes, fuentes y hojas de estilo:

await page.setRequestInterception(true);
page.on('request', (req) => {
    if (req.resourceType() === 'stylesheet' || req.resourceType() === 'font' || req.resourceType() === 'image') {
        req.abort();
    } else {
        req.continue();
    }
});

Combine page.goto con page.waitForSelector para una navegación más rápida:

await page.goto(url, {
    timeout: 30000,
    waitUntil: 'domcontentloaded'
});
await page.waitForSelector('.main-content');

"Al optimizar Puppeteer, recuerde que solo hay un número limitado de formas de acelerar el rendimiento de inicio y cierre de Puppeteer. Lo más probable es que las mayores mejoras provengan de lograr que sus páginas de destino se rendericen más rápido."
– Jon Yongfook, fundador de Bannerbear [3]

Distribución de carga de proxies

Distribuya el tráfico entre varios proxies con Puppeteer Cluster:

const proxyCluster = {
    async distributeLoad(urls, proxyList) {
        const cluster = await Cluster.launch({
            concurrency: Cluster.CONCURRENCY_CONTEXT,
            maxConcurrency: 5
        });

        await cluster.task(async ({ page, data: url }) => {
            const proxy = proxyList.getNext();
            await page.authenticate(proxy);
            await page.goto(url);
        });
    }
};

Este enfoque equilibra el tráfico entre los proxies y complementa los métodos de rotación anteriores para evitar sobrecargar un único proxy.

Problemas frecuentes y soluciones

A continuación se presentan algunos desafíos comunes y cómo gestionarlos eficazmente:

• Latencia de red Utilice el siguiente código para gestionar los tiempos de espera y evitar retrasos innecesarios:

  const performRequest = async (page, url) => {
      try {
          await page.goto(url, {
              timeout: 30000,
              waitUntil: 'networkidle2'
          });
      } catch (error) {
          if (error.name === 'TimeoutError') {
              await page.evaluate(() => window.stop());
              return handleTimeout();
          }
          throw error;
      }
  };
  

• Limitación de frecuencia Detecte y responda a los límites de frecuencia con este fragmento:

  const checkRateLimit = async (response) => {
      if (response.status() === 429 || response.headers()['retry-after']) {
          await handleRateLimit(response.headers()['retry-after']);
      }
  };
  

• Fallos de autenticación Gestione los errores de autenticación del proxy reintentando con nuevas credenciales:

  const handleAuthError = async (response, page, proxy) => {
      if (response.status() === 407) {
          await retryWithNewCredentials(page, proxy);
          return true;
      }
      return false;
  };
  

"Al optimizar su script de Puppeteer, puede garantizar un funcionamiento fluido y eficiente con resultados precisos y consistentes."
– ScrapeOps [2]

Supervise los tiempos de respuesta y las tasas de éxito para garantizar que sus proxies sigan siendo eficientes y no sean detectados.

Conclusión

Métodos de configuración clave

Configurar Puppeteer con proxies implica algunos pasos importantes. Para proxies privados, utilice la función authenticate para proporcionar credenciales:

await page.authenticate({
    username: 'proxyUser',
    password: 'proxyPass'
});

Para asegurarse de que la página se cargue por completo, utilice la opción waitUntil (por ejemplo, 'networkidle2') y establezca un tiempo de espera (por ejemplo, 30 segundos):

await page.goto(url, {
    waitUntil: 'networkidle2',
    timeout: 30000
});

Estas configuraciones constituyen la base de una implementación de proxy fiable.

Mejores prácticas

Para mantener operaciones de proxy seguras y eficientes, siga estas estrategias:

Gestión de conexiones

• Ajuste los tiempos de espera según la velocidad del proxy.
• Gestione los errores de autenticación de forma eficaz.
• Supervise las métricas de rendimiento para identificar cuellos de botella.

Optimización de la seguridad

• Rote los agentes de usuario junto con los proxies para evitar la detección.
• Añada una capa de VPN para obtener protección adicional.
• Intercepte y filtre solicitudes innecesarias para ahorrar ancho de banda.

A continuación se presenta un resumen rápido de consideraciones importantes para la implementación de proxies: