Cambio dinamico de proxy: configuracion por contexto

Introduccion

Muchos flujos de trabajo de privacidad requieren mas de un unico proxy para toda una sesion de navegador. Es posible que necesites diferentes proxies para diferentes cuentas, regiones geograficas o dominios objetivo. La configuracion de proxy estatica, donde un solo proxy sirve todo el trafico durante la vida del navegador, es limitante en estos escenarios.

BotBrowser soporta el cambio dinamico de proxy a traves de las API de contexto de Playwright y Puppeteer. Cada contexto de navegador puede enrutar el trafico a traves de un proxy diferente con su propia identidad geografica, y puedes crear y cerrar contextos en tiempo de ejecucion sin reiniciar el navegador. Este articulo cubre la configuracion de proxy por contexto, estrategias de rotacion de proxy y configuraciones multi-proxy para flujos de trabajo complejos.

Impacto en la privacidad

Cuando multiples cuentas o identidades comparten un unico proxy, sus patrones de trafico quedan vinculados por direccion IP. Un sistema de rastreo que observa la misma IP accediendo a multiples cuentas en momentos similares puede correlacionar esas cuentas. Incluso si los perfiles de huella digital son diferentes, la identidad de red compartida crea una conexion.

La asignacion de proxy por contexto resuelve esto. Cada contexto se enruta a traves de un proxy distinto, de modo que el trafico de diferentes identidades nunca comparte una IP. Combinado con el aislamiento de huella digital por contexto de BotBrowser, cada contexto presenta una identidad completamente independiente: huella digital diferente, IP diferente, metadatos geograficos diferentes.

El cambio dinamico de proxy tambien es importante para flujos de trabajo que abarcan multiples regiones. Una identidad que necesita aparecer en EE.UU. para una tarea y en Alemania para otra puede cambiar de proxy entre tareas, con BotBrowser ajustando automaticamente la zona horaria, la configuracion regional y el idioma para que coincidan.

Contexto tecnico

Contextos de navegador y aislamiento de red

Un contexto de navegador en Playwright o Puppeteer es una sesion de navegacion aislada dentro de una unica instancia de navegador. Cada contexto tiene sus propias cookies, localStorage, sessionStorage y cache. Playwright extiende este aislamiento a la configuracion de red: cada contexto puede tener su propia configuracion de proxy.

Cuando creas un contexto con browser.newContext({ proxy: ... }), todo el trafico de ese contexto se enruta a traves del proxy especificado. Otros contextos en la misma instancia de navegador no se ven afectados. Este es un verdadero aislamiento de red a nivel de contexto.

Configuracion de proxy estatica vs. por contexto

La configuracion estatica establece un proxy al lanzar el navegador con --proxy-server. Todos los contextos en esa instancia de navegador comparten el mismo proxy:

chrome --bot-profile="/path/to/profile.enc" \
       --proxy-server=socks5://user:pass@proxy:1080

La configuracion por contexto establece proxies al crear contextos individuales:

const context = await browser.newContext({
  proxy: { server: 'socks5://proxy:1080', username: 'user', password: 'pass' },
});

Los proxies por contexto sobreescriben el proxy a nivel de navegador para ese contexto especifico. Si no se especifica un proxy a nivel de contexto, el contexto hereda el proxy a nivel de navegador.

Como BotBrowser extiende los proxies de contexto

Chromium estandar soporta proxies por contexto a traves de la API de Playwright, pero no deriva automaticamente la configuracion geografica por contexto. BotBrowser extiende este comportamiento: cuando se configura un proxy por contexto, BotBrowser auto-deriva la zona horaria, la configuracion regional y el idioma a partir de la IP del proxy para ese contexto especifico.

Esto significa que cada contexto obtiene una identidad geografica completa sin configuracion manual de cada parametro.

Enfoques comunes y sus limitaciones

Lanzar instancias de navegador separadas

El enfoque mas simple para configuraciones multi-proxy es lanzar una instancia de navegador separada por proxy:

# Instancia 1
chrome --bot-profile="/profiles/profile-a.enc" \
       --proxy-server=socks5://proxy-us:1080 \
       --user-data-dir="/tmp/session-1"

# Instancia 2
chrome --bot-profile="/profiles/profile-b.enc" \
       --proxy-server=socks5://proxy-de:1080 \
       --user-data-dir="/tmp/session-2"

Esto funciona pero consume mas memoria y CPU. Cada instancia de navegador tiene sus propios procesos de renderizado, proceso GPU y procesos de utilidades. Ejecutar 10 instancias usa significativamente mas recursos que ejecutar 10 contextos dentro de una sola instancia.

Rotacion de proxy a nivel de framework

Algunos frameworks proporcionan rotacion de proxy a traves de page.route() o API de interceptores. Estos enfoques modifican el trafico a nivel de JavaScript/CDP, lo que significa:

• La conexion inicial puede usar el proxy incorrecto antes de que el interceptor se active
• Las conexiones WebSocket pueden no estar cubiertas
• La precarga de DNS puede filtrarse a traves de la ruta del proxy original

Los proxies por contexto configurados a nivel del motor del navegador no tienen estos problemas de sincronizacion.

Servidores de middleware de proxy

Ejecutar un middleware de proxy local que maneje la rotacion agrega complejidad de infraestructura y un unico punto de falla. El navegador se conecta al middleware local, que reenvia a diferentes proxies upstream. Esto funciona pero introduce latencia y requiere mantener software adicional.

Enfoque de BotBrowser

Proxy por contexto con autodeteccion

El soporte de proxy por contexto de BotBrowser (ENT Tier1) proporciona identidad geografica completa por contexto:

const { chromium } = require('playwright-core');

const browser = await chromium.launch({
  executablePath: '/path/to/botbrowser/chrome',
  args: [
    '--bot-profile=/path/to/profile.enc',
  ],
  headless: true,
});

// Contexto EE.UU. - BotBrowser auto-deriva configuracion geografica de EE.UU.
const usContext = await browser.newContext({
  proxy: { server: 'socks5://us-proxy:1080', username: 'user', password: 'pass' },
});

// Contexto Alemania - BotBrowser auto-deriva configuracion geografica alemana
const deContext = await browser.newContext({
  proxy: { server: 'socks5://de-proxy:1080', username: 'user', password: 'pass' },
});

Cada contexto recibe automaticamente configuracion de zona horaria, configuracion regional e idioma que coinciden con la ubicacion geografica de su proxy.

Sobreescrituras geograficas manuales por contexto

Cuando necesitas configuracion geografica especifica para un contexto, combina el proxy con las opciones de configuracion regional y zona horaria de Playwright:

async function createGeoContext(browser, config) {
  return browser.newContext({
    proxy: {
      server: config.proxyUrl,
      username: config.user,
      password: config.pass,
    },
    locale: config.locale,
    timezoneId: config.timezone,
  });
}

const usCtx = await createGeoContext(browser, {
  proxyUrl: 'socks5://us-east:1080',
  user: 'u', pass: 'p',
  locale: 'en-US',
  timezone: 'America/New_York',
});

const jpCtx = await createGeoContext(browser, {
  proxyUrl: 'socks5://jp-tokyo:1080',
  user: 'u', pass: 'p',
  locale: 'ja-JP',
  timezone: 'Asia/Tokyo',
});

Rotacion de proxy entre solicitudes

Para flujos de trabajo que necesitan diversidad de IP entre navegaciones, crea un nuevo contexto por rotacion:

const proxyPool = [
  { server: 'socks5://proxy-1:1080', username: 'user', password: 'pass' },
  { server: 'socks5://proxy-2:1080', username: 'user', password: 'pass' },
  { server: 'socks5://proxy-3:1080', username: 'user', password: 'pass' },
];

async function navigateWithRotation(browser, url, index) {
  const proxy = proxyPool[index % proxyPool.length];
  const context = await browser.newContext({ proxy });
  const page = await context.newPage();

  try {
    await page.goto(url);
    const content = await page.content();
    return content;
  } finally {
    await context.close();
  }
}

// Cada llamada usa un proxy diferente
for (let i = 0; i < 10; i++) {
  await navigateWithRotation(browser, 'https://example.com', i);
}

Cerrar el contexto despues de cada uso asegura un estado limpio: sin cookies, cache ni reutilizacion de conexiones entre rotaciones.

Asignacion de proxy persistente por sesion

Para flujos de trabajo donde cada cuenta necesita un proxy persistente a traves de multiples cargas de pagina, mantien el contexto abierto:

const accounts = [
  { name: 'account-a', proxy: 'socks5://proxy-us:1080' },
  { name: 'account-b', proxy: 'socks5://proxy-uk:1080' },
  { name: 'account-c', proxy: 'socks5://proxy-de:1080' },
];

const contexts = {};

for (const account of accounts) {
  contexts[account.name] = await browser.newContext({
    proxy: { server: account.proxy, username: 'user', password: 'pass' },
  });
}

// Cada cuenta usa su contexto y proxy dedicado
const pageA = await contexts['account-a'].newPage();
await pageA.goto('https://example.com/login');
// ... iniciar sesion y realizar tareas con el proxy de la cuenta A

const pageB = await contexts['account-b'].newPage();
await pageB.goto('https://example.com/login');
// ... iniciar sesion y realizar tareas con el proxy de la cuenta B

Configuracion y uso

Proxy predeterminado a nivel CLI con sobreescritura por contexto

Establece un proxy predeterminado a nivel CLI, luego sobreescribe por contexto:

const browser = await chromium.launch({
  executablePath: '/path/to/botbrowser/chrome',
  args: [
    '--bot-profile=/path/to/profile.enc',
    // Proxy predeterminado para contextos que no especifiquen uno
    '--proxy-server=socks5://default-proxy:1080',
  ],
  headless: true,
});

// Este contexto usa el proxy predeterminado
const defaultCtx = await browser.newContext();

// Este contexto sobreescribe con un proxy especifico
const specialCtx = await browser.newContext({
  proxy: { server: 'socks5://special-proxy:1080', username: 'u', password: 'p' },
});

Combinacion con banderas CLI de BotBrowser

Para la mayor consistencia geografica, combina los proxies por contexto con las banderas a nivel CLI de BotBrowser:

const browser = await chromium.launch({
  executablePath: '/path/to/botbrowser/chrome',
  args: [
    '--bot-profile=/path/to/profile.enc',
    '--bot-local-dns',
    '--bot-webrtc-ice=google',
  ],
  headless: true,
});

Las banderas --bot-local-dns y --bot-webrtc-ice se aplican globalmente y protegen todos los contextos de filtraciones de DNS y WebRTC.

Enfoque multi-instancia con Puppeteer

Puppeteer no soporta proxies por contexto de la misma manera que Playwright. Para Puppeteer, usa instancias de navegador separadas:

const puppeteer = require('puppeteer-core');

async function createInstance(profile, proxy, timezone, locale) {
  return puppeteer.launch({
    executablePath: '/path/to/botbrowser/chrome',
    args: [
      `--bot-profile=${profile}`,
      `--proxy-server=${proxy}`,
      `--bot-config-timezone=${timezone}`,
      `--bot-config-locale=${locale}`,
      `--user-data-dir=${'/tmp/session-' + Math.random().toString(36).slice(2)}`,
    ],
    headless: true,
    defaultViewport: null,
  });
}

const usBrowser = await createInstance(
  '/profiles/us.enc', 'socks5://us-proxy:1080',
  'America/New_York', 'en-US'
);

const deBrowser = await createInstance(
  '/profiles/de.enc', 'socks5://de-proxy:1080',
  'Europe/Berlin', 'de-DE'
);

Verificacion

Despues de configurar el cambio dinamico de proxy, verifica cada contexto de manera independiente:

async function verifyContext(context, expectedCountry) {
  const page = await context.newPage();

  // Verificar IP
  await page.goto('https://httpbin.org/ip');
  const ip = await page.textContent('body');
  console.log(`${expectedCountry} IP:`, ip);

  // Verificar zona horaria
  const tz = await page.evaluate(() =>
    Intl.DateTimeFormat().resolvedOptions().timeZone
  );
  console.log(`${expectedCountry} Zona horaria:`, tz);

  // Verificar configuracion regional
  const locale = await page.evaluate(() =>
    Intl.NumberFormat().resolvedOptions().locale
  );
  console.log(`${expectedCountry} Configuracion regional:`, locale);

  await page.close();
}

await verifyContext(usContext, 'US');
await verifyContext(deContext, 'DE');

Confirma que cada contexto muestra una IP, zona horaria y configuracion regional diferentes. Verifica que ningun trafico de un contexto se filtre a otro.

Mejores practicas

1. Cierra los contextos cuando termines. Los contextos abiertos consumen memoria. Cierralos despues de usar para liberar recursos.

2. Usa Playwright para proxies por contexto. El soporte nativo de proxy por contexto de Playwright es mas eficiente que ejecutar instancias de navegador separadas.

3. Haz coincidir la geografia del proxy con la configuracion regional. Siempre alinea la zona horaria, la configuracion regional y el idioma con la ubicacion del proxy. BotBrowser maneja esto automaticamente cuando usa proxies por contexto.

4. Establece --bot-local-dns y --bot-webrtc-ice globalmente. Estas banderas protegen todos los contextos de filtraciones de red independientemente de la configuracion del proxy.

5. Usa diferentes perfiles de huella digital para diferentes cuentas. Aunque los proxies por contexto aislan la identidad de red, usar diferentes perfiles por cuenta proporciona tambien aislamiento de huella digital.

6. No uses page.authenticate() con BotBrowser. La API page.authenticate() puede interferir con la autodeteccion geografica de BotBrowser. Usa credenciales integradas en la URL del proxy en su lugar.

Preguntas frecuentes

¿Puedo cambiar el proxy de un contexto despues de crearlo? No. La configuracion del proxy se fija cuando se crea el contexto. Para cambiar de proxy, cierra el contexto actual y crea uno nuevo.

¿Cuantos contextos pueden ejecutarse simultaneamente? No hay un limite estricto. Cada contexto consume memoria proporcional a sus paginas abiertas y recursos en cache. En la practica, cientos de contextos pueden ejecutarse dentro de una sola instancia de navegador en una maquina con suficiente RAM.

¿Los proxies por contexto soportan SOCKS5H? Si. Todos los protocolos de proxy soportados por --proxy-server tambien son soportados en la configuracion de proxy por contexto.

¿BotBrowser autodetecta la geografia para proxies por contexto? Si (ENT Tier1). Cuando estableces un proxy por contexto, BotBrowser detecta la IP del proxy y deriva la zona horaria, la configuracion regional y el idioma automaticamente para ese contexto.

¿Puedo mezclar proxies estaticos y por contexto? Si. Establece un proxy predeterminado con --proxy-server al lanzar. Los contextos que especifiquen su propio proxy sobreescriben el predeterminado. Los contextos sin configuracion de proxy heredan el predeterminado a nivel de navegador.

¿Que sucede con las cookies cuando cierro un contexto? Todas las cookies, localStorage y cache de ese contexto se descartan. Si necesitas persistencia de cookies, exporta las cookies antes de cerrar el contexto.

¿El cambio de proxy por contexto es soportado en Puppeteer? Puppeteer tiene soporte limitado de proxy por contexto. Para control completo de proxy por contexto, usa Playwright. Para Puppeteer, lanza instancias de navegador separadas con diferentes valores de --proxy-server.

Resumen

El cambio dinamico de proxy permite flujos de trabajo complejos con multiples identidades dentro de una sola instancia de navegador. El soporte de proxy por contexto de BotBrowser, combinado con la deteccion geografica automatica, proporciona a cada contexto una identidad de red completa: IP unica, zona horaria coincidente, configuracion regional apropiada y configuracion de idioma consistente.

Para los fundamentos de proxy, consulta Configuracion de proxy. Para prevenir filtraciones de red en todos los contextos, combina con Prevencion de filtraciones DNS y Prevencion de filtraciones WebRTC. Para aislamiento completo de identidad, consulta Aislamiento de navegador para multiples cuentas.