Configuración de proxy en Puppeteer: técnicas de autenticación, rotación y omisión

Los apoderados son esenciales para Titiritero Automatización. Ocultan tu IP, evitan restricciones geográficas y ayudan a evitar baneos. Esto es lo que aprenderás sobre el uso de proxies en Titiritero:

1. Configurar servidores proxy:Agregue proxies a su navegador y autentíquelos con facilidad.
2. Rotar poderes:Distribuya las solicitudes entre múltiples IP para evitar la detección.
3. Manejar errores:Reintente solicitudes, administre bloqueos y cambie servidores proxy cuando sea necesario.
4. Optimizar la velocidad:Bloquee recursos innecesarios y rote agentes de usuario para un raspado más rápido y sigiloso.

Comparación rápida de los tipos de proxy

Tipo de proxy	Velocidad	anonimato	Costo	La mejor opción para
Datacenter	Rápido	Baja	Los Mejores	Raspado de gran volumen
Residencial	Moderado	Alta	Costoso	Tareas sensibles o geoespecíficas
Móvil	Lenta	Muy Alta	Muy caro	Verificación de anuncios, CAPTCHAs

Titiritero Integración de proxy con Datos brillantes - Tutorial completo 2024

Configuración básica de proxy

Configurar un proxy es fundamental para optimizar la automatización de Puppeteer. Aquí te explicamos cómo empezar.

Agregar un servidor proxy

Puedes configurar un servidor proxy durante el inicio del navegador en Puppeteer de la siguiente manera:

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 con un proxy:

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

A continuación, querrás proteger tu conexión configurando la autenticación de proxy.

Pasos de 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 se muestra una comparación rápida de diferentes métodos de autenticación:

método de autentificación	Mejor caso de uso	Complejidad de implementación
page.authenticate()	Autorización de proxy estándar	Baja
proxy-chain PARA DOS	Enrutamiento avanzado	Mediana
Proxy-Authorization encabezamiento	Sitios que solo admiten HTTP	Alta

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

Prueba de la configuración del proxy

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

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

Aquí tienes un ejemplo de script para probar tu 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 su configuración de proxy esté lista para usarse en sus tareas de automatización.

Métodos de rotación de proxy

Administrar la rotación de proxy es esencial para evitar prohibiciones de IP y evitar limitaciones de velocidad al extraer o automatizar tareas en línea.

Creación de una lista de proxy

Para empezar, cree una lista de servidores proxy que puedan rotarse eficientemente. A continuación, se muestra un ejemplo de cómo configurar y usar un grupo de servidores proxy:

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 servidores proxy, es importante comprender los diferentes tipos de servidores proxy y sus ventajas y desventajas:

Tipo de proxy	Tiempo de Respuesta	Tasa de éxito	Rango de costo
Datacenter	100-300ms	85-95%	$0.50-$2/IP
Residencial	500-1000ms	90-98%	$2-$8/IP
Móvil	800-1500ms	95-99%	$5-$15/IP

Cada tipo tiene sus fortalezas y debilidades, así que elija según sus necesidades específicas, como velocidad, confiabilidad o presupuesto.

Cambio de servidores proxy 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 de rotación de apoderados

A continuación se presentan algunas prácticas clave para mejorar su estrategia de rotación de proxy:

1. Estrategia de tiempo

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 con elegancia cambiando a uno nuevo 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 solicitudes relacionadas:

const sessionMap = new Map();

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

Con estas estrategias, puedes administrar servidores proxy de manera eficiente y prepararte para desafíos más avanzados, como el manejo de bloqueos, CAPTCHA y otros obstáculos.

sbb-itb-23997f1

Técnicas avanzadas de proxy

Proxies residenciales frente a centros de datos

Seleccionar el proxy adecuado es fundamental al trabajar con la automatización de Puppeteer. Aquí tienes una comparación para ayudarte a decidir:

Feature	Proxies residenciales	Proxies de centros de datos
Fuente	Proporcionado por los ISP a propiedades residenciales	Procedente de centros de datos
Velocidad	Más lento debido al enrutamiento del ISP	Más rápido con infraestructura dedicada
Riesgo de detección	Inferior: imita el tráfico de usuarios reales	Más alto: más fácil de detectar
Costo	Más caro	Económico
Cobertura geografica	Amplio, en múltiples ubicaciones	A menudo limitado
Mejores casos de uso	Tareas de alto anonimato, extracción de datos sensibles y verificación de anuncios	Minería de datos de gran volumen, procesamiento por lotes

Los proxies residenciales son una opción sólida para tareas que exigen un alto anonimato, ya que se asemejan mucho a la actividad real del usuario. ^{[ 1 ]}.

Manejo de bloques y CAPTCHA

Para solucionar los bloqueos de sitios web y los problemas de CAPTCHA, utilice mecanismos de rotación de proxy 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, volver a intentarlo con un nuevo proxy puede mantener la 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 de trabajo, incluso cuando surgen desafíos.

Gestión de errores de proxy

Gestionar eficazmente los errores de proxy requiere ajustes de tiempo de espera, comprobaciones de validación y servidores proxy 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 pautas para una mejor gestión de errores:

• Establezca tiempos de espera de conexión para evitar esperas prolongadas.
• Supervisar continuamente el rendimiento del proxy.
• Mantenga listo un grupo de servidores proxy de respaldo.

Configurar correctamente su navegador también juega un papel importante para garantizar un rendimiento perfecto:

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

Por último, valide siempre sus servidores proxy para asegurarse de que funcionen:

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 sobre el rendimiento del proxy

¿Quieres sacarle el máximo partido a Puppeteer? Estos consejos te ayudarán a optimizar la configuración de tu proxy y a 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();
    }
});

Vincular 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 maneras de acelerar el inicio y el apagado de Puppeteer. Lo más probable es que las mayores ganancias provengan de lograr que sus páginas de destino se visualicen más rápido.
– Jon Yongfook, Fundador, oso estandarte ^{[ 3 ]}

Distribución de carga de proxy

Distribuya el tráfico entre varios servidores proxy mediante 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 servidores proxy y complementa los métodos de rotación anteriores para evitar la sobrecarga de un solo servidor proxy.

Problemas y soluciones habituales

A continuación se presentan algunos desafíos comunes y cómo afrontarlos de manera efectiva:

• Latencia de conexion Utilice el siguiente código para administrar 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 la velocidad Detecte y responda a los límites de velocidad con este fragmento:

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

• Errores de autenticación Maneje los errores de autenticación de proxy volviendo a intentarlo 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.
– operaciones de raspado ^{[ 2 ]}

Esté atento a los tiempos de respuesta y las tasas de éxito para garantizar que sus servidores proxy sigan siendo eficientes y no sean detectados.

Conclusión

Métodos de configuración de claves

Configurar Puppeteer con servidores proxy implica algunos pasos importantes. Para servidores proxy privados, use el authenticate Función para proporcionar credenciales:

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

Para garantizar que la página se cargue completamente, utilice el waitUntil opción (p. ej., 'networkidle2') y establecer un tiempo de espera (por ejemplo, 30 segundos):

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

Estas configuraciones forman la base de una configuración de proxy confiable.

BUENAS PRÁCTICAS

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

Gestión de la conexión

• Ajuste los tiempos de espera según la velocidad del proxy.
• Manejar errores de autenticación de manera efectiva.
• Supervisar las métricas de rendimiento para identificar cuellos de botella.

Optimización de seguridad

• Rote los agentes de usuario junto con los servidores proxy para evitar la detección.
• Agregue una capa VPN para protección adicional.
• Interceptar y filtrar solicitudes innecesarias para ahorrar ancho de banda.

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

Aspecto	Implementación	Beneficio
Autenticación	Use authenticate función	Asegura el acceso a servidores proxy privados
Gestión de carga	Habilitar la intercepción de solicitudes	Reduce el ancho de banda y acelera la carga.
Gestión de errores	Implementar try-catch bloques	Gestiona los problemas de conexión con elegancia
Protección de Identidad	Rotar servidores proxy y agentes de usuario	Mejora las tasas de éxito y evita bloqueos.

Artículos relacionados con

• Cómo funciona la detección de navegadores sin interfaz gráfica y cómo evitarla
• Instalación y configuración de Puppeteer: Solución de problemas comunes de dependencias y Chromium
• Interceptar y modificar solicitudes de red en Puppeteer: una guía práctica
• Gestión de agentes de usuario en Puppeteer para la emulación de dispositivos