Веб-скрапинг 10 мин чтения

Стратегии ротации прокси для масштабного скрапинга

Освойте четыре ключевые стратегии ротации прокси: на каждый запрос, липкие сессии по времени, по сбоям и гео-распределённую. Примеры кода на Python, Node.js и Go.

ProxyHat Team
Стратегии ротации прокси для масштабного скрапинга

Почему ротация прокси необходима для масштабного скрапинга

Когда вы масштабируетесь от сотен до миллионов запросов, один IP-адрес прокси становится уязвимостью. Веб-сайты отслеживают паттерны запросов по IP и ограничивают или блокируют адреса, превышающие нормальное поведение пользователя. Ротация прокси распределяет запросы между множеством IP, чтобы ни один адрес не накопил достаточно активности для срабатывания детекции.

Разница между наивным подходом к ротации и продуманной стратегией может означать разницу между 95% и 40% успешных запросов. Это руководство охватывает четыре основные стратегии ротации, когда использовать каждую и как реализовать их с рабочими примерами кода.

Эта статья — часть нашего кластера Полное руководство по прокси для веб-скрапинга. Начните оттуда, если вам нужны базовые концепции прокси.

Стратегия 1: Ротация на каждый запрос

Простейший подход: каждый запрос получает новый IP. Идеален для бессостоятельного сбора данных, где каждый запрос независим — поиск цен, запросы к SERP, получение страниц товаров.

Когда использовать

  • Скрапинг больших каталогов, где каждый URL независим
  • Мониторинг SERP по множеству ключевых слов
  • Любые задачи, не требующие cookies или состояния сессии

Реализация на Python

import requests
PROXY = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
def fetch_with_rotation(urls: list[str]) -> list[str]:
    """Each request automatically gets a fresh IP via the rotating gateway."""
    results = []
    session = requests.Session()
    session.proxies = {"http": PROXY, "https": PROXY}
    for url in urls:
        try:
            resp = session.get(url, timeout=30)
            resp.raise_for_status()
            results.append(resp.text)
        except requests.RequestException as e:
            print(f"Failed {url}: {e}")
            results.append(None)
    return results
# Each request through gate.proxyhat.com uses a different IP
pages = fetch_with_rotation([
    "https://example.com/product/1",
    "https://example.com/product/2",
    "https://example.com/product/3",
])

Реализация на Node.js

const HttpsProxyAgent = require('https-proxy-agent');
const fetch = require('node-fetch');
const agent = new HttpsProxyAgent('http://USERNAME:PASSWORD@gate.proxyhat.com:8080');
async function fetchWithRotation(urls) {
  const results = [];
  for (const url of urls) {
    try {
      const res = await fetch(url, { agent, timeout: 30000 });
      results.push(await res.text());
    } catch (err) {
      console.error(`Failed ${url}: ${err.message}`);
      results.push(null);
    }
  }
  return results;
}

Реализация на Go

package main
import (
    "fmt"
    "io"
    "net/http"
    "net/url"
    "time"
)
func fetchWithRotation(urls []string) []string {
    proxyURL, _ := url.Parse("http://USERNAME:PASSWORD@gate.proxyhat.com:8080")
    client := &http.Client{
        Transport: &http.Transport{Proxy: http.ProxyURL(proxyURL)},
        Timeout:   30 * time.Second,
    }
    results := make([]string, len(urls))
    for i, u := range urls {
        resp, err := client.Get(u)
        if err != nil {
            fmt.Printf("Failed %s: %v\n", u, err)
            continue
        }
        body, _ := io.ReadAll(resp.Body)
        resp.Body.Close()
        results[i] = string(body)
    }
    return results
}

Стратегия 2: Ротация по времени (липкие сессии)

Некоторые задачи скрапинга требуют одного IP для серии связанных запросов — навигация по пагинированному списку, прохождение многоступенчатого оформления заказа или поддержание авторизованной сессии. Ротация по времени (или липкие сессии) сохраняет тот же IP на определённое время, обычно 1-30 минут.

Когда использовать

  • Пагинированный обход (страница 1, 2, 3... результатов)
  • Задачи, требующие cookies или сохранения сессии
  • Имитация реалистичных паттернов просмотра

Паттерн реализации

В ProxyHat липкие сессии управляются через параметр сессии в ваших учётных данных. Каждый уникальный ID сессии сохраняет тот же IP на настроенное время:

import requests
import uuid
def create_sticky_session(duration_label: str = "10m"):
    """Create a session that maintains the same IP."""
    session_id = uuid.uuid4().hex[:8]
    proxy = f"http://USERNAME-session-{session_id}:PASSWORD@gate.proxyhat.com:8080"
    session = requests.Session()
    session.proxies = {"http": proxy, "https": proxy}
    return session
# All requests through this session use the same IP
session = create_sticky_session()
page1 = session.get("https://example.com/listings?page=1")
page2 = session.get("https://example.com/listings?page=2")
page3 = session.get("https://example.com/listings?page=3")

Липкие сессии на Node.js

const HttpsProxyAgent = require('https-proxy-agent');
const fetch = require('node-fetch');
const crypto = require('crypto');
function createStickyAgent() {
  const sessionId = crypto.randomBytes(4).toString('hex');
  return new HttpsProxyAgent(
    `http://USERNAME-session-${sessionId}:PASSWORD@gate.proxyhat.com:8080`
  );
}
async function crawlPaginated(baseUrl, pages) {
  const agent = createStickyAgent(); // Same IP for all pages
  const results = [];
  for (let page = 1; page <= pages; page++) {
    const res = await fetch(`${baseUrl}?page=${page}`, { agent });
    results.push(await res.text());
  }
  return results;
}

Стратегия 3: Ротация по сбоям

Вместо ротации на каждый запрос или по таймеру, ротация по сбоям продолжает использовать IP до его блокировки, а затем переключается. Это максимизирует ценность каждого IP, используя его столько, сколько он работает.

Когда использовать

  • Цели с непредсказуемыми порогами блокировки
  • Бюджетный скрапинг, когда нужно максимум запросов на IP
  • Длительные обходы, где одни IP работают часами, а другие — минутами

Реализация с автоматическим переключением

import requests
import uuid
from time import sleep
class FailureBasedRotator:
    """Rotates proxy only when the current IP fails."""
    BLOCK_SIGNALS = [403, 429, 503]
    MAX_RETRIES = 3
    def __init__(self):
        self.session_id = None
        self.requests_on_current_ip = 0
        self._new_session()
    def _new_session(self):
        self.session_id = uuid.uuid4().hex[:8]
        self.requests_on_current_ip = 0
        proxy = f"http://USERNAME-session-{self.session_id}:PASSWORD@gate.proxyhat.com:8080"
        self.session = requests.Session()
        self.session.proxies = {"http": proxy, "https": proxy}
    def fetch(self, url: str) -> str | None:
        for attempt in range(self.MAX_RETRIES):
            try:
                resp = self.session.get(url, timeout=30)
                if resp.status_code in self.BLOCK_SIGNALS:
                    print(f"Blocked (HTTP {resp.status_code}) after "
                          f"{self.requests_on_current_ip} requests. Rotating...")
                    self._new_session()
                    sleep(1)
                    continue
                resp.raise_for_status()
                self.requests_on_current_ip += 1
                return resp.text
            except requests.RequestException:
                self._new_session()
                sleep(1)
        return None
# Usage
rotator = FailureBasedRotator()
for url in urls:
    html = rotator.fetch(url)

Реализация на Go с переключением

package main
import (
    "crypto/rand"
    "encoding/hex"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "time"
)
type FailureRotator struct {
    client    *http.Client
    sessionID string
    reqCount  int
}
func NewFailureRotator() *FailureRotator {
    r := &FailureRotator{}
    r.rotate()
    return r
}
func (r *FailureRotator) rotate() {
    b := make([]byte, 4)
    rand.Read(b)
    r.sessionID = hex.EncodeToString(b)
    r.reqCount = 0
    proxyStr := fmt.Sprintf("http://USERNAME-session-%s:PASSWORD@gate.proxyhat.com:8080", r.sessionID)
    proxyURL, _ := url.Parse(proxyStr)
    r.client = &http.Client{
        Transport: &http.Transport{Proxy: http.ProxyURL(proxyURL)},
        Timeout:   30 * time.Second,
    }
}
func (r *FailureRotator) Fetch(target string) (string, error) {
    for attempt := 0; attempt < 3; attempt++ {
        resp, err := r.client.Get(target)
        if err != nil {
            r.rotate()
            time.Sleep(time.Second)
            continue
        }
        defer resp.Body.Close()
        if resp.StatusCode == 403 || resp.StatusCode == 429 || resp.StatusCode == 503 {
            fmt.Printf("Blocked after %d requests. Rotating...\n", r.reqCount)
            r.rotate()
            time.Sleep(time.Second)
            continue
        }
        body, _ := io.ReadAll(resp.Body)
        r.reqCount++
        return string(body), nil
    }
    return "", fmt.Errorf("all retries exhausted for %s", target)
}

Стратегия 4: Гео-распределённая ротация

При скрапинге локализованного контента — поисковой выдачи, цен, доступности — нужны IP из конкретных географических локаций. Гео-распределённая ротация назначает IP из целевых стран или городов для получения точных локальных данных.

Когда использовать

  • Скрапинг SERP для локальных позиций
  • Мониторинг цен по регионам
  • Проверка доступности контента (гео-ограничения)
  • Верификация рекламы на конкретных рынках

Реализация с таргетингом по стране

import requests
from concurrent.futures import ThreadPoolExecutor
COUNTRIES = ["us", "gb", "de", "fr", "jp"]
def fetch_localized(url: str, country: str) -> dict:
    """Fetch URL through a proxy in the specified country."""
    proxy = f"http://USERNAME-country-{country}:PASSWORD@gate.proxyhat.com:8080"
    try:
        resp = requests.get(url, proxies={"http": proxy, "https": proxy}, timeout=30)
        return {"country": country, "status": resp.status_code, "body": resp.text}
    except requests.RequestException as e:
        return {"country": country, "status": 0, "error": str(e)}
def scrape_all_regions(url: str) -> list[dict]:
    """Fetch the same URL from multiple countries in parallel."""
    with ThreadPoolExecutor(max_workers=len(COUNTRIES)) as executor:
        futures = [executor.submit(fetch_localized, url, c) for c in COUNTRIES]
        return [f.result() for f in futures]
# Get localized pricing from 5 countries simultaneously
results = scrape_all_regions("https://example.com/product/pricing")
for r in results:
    print(f"{r['country'].upper()}: HTTP {r['status']}")

Смотрите доступные варианты таргетинга на странице Локации ProxyHat.

Комбинирование стратегий: гибридный подход

На практике крупные проекты скрапинга комбинируют несколько стратегий. Вот паттерн, использующий ротацию на каждый запрос для обнаружения, липкие сессии для глубокого обхода и ротацию по сбоям как запасной вариант:

import requests
import uuid
from enum import Enum
class RotationMode(Enum):
    PER_REQUEST = "per_request"
    STICKY = "sticky"
    FAILURE_BASED = "failure_based"
class HybridRotator:
    def __init__(self, mode: RotationMode = RotationMode.PER_REQUEST):
        self.mode = mode
        self.session_id = None
        self.failure_count = 0
        self._init_session()
    def _init_session(self):
        if self.mode == RotationMode.PER_REQUEST:
            proxy = "http://USERNAME:PASSWORD@gate.proxyhat.com:8080"
        else:
            self.session_id = self.session_id or uuid.uuid4().hex[:8]
            proxy = f"http://USERNAME-session-{self.session_id}:PASSWORD@gate.proxyhat.com:8080"
        self.session = requests.Session()
        self.session.proxies = {"http": proxy, "https": proxy}
    def force_rotate(self):
        """Force a new IP regardless of mode."""
        self.session_id = uuid.uuid4().hex[:8]
        self.failure_count = 0
        self._init_session()
    def fetch(self, url: str) -> str | None:
        try:
            resp = self.session.get(url, timeout=30)
            if resp.status_code in [403, 429, 503]:
                self.failure_count += 1
                if self.failure_count >= 2:
                    self.force_rotate()
                return None
            self.failure_count = 0
            return resp.text
        except requests.RequestException:
            self.failure_count += 1
            if self.failure_count >= 2:
                self.force_rotate()
            return None
# Discovery phase: rotate every request
discovery = HybridRotator(RotationMode.PER_REQUEST)
sitemap_urls = [discovery.fetch(url) for url in seed_urls]
# Deep crawl phase: sticky sessions per site section
crawler = HybridRotator(RotationMode.STICKY)
for section_url in section_urls:
    pages = [crawler.fetch(f"{section_url}?page={i}") for i in range(1, 11)]
    crawler.force_rotate()  # New IP for next section

Сравнение стратегий ротации

СтратегияЛучше всего дляПроцент успехаЭффективность IPСложность
На каждый запросБессостоятельный массовый сборВысокийНизкаяНизкая
По времени/липкиеЗадачи с сессиейСредне-высокийСредняяНизкая
По сбоямЦели с разной сложностьюСреднийВысокаяСредняя
Гео-распределённаяЛокализованный сбор данныхВысокийСредняяСредняя
ГибриднаяСложные многофазные проектыНаивысшийВысокаяВысокая

Лучшие практики ротации в масштабе

  • Уважайте robots.txt. Ротация не освобождает от соблюдения правил. Проверяйте правила и соблюдайте директивы crawl-delay.
  • Добавляйте реалистичные задержки. Даже с ротацией, всплеск в сотни запросов в секунду выглядит роботизированно. Добавьте случайные задержки 0.5-2 секунды между запросами.
  • Мониторьте процент успеха. Отслеживайте HTTP-коды статуса по каждому целевому сайту. Падение ниже 90% означает, что ротацию нужно настроить.
  • Комбинируйте с ротацией заголовков. Ротации IP недостаточно. Ротируйте строки User-Agent и другие заголовки для избежания обнаружения по отпечаткам.
  • Используйте задержку при сбоях. Когда IP блокируется, подождите перед повторной попыткой. Экспоненциальная задержка (1с, 2с, 4с, 8с) предотвращает трату запросов на временно враждебные цели.

Чтобы понять, сколько IP нужно для вашей стратегии ротации, смотрите Сколько прокси нужно для скрапинга?. Для комплексного обзора архитектуры скрапинга посетите наше Полное руководство по прокси для веб-скрапинга.

Готовы внедрить эти стратегии? Ознакомьтесь с Python SDK, Node SDK или Go SDK для интеграции прокси в продакшене, или изучите тарифы ProxyHat.

Часто задаваемые вопросы

Какая лучшая стратегия ротации прокси для веб-скрапинга?

Ротация на каждый запрос — самый безопасный вариант по умолчанию для большинства задач скрапинга. Она гарантирует, что каждый запрос использует другой IP, значительно затрудняя обнаружение паттернов. Для задач, требующих сохранения сессии (пагинация, авторизация), используйте липкие сессии.

Как часто нужно ротировать прокси?

При ротации на каждый запрос новый IP назначается автоматически. Для липких сессий 5-10 минут — хорошее значение по умолчанию. Оптимальная длительность зависит от цели — агрессивные сайты могут требовать более коротких сессий (1-2 минуты), а лояльные допускают 30+ минут.

Можно ли комбинировать разные стратегии ротации?

Да, и это рекомендуется для сложных проектов. Используйте ротацию на каждый запрос для обнаружения и сбора URL, липкие сессии для глубокого обхода и ротацию по сбоям как запасной вариант при блокировке IP.

ProxyHat обрабатывает ротацию автоматически?

Да. Каждый запрос через шлюз ProxyHat (gate.proxyhat.com:8080) автоматически получает другой IP из резидентного пула. Для липких сессий добавьте параметр сессии в учётные данные. Ручное управление списком IP не требуется.

Готовы начать?

Доступ к более чем 50 млн резидентных IP в 148+ странах с AI-фильтрацией.

Смотреть ценыРезидентные прокси
Полное руководство по прокси для веб-скрапинга
Веб-скрапинг

Полное руководство по прокси для веб-скрапинга

Исчерпывающее руководство по использованию прокси для веб-скрапинга. Типы прокси, стратегии ротации, примеры кода на Python, Node.js и Go, методы масштабирования и юридические аспекты парсинга в любых масштабах.

20 мин чтенияЧитать далее →
← Вернуться в Блог