Smile Comfort
記事一覧へ

IPブロックを回避するテクニック：2024年Webスクレイピング完全ガイド

約 21 分
IP ブロック 回避
Webスクレイピング
プロキシローテーション
アンチボット対策

IPブロック回避の最新テクニックを詳しく解説。プロキシローテーション、User-Agent変更、レート制限、行動パターン模倣まで実践的な方法を網羅。

IP ブロック回避には、プロキシローテーション、User-Agent 変更、適切なレート制限、人間らしい行動パターンの模倣が効果的です。

IP ブロックとは？なぜ発生するのか

IP ブロックは、Web サイトが同一 IP アドレスからの大量・高頻度アクセスを検知し、その IP アドレスからのアクセスを制限する仕組みです。この技術により、サーバー負荷軽減とセキュリティ向上を図っています。

まずWeb スクレイピングの基本概念を理解した上で、適切な対策を学んでいきましょう。

セキュリティシールドとネットワーク保護

IP ブロックが発生する主な理由

1. アクセス頻度の異常 人間の通常のブラウジング速度を大幅に超えるリクエスト頻度は、自動化ツールの使用を示唆します。

2. 規則的なパターン 一定間隔でのアクセスや、機械的な順序でのページ遷移は検知されやすい特徴です。

3. 疑わしい User-Agent デフォルトのライブラリ User-Agent や cURL などのツール固有の識別子は即座に検知されます。

4. 異常なリクエストヘッダー 不自然な HTTP ヘッダーや、ブラウザが通常送信しないヘッダーの組み合わせも検知要因となります。

核心的な回避テクニック

1. プロキシローテーション戦略

基本的なローテーション

import requests
import random
import time

class IPRotationScraper:
    def __init__(self, proxy_list):
        self.proxy_list = proxy_list
        self.current_proxy_index = 0

    def get_next_proxy(self):
        proxy = self.proxy_list[self.current_proxy_index]
        self.current_proxy_index = (self.current_proxy_index + 1) % len(self.proxy_list)
        return proxy

    def make_request(self, url, rotate_every=1):
        if self.current_proxy_index % rotate_every == 0:
            proxy = self.get_next_proxy()
        else:
            proxy = self.proxy_list[self.current_proxy_index - 1]

        proxies = {
            'http': f'http://{proxy}',
            'https': f'http://{proxy}'
        }

        try:
            response = requests.get(url, proxies=proxies, timeout=10)
            print(f"成功: {url} (プロキシ: {proxy})")
            return response
        except Exception as e:
            print(f"エラー: {url} (プロキシ: {proxy}) - {e}")
            return None

# 使用例
proxy_list = [
    "proxy1.example.com:8000",
    "proxy2.example.com:8000",
    "proxy3.example.com:8000"
]

scraper = IPRotationScraper(proxy_list)

住宅 IP プロキシの活用 データセンタープロキシよりも検知されにくい住宅 IP プロキシの使用を推奨します。詳細はデータセンタープロキシと住宅 IP の違いをご参照ください。

2. User-Agent 多様化戦略

現実的な User-Agent リストの作成

import random

class UserAgentRotator:
    def __init__(self):
        self.user_agents = [
            # Chrome (Windows)
            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
            # Chrome (Mac)
            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
            # Firefox (Windows)
            'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0',
            # Safari (Mac)
            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15',
            # Edge (Windows)
            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 Edg/120.0.0.0'
        ]

    def get_random_user_agent(self):
        return random.choice(self.user_agents)

    def get_headers(self):
        return {
            'User-Agent': self.get_random_user_agent(),
            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
            'Accept-Language': 'ja,en-US;q=0.7,en;q=0.3',
            'Accept-Encoding': 'gzip, deflate, br',
            'DNT': '1',
            'Connection': 'keep-alive',
            'Upgrade-Insecure-Requests': '1',
            'Sec-Fetch-Dest': 'document',
            'Sec-Fetch-Mode': 'navigate',
            'Sec-Fetch-Site': 'none'
        }

# 使用例
ua_rotator = UserAgentRotator()
headers = ua_rotator.get_headers()
response = requests.get(url, headers=headers)

User-Agent 選択の重要ポイント

  • 最新バージョンのブラウザを使用
  • OS とブラウザの組み合わせを自然に
  • モバイルとデスクトップを適切に使い分け

User-Agentローテーション図

3. インテリジェントレート制限

適応的遅延システム

import time
import random
from datetime import datetime, timedelta

class AdaptiveRateLimiter:
    def __init__(self, base_delay=1.0, max_delay=10.0):
        self.base_delay = base_delay
        self.max_delay = max_delay
        self.current_delay = base_delay
        self.last_request_time = 0
        self.success_count = 0
        self.failure_count = 0

    def calculate_delay(self):
        # 成功率に基づいて遅延を調整
        total_requests = self.success_count + self.failure_count
        if total_requests > 10:
            success_rate = self.success_count / total_requests
            if success_rate > 0.9:
                # 成功率が高い場合は遅延を短縮
                self.current_delay = max(self.base_delay, self.current_delay * 0.9)
            elif success_rate < 0.7:
                # 成功率が低い場合は遅延を延長
                self.current_delay = min(self.max_delay, self.current_delay * 1.5)

        # ランダム要素を追加して人間らしさを演出
        variance = random.uniform(-0.3, 0.7)
        return self.current_delay + variance

    def wait(self):
        current_time = time.time()
        time_since_last = current_time - self.last_request_time
        delay = self.calculate_delay()

        if time_since_last < delay:
            sleep_time = delay - time_since_last
            print(f"待機中: {sleep_time:.2f}秒")
            time.sleep(sleep_time)

        self.last_request_time = time.time()

    def mark_success(self):
        self.success_count += 1

    def mark_failure(self):
        self.failure_count += 1

# 使用例
rate_limiter = AdaptiveRateLimiter(base_delay=2.0, max_delay=15.0)

for url in url_list:
    rate_limiter.wait()
    response = make_request(url)
    if response and response.status_code == 200:
        rate_limiter.mark_success()
    else:
        rate_limiter.mark_failure()

4. 人間らしい行動パターンの模倣

自然なブラウジング行動の実装

import random
import time
from selenium import webdriver
from selenium.webdriver.common.action_chains import ActionChains

class HumanBehaviorSimulator:
    def __init__(self, driver):
        self.driver = driver
        self.actions = ActionChains(driver)

    def random_mouse_movement(self):
        # ランダムなマウス移動
        viewport_width = self.driver.execute_script("return window.innerWidth")
        viewport_height = self.driver.execute_script("return window.innerHeight")

        x = random.randint(0, viewport_width)
        y = random.randint(0, viewport_height)

        self.actions.move_by_offset(x, y).perform()
        time.sleep(random.uniform(0.1, 0.5))

    def random_scroll(self):
        # ランダムなスクロール
        scroll_amount = random.randint(-300, 300)
        self.driver.execute_script(f"window.scrollBy(0, {scroll_amount})")
        time.sleep(random.uniform(0.5, 2.0))

    def simulate_reading(self, min_time=2, max_time=8):
        # 読書時間のシミュレーション
        reading_time = random.uniform(min_time, max_time)
        print(f"読書シミュレーション: {reading_time:.2f}秒")

        # 読書中のランダムな行動
        for _ in range(random.randint(1, 3)):
            time.sleep(reading_time / 3)
            if random.choice([True, False]):
                self.random_scroll()
            else:
                self.random_mouse_movement()

    def click_random_safe_element(self):
        # 安全な要素へのランダムクリック
        safe_elements = self.driver.find_elements("tag name", "div")
        if safe_elements:
            element = random.choice(safe_elements[:5])  # 最初の5要素から選択
            try:
                self.actions.move_to_element(element).click().perform()
                time.sleep(random.uniform(0.5, 1.5))
            except:
                pass  # クリックできない要素は無視

# 使用例
driver = webdriver.Chrome()
behavior_sim = HumanBehaviorSimulator(driver)

driver.get("https://example.com")
behavior_sim.simulate_reading()
behavior_sim.random_scroll()

高度な回避技術

セッション管理と Cookie 処理

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

class SessionManager:
    def __init__(self):
        self.session = requests.Session()
        self.setup_session()

    def setup_session(self):
        # リトライ戦略の設定
        retry_strategy = Retry(
            total=3,
            backoff_factor=1,
            status_forcelist=[429, 500, 502, 503, 504]
        )

        adapter = HTTPAdapter(max_retries=retry_strategy)
        self.session.mount("http://", adapter)
        self.session.mount("https://", adapter)

        # 持続的なヘッダーの設定
        self.session.headers.update({
            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
            'Accept-Language': 'ja,en-US;q=0.7,en;q=0.3',
            'Accept-Encoding': 'gzip, deflate, br',
            'Connection': 'keep-alive',
            'Upgrade-Insecure-Requests': '1'
        })

    def maintain_session(self, base_url):
        # セッション維持のための定期的アクセス
        try:
            response = self.session.get(f"{base_url}/robots.txt", timeout=10)
            print(f"セッション維持: {response.status_code}")
        except:
            print("セッション維持失敗")

    def get_with_session(self, url, **kwargs):
        return self.session.get(url, **kwargs)

# 使用例
session_manager = SessionManager()
response = session_manager.get_with_session("https://example.com")

ブラウザフィンガープリント対策

from selenium import webdriver
from selenium.webdriver.chrome.options import Options

class AntiDetectionBrowser:
    def __init__(self):
        self.options = Options()
        self.setup_anti_detection()

    def setup_anti_detection(self):
        # 一般的な検知回避設定
        self.options.add_argument("--no-sandbox")
        self.options.add_argument("--disable-dev-shm-usage")
        self.options.add_argument("--disable-blink-features=AutomationControlled")
        self.options.add_experimental_option("excludeSwitches", ["enable-automation"])
        self.options.add_experimental_option('useAutomationExtension', False)

        # ウィンドウサイズの設定
        self.options.add_argument("--window-size=1366,768")

        # プラグインの無効化
        self.options.add_argument("--disable-plugins")
        self.options.add_argument("--disable-images")

    def create_driver(self):
        driver = webdriver.Chrome(options=self.options)

        # WebDriverプロパティの隠蔽
        driver.execute_script("Object.defineProperty(navigator, 'webdriver', {get: () => undefined})")

        # ユーザーエージェントの設定
        driver.execute_cdp_cmd('Network.setUserAgentOverride', {
            "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
        })

        return driver

# 使用例
anti_detection = AntiDetectionBrowser()
driver = anti_detection.create_driver()

ブラウザフィンガープリント対策

プロバイダー別対策

CloudFlare 回避

import undetected_chromedriver as uc
from selenium.webdriver.common.by import By
import time

class CloudFlareBypass:
    def __init__(self):
        self.driver = None

    def setup_driver(self):
        options = uc.ChromeOptions()
        options.add_argument("--no-first-run")
        options.add_argument("--no-service-autorun")
        options.add_argument("--password-store=basic")

        self.driver = uc.Chrome(options=options)
        return self.driver

    def bypass_cloudflare(self, url, max_wait=30):
        self.driver.get(url)

        start_time = time.time()
        while time.time() - start_time < max_wait:
            try:
                # CloudFlareチャレンジページの検知
                if "checking your browser" in self.driver.page_source.lower():
                    print("CloudFlareチャレンジ検知、待機中...")
                    time.sleep(2)
                    continue
                else:
                    print("CloudFlare回避成功")
                    return True
            except:
                time.sleep(1)

        return False

# 使用例
cf_bypass = CloudFlareBypass()
driver = cf_bypass.setup_driver()
success = cf_bypass.bypass_cloudflare("https://example.com")

CAPTCHA 対策

import time
from selenium.webdriver.common.by import By

class CaptchaHandler:
    def __init__(self, driver):
        self.driver = driver

    def detect_captcha(self):
        captcha_indicators = [
            "captcha",
            "recaptcha",
            "hcaptcha",
            "verify you are human",
            "prove you are not a robot"
        ]

        page_source = self.driver.page_source.lower()
        for indicator in captcha_indicators:
            if indicator in page_source:
                return True
        return False

    def wait_for_manual_solve(self, timeout=300):
        print("CAPTCHA検知: 手動解決を待機中...")
        start_time = time.time()

        while time.time() - start_time < timeout:
            if not self.detect_captcha():
                print("CAPTCHA解決完了")
                return True
            time.sleep(2)

        print("CAPTCHA解決タイムアウト")
        return False

    def auto_retry_after_captcha(self, url, max_retries=3):
        for attempt in range(max_retries):
            self.driver.get(url)
            time.sleep(3)

            if self.detect_captcha():
                if self.wait_for_manual_solve():
                    return True
                else:
                    print(f"再試行 {attempt + 1}/{max_retries}")
            else:
                return True

        return False

# 使用例
captcha_handler = CaptchaHandler(driver)
success = captcha_handler.auto_retry_after_captcha("https://example.com")

統合的な回避システム

import random
import time
from datetime import datetime

class ComprehensiveAntiBlockSystem:
    def __init__(self, proxy_list=None):
        self.proxy_rotator = IPRotationScraper(proxy_list) if proxy_list else None
        self.ua_rotator = UserAgentRotator()
        self.rate_limiter = AdaptiveRateLimiter()
        self.session_manager = SessionManager()

        self.request_count = 0
        self.block_count = 0

    def make_smart_request(self, url, method='GET', **kwargs):
        self.request_count += 1

        # レート制限の適用
        self.rate_limiter.wait()

        # ヘッダーの準備
        headers = self.ua_rotator.get_headers()
        if 'headers' in kwargs:
            headers.update(kwargs['headers'])
        kwargs['headers'] = headers

        # プロキシローテーション
        if self.proxy_rotator and self.request_count % 5 == 0:
            proxy = self.proxy_rotator.get_next_proxy()
            kwargs['proxies'] = {
                'http': f'http://{proxy}',
                'https': f'http://{proxy}'
            }

        try:
            if method.upper() == 'GET':
                response = self.session_manager.get_with_session(url, **kwargs)
            else:
                response = getattr(self.session_manager.session, method.lower())(url, **kwargs)

            if response.status_code in [403, 429, 503]:
                self.block_count += 1
                self.rate_limiter.mark_failure()
                print(f"ブロック検知: {response.status_code}")
                return None
            else:
                self.rate_limiter.mark_success()
                return response

        except Exception as e:
            self.rate_limiter.mark_failure()
            print(f"リクエストエラー: {e}")
            return None

    def get_statistics(self):
        success_rate = (self.request_count - self.block_count) / self.request_count if self.request_count > 0 else 0
        return {
            'total_requests': self.request_count,
            'blocks': self.block_count,
            'success_rate': success_rate
        }

# 使用例
system = ComprehensiveAntiBlockSystem(proxy_list)

for url in target_urls:
    response = system.make_smart_request(url)
    if response:
        # データ処理
        process_response(response)
    else:
        print(f"スキップ: {url}")

print("統計:", system.get_statistics())

監視と分析

リアルタイム成功率モニタリング

import matplotlib.pyplot as plt
from collections import deque
import threading
import time

class ScrapingMonitor:
    def __init__(self, window_size=100):
        self.success_history = deque(maxlen=window_size)
        self.timestamp_history = deque(maxlen=window_size)
        self.lock = threading.Lock()

    def log_result(self, success):
        with self.lock:
            self.success_history.append(1 if success else 0)
            self.timestamp_history.append(time.time())

    def get_success_rate(self, last_n=None):
        with self.lock:
            if not self.success_history:
                return 0

            data = list(self.success_history)
            if last_n:
                data = data[-last_n:]

            return sum(data) / len(data) if data else 0

    def should_adjust_strategy(self, threshold=0.7):
        return self.get_success_rate() < threshold

    def print_status(self):
        rate = self.get_success_rate()
        recent_rate = self.get_success_rate(last_n=10)
        print(f"成功率: 全体 {rate:.2%}, 直近10件 {recent_rate:.2%}")

# 使用例
monitor = ScrapingMonitor()

for url in urls:
    response = make_request(url)
    success = response and response.status_code == 200
    monitor.log_result(success)

    if monitor.should_adjust_strategy():
        print("戦略調整が必要です")
        # より保守的な設定に変更

法的・倫理的考慮事項

コンプライアンス遵守のフレームワーク

import urllib.robotparser
from urllib.parse import urljoin, urlparse

class EthicalScrapingFramework:
    def __init__(self, base_url):
        self.base_url = base_url
        self.robots_parser = urllib.robotparser.RobotFileParser()
        self.setup_robots_txt()

        self.rate_limits = {
            'default': 1.0,  # デフォルト1秒間隔
            'aggressive': 5.0,  # 厳格なサイトは5秒間隔
            'lenient': 0.5  # 寛容なサイトは0.5秒間隔
        }

    def setup_robots_txt(self):
        robots_url = urljoin(self.base_url, '/robots.txt')
        self.robots_parser.set_url(robots_url)
        try:
            self.robots_parser.read()
            print(f"robots.txt読み込み完了: {robots_url}")
        except:
            print("robots.txt読み込み失敗")

    def can_fetch(self, url, user_agent='*'):
        return self.robots_parser.can_fetch(user_agent, url)

    def get_crawl_delay(self, user_agent='*'):
        delay = self.robots_parser.crawl_delay(user_agent)
        return delay if delay else self.rate_limits['default']

    def check_ethical_compliance(self, url):
        # robots.txtチェック
        if not self.can_fetch(url):
            return False, "robots.txtにより禁止"

        # レート制限チェック
        required_delay = self.get_crawl_delay()
        return True, f"推奨間隔: {required_delay}秒"

    def get_sitemap_urls(self):
        sitemaps = self.robots_parser.site_maps()
        return list(sitemaps) if sitemaps else []

# 使用例
ethical_framework = EthicalScrapingFramework("https://example.com")

for url in target_urls:
    allowed, message = ethical_framework.check_ethical_compliance(url)
    if allowed:
        # スクレイピング実行
        print(f"実行: {url} ({message})")
    else:
        print(f"スキップ: {url} ({message})")

詳細な法的問題については、スクレイピングの法的問題 Q&Aをご確認ください。

よくある質問

Q1. IP ブロックを完全に回避することは可能ですか？ A. 完全な回避は困難ですが、適切なテクニックを組み合わせることで検知率を大幅に下げることができます。成功率 90%以上を目指すのが現実的です。

Q2. 無料プロキシで IP ブロック回避はできますか？ A. 無料プロキシは信頼性が低く、むしろブロックされやすい傾向があります。本格的な運用には有料プロキシサービスを推奨します。

Q3. Selenium を使用すると検知されやすいですか？ A. デフォルト設定の Selenium は検知されやすいですが、適切な設定により検知率を下げることが可能です。undetected-chromedriver などの専用ライブラリも有効です。

Q4. CloudFlare で保護されたサイトの対策は？ A. CloudFlare は特に厳格ですが、適切なブラウザ設定とヘッダー管理により回避可能です。ただし、頻繁な仕様変更にご注意ください。

Q5. 法的リスクを避けるにはどうすれば良いですか？ A. robots.txt の遵守、適切なレート制限、利用規約の確認が基本です。疑問がある場合は法的助言を求めることをお勧めします。

まとめ

IP ブロック回避は技術的な知識と倫理的な配慮の両方が必要な分野です。適切なテクニックを組み合わせることで、効果的かつ責任ある Web スクレイピングが実現できます。

実装を始める前に、まずローテーティングプロキシの基本を理解し、プロキシの種類と特徴を把握することをお勧めします。

この記事が役に立ちましたら、ぜひシェアしてください。

記事一覧へ

関連記事

関連記事の実装を準備中です。