Bezgłowe przeglądarki + Proxies: Kompletny przewodnik konfiguracji dla Marionetki i Playwright

Dlaczego przeglądarki bez głowy potrzebują profili

Bezgłowe przeglądarki - instancje przeglądarki uruchomione bez widocznego GUI - są niezbędne do skrobania stron JavaScript- heavy. Jednak uruchomienie wielu sesji przeglądarki bez głowy z jednego adresu IP jest oczywistym sygnałem automatyzacji. Łączenie przeglądarek bez głowy z rotacją proxy rozwiązuje to poprzez dystrybucję żądań w tysiącach domowych IP.

Niniejszy przewodnik obejmuje konfigurację proxy Puppeteera i Playwrighta, wtyczki stealth i strategie rotacji. Aby dowiedzieć się, jak działa wykrywanie, zobacz nasz przewodnik po systemach wykrywania robotów.

Zestaw Proxy Puppeteer

Podstawowa konfiguracja

// Puppeteer: Basic proxy configuration
const puppeteer = require('puppeteer');
const browser = await puppeteer.launch({
  headless: 'new',
  args: [
    '--proxy-server=http://gate.proxyhat.com:8080',
    '--no-sandbox',
    '--disable-setuid-sandbox'
  ]
});
const page = await browser.newPage();
// Authenticate with the proxy
await page.authenticate({
  username: 'USERNAME',
  password: 'PASSWORD'
});
await page.goto('https://example.com', {
  waitUntil: 'networkidle2',
  timeout: 30000
});
const content = await page.content();
console.log(content.substring(0, 200));
await browser.close();

SOCKS5 z Marionetką

// Puppeteer: SOCKS5 proxy configuration
const browser = await puppeteer.launch({
  headless: 'new',
  args: [
    '--proxy-server=socks5://gate.proxyhat.com:1080'
  ]
});
const page = await browser.newPage();
await page.authenticate({
  username: 'USERNAME',
  password: 'PASSWORD'
});

Wtyczka Stealth Puppeteer

Domyślna konfiguracja Puppeteer eksponuje dziesiątki znaczników automatyki, które wykrywają systemy anty-bot. W puppeteer-extra-plugin-stealth wtyczki łata te markery automatycznie.

// Install: npm install puppeteer-extra puppeteer-extra-plugin-stealth
const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');
// Apply stealth plugin
puppeteer.use(StealthPlugin());
const browser = await puppeteer.launch({
  headless: 'new',
  args: [
    '--proxy-server=http://gate.proxyhat.com:8080',
    '--disable-blink-features=AutomationControlled',
    '--window-size=1920,1080',
    '--disable-dev-shm-usage'
  ]
});
const page = await browser.newPage();
await page.authenticate({
  username: 'USERNAME',
  password: 'PASSWORD'
});
// Set realistic viewport
await page.setViewport({ width: 1920, height: 1080 });
// Set extra headers for consistency
await page.setExtraHTTPHeaders({
  'Accept-Language': 'en-US,en;q=0.9'
});
await page.goto('https://example.com');

Łaty wtyczki stealth:

• navigator.webdriver - ustawione na nieokreślone zamiast true
• chrome.runtime - dodaje brakujące obiekty specyficzne dla ChromeName
• WebGL sprzedawca / renderer - realistyczne struny GPU
• Wtyczka i tablice zezwoleń - dopasować prawdziwy Chrome
• Spójność języka i platformy

Aby lepiej zrozumieć, co te poprawki adresują, zobacz nasz artykuł na temat pobieranie odcisków palców przez przeglądarkę.

Ustawienia Proxy Playwright

Playwright zapewnia bardziej elegancką konfigurację proxy niż Puppeteer, wspierając proxy kontekstowe i emulację wbudowanego urządzenia.

Podstawowa konfiguracja

// Playwright: Basic proxy setup
const { chromium } = require('playwright');
const browser = await chromium.launch({
  proxy: {
    server: 'http://gate.proxyhat.com:8080',
    username: 'USERNAME',
    password: 'PASSWORD'
  }
});
const context = await browser.newContext();
const page = await context.newPage();
await page.goto('https://example.com');
const title = await page.title();
console.log(`Page title: ${title}`);
await browser.close();

Proxy kontekstowe (różne IP na kartę)

// Playwright: Different proxy per context
const { chromium } = require('playwright');
const browser = await chromium.launch();
// Context 1: US proxy session
const ctx1 = await browser.newContext({
  proxy: {
    server: 'http://gate.proxyhat.com:8080',
    username: 'USERNAME-country-us-session-abc1',
    password: 'PASSWORD'
  },
  locale: 'en-US',
  timezoneId: 'America/New_York'
});
// Context 2: UK proxy session
const ctx2 = await browser.newContext({
  proxy: {
    server: 'http://gate.proxyhat.com:8080',
    username: 'USERNAME-country-gb-session-abc2',
    password: 'PASSWORD'
  },
  locale: 'en-GB',
  timezoneId: 'Europe/London'
});
const page1 = await ctx1.newPage();
const page2 = await ctx2.newPage();
// Each page uses a different IP and locale
await page1.goto('https://example.com');
await page2.goto('https://example.com');

Emulacja urządzenia z proxy

// Playwright: Realistic device emulation + proxy
const { chromium, devices } = require('playwright');
const browser = await chromium.launch({
  proxy: {
    server: 'http://gate.proxyhat.com:8080',
    username: 'USERNAME',
    password: 'PASSWORD'
  }
});
// Emulate a specific device with matching settings
const context = await browser.newContext({
  ...devices['Desktop Chrome'],
  locale: 'en-US',
  timezoneId: 'America/Chicago',
  geolocation: { latitude: 41.8781, longitude: -87.6298 },
  permissions: ['geolocation'],
  colorScheme: 'light'
});
const page = await context.newPage();
await page.goto('https://example.com');

Rotacja Proxy z przeglądarkami bez głowy

Strategia 1: Nowy kontekst na wniosek

Utwórz nowy kontekst przeglądarki dla każdego adresu URL. Daje to świeże IP i czyste pliki cookie na życzenie.

// Playwright: Rotate proxy per request via new contexts
async function scrapeWithRotation(urls) {
  const browser = await chromium.launch();
  const results = [];
  for (const url of urls) {
    const sessionId = `sess-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
    const context = await browser.newContext({
      proxy: {
        server: 'http://gate.proxyhat.com:8080',
        username: `USERNAME-session-${sessionId}`,
        password: 'PASSWORD'
      }
    });
    const page = await context.newPage();
    try {
      await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 30000 });
      const data = await page.evaluate(() => document.title);
      results.push({ url, data });
    } catch (error) {
      console.error(`Failed: ${url} — ${error.message}`);
    } finally {
      await context.close();
    }
    // Natural delay between requests
    await new Promise(r => setTimeout(r, 1000 + Math.random() * 2000));
  }
  await browser.close();
  return results;
}

Strategia 2: Namacalne sesje dla wielostronnych przepływów

Używaj lepkich sesji, gdy musisz utrzymać ten sam adres IP na wielu stronach (pagination, login flows).

// Playwright: Sticky session for multi-page scraping
async function scrapeWithStickySession(baseUrl, pageCount) {
  const sessionId = `sticky-${Date.now()}`;
  const browser = await chromium.launch({
    proxy: {
      server: 'http://gate.proxyhat.com:8080',
      username: `USERNAME-session-${sessionId}`,
      password: 'PASSWORD'
    }
  });
  const context = await browser.newContext();
  const page = await context.newPage();
  const results = [];
  for (let i = 1; i <= pageCount; i++) {
    await page.goto(`${baseUrl}?page=${i}`, { waitUntil: 'networkidle' });
    const items = await page.$$eval('.item', els =>
      els.map(el => el.textContent.trim())
    );
    results.push(...items);
    // Natural delay between pages
    await new Promise(r => setTimeout(r, 1500 + Math.random() * 1500));
  }
  await browser.close();
  return results;
}

Strategia 3: Równoczesne rozdrabnianie z basenem

// Playwright: Concurrent scraping with proxy pool
async function concurrentScrape(urls, concurrency = 5) {
  const browser = await chromium.launch();
  const results = [];
  // Process URLs in batches
  for (let i = 0; i < urls.length; i += concurrency) {
    const batch = urls.slice(i, i + concurrency);
    const promises = batch.map(async (url) => {
      const sessionId = `conc-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
      const context = await browser.newContext({
        proxy: {
          server: 'http://gate.proxyhat.com:8080',
          username: `USERNAME-session-${sessionId}`,
          password: 'PASSWORD'
        }
      });
      const page = await context.newPage();
      try {
        await page.goto(url, { timeout: 30000, waitUntil: 'domcontentloaded' });
        return { url, title: await page.title(), status: 'ok' };
      } catch (e) {
        return { url, error: e.message, status: 'error' };
      } finally {
        await context.close();
      }
    });
    const batchResults = await Promise.all(promises);
    results.push(...batchResults);
    // Delay between batches
    await new Promise(r => setTimeout(r, 2000));
  }
  await browser.close();
  return results;
}

Puppeteer z Python (alternatywa Pyppeteer)

Dla programistów Pythona, playwright dla Python zapewnia te same możliwości z czystszą składnią.

# Python: Playwright with proxy and stealth settings
# pip install playwright
# playwright install chromium
from playwright.async_api import async_playwright
import asyncio
async def scrape_with_proxy():
    async with async_playwright() as p:
        browser = await p.chromium.launch(
            proxy={
                "server": "http://gate.proxyhat.com:8080",
                "username": "USERNAME",
                "password": "PASSWORD"
            }
        )
        context = await browser.new_context(
            viewport={"width": 1920, "height": 1080},
            locale="en-US",
            timezone_id="America/New_York",
            user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
        )
        page = await context.new_page()
        await page.goto("https://example.com")
        title = await page.title()
        print(f"Title: {title}")
        await browser.close()
asyncio.run(scrape_with_proxy())

Optymalizacja zasobów

Bezgłowe przeglądarki zużywają znaczną pamięć i procesor. Optymalizacja obciążeń produkcyjnych:

Blokuj niepotrzebne zasoby

// Playwright: Block images, fonts, and CSS to save bandwidth
const context = await browser.newContext({
  proxy: {
    server: 'http://gate.proxyhat.com:8080',
    username: 'USERNAME',
    password: 'PASSWORD'
  }
});
const page = await context.newPage();
// Block non-essential resources
await page.route('**/*.{png,jpg,jpeg,gif,svg,webp,woff,woff2,ttf,css}', route =>
  route.abort()
);
// Block tracking and analytics
await page.route('**/{google-analytics,gtag,facebook}**', route =>
  route.abort()
);
await page.goto('https://example.com');

Zarządzanie pamięcią

• Zamknij kontekst po użyciu: Każdy otwarty kontekst zużywa 50- 150MB. Zawsze zamykaj kontekst, kiedy to robisz.
• Limit kontekstów równoległych: Zachowaj 3- 10 kontekstów na instancję przeglądarki w oparciu o dostępny RAM.
• Restart przeglądarki okresowo: Po 100- 200 cyklach kontekstowych, ponownie uruchomić przeglądarkę, aby zapobiec wyciekom pamięci.
• Używać bez głowy: 'nowy' (Puppeteer): Nowy tryb bez głowy używa mniej pamięci niż poprzedni.

Zarządzanie wspólnymi kwestiami

Proxy Authentication Assessments

// Handle proxy auth errors gracefully
try {
  const response = await page.goto(url, { timeout: 30000 });
  if (response.status() === 407) {
    console.error('Proxy authentication failed — check credentials');
  }
} catch (error) {
  if (error.message.includes('net::ERR_PROXY_CONNECTION_FAILED')) {
    console.error('Proxy connection failed — check proxy server availability');
  }
}

Zarządzanie czasem

// Retry with exponential backoff
async function gotoWithRetry(page, url, maxRetries = 3) {
  for (let attempt = 1; attempt <= maxRetries; attempt++) {
    try {
      return await page.goto(url, {
        waitUntil: 'domcontentloaded',
        timeout: 30000
      });
    } catch (error) {
      if (attempt === maxRetries) throw error;
      const delay = 1000 * Math.pow(2, attempt) + Math.random() * 1000;
      console.log(`Retry ${attempt}/${maxRetries} after ${delay}ms`);
      await new Promise(r => setTimeout(r, delay));
    }
  }
}

Lista kontrolna najlepszych praktyk

Dla większości zadań scrating, Playwright jest zalecanym wyborem nad Puppeteer ze względu na jego superior support proxy (per- context), built- in emulation urządzeń, i multi- wsparcia przeglądarki. Połącz to z ProxyHat 's residential proxy dla najlepszych wyników.

Konfigurowanie proxy dla danego języka bez przeglądarek bez głowy, zobacz nasze przewodniki dla Python, Node.jsoraz Idź.Dla kompleksowych strategii antydetekcji, przeczytaj nasze prowadnica redukcji wykrywaniaZawsze postępuj zgodnie z etycznymi praktykami i szacunkiem polityki dostępu do stron internetowych.

Często zadawane pytania