वेब क्रॉलर सिर्फ HTTP अनुरोध भेजने के बारे में नहीं हैं - उन्हें जावास्क्रिप्ट रेंडरिंग, एंटी-बॉट सुरक्षा, स्केलेबिलिटी और त्रुटि प्रबंधन का सामना करना पड़ता है।この記事 में, हम उन सामान्य गडबडियों की जांच करेंगे जिनका सामना डेवलपर्स क्रॉलर बनाते समय करते हैं और कोड स्निपेट के साथ व्यावहारिक समाधान प्रदान करेंगे।

1. Robots.txt और क्रॉल नीतियों की अनदेखी करना

यदि आपका क्रॉलर robots.txt की अनदेखी करता है, तो आप कानूनी समस्याओं या आईपी ब्लॉक्स का सामना कर सकते हैं।

मल्टीप्रैक्टिस:

import requests

html = requests.get("https://example.com").text
# robots.txt की कोई जांच नहीं

बेहतर दृष्टिकोण:

import urllib.robotparser

rp = urllib.robotparser.RobotFileParser()
rp.set_url("https://example.com/robots.txt")
rp.read()

if rp.can_fetch("*", "https://example.com/page"):
    print("क्रॉल करने की अनुमति है")
else:
    print("robots.txt द्वारा अस्वीकृत")

✅ हमेशा क्रॉल नीतियों का सम्मान करें और दर सीमाएँ लागू करें।

2. बहुत आक्रामकता से क्रॉल करना

प्रतिक्षण हजारों अनुरोध भेजना बैन होने का एक तेज़ तरीका है।

समाधान:

• देरी जोड़ें
• असिंक्रोनस क्रॉलिंग का उपयोग करें ताकि दक्षता बढ़ सके

import asyncio, aiohttp, random

async def fetch(session, url):
    async with session.get(url) as resp:
        return await resp.text()

async def main():
    urls = ["https://example.com/page1", "https://example.com/page2"]
    async with aiohttp.ClientSession() as session:
        for url in urls:
            html = await fetch(session, url)
            print(len(html))
            await asyncio.sleep(random.uniform(1, 3))  # शिष्ट देरी

asyncio.run(main())

3. जावास्क्रिप्ट-रेंडर किए गए कंटेंट को संभालना

स्थैतिक क्रॉलर JS-भारी पृष्ठों (React, Vue, Angular) को चूक जाते हैं।

समाधान: हेडलेस ब्राउज़र का उपयोग करें (जैसे कि Playwright, Puppeteer)।

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(headless=True)
    page = browser.new_page()
    page.goto("https://quotes.toscrape.com/js/")
    print(page.content())  # अब JS-रेंडर किए गए कंटेंट को शामिल करता है
    browser.close()

4. डेटा निष्कर्षण में असामर्थता

नाजुक चयनकर्ताओं को हार्डकोड करने से क्रॉलर टूटने लगते हैं।

बेटर दृष्टिकोण BeautifulSoup + फॉलबैक के साथ:

from bs4 import BeautifulSoup

html = "<div><h1 class='title'>Hello</h1></div>"
soup = BeautifulSoup(html, "lxml")

# प्राथमिक चयनकर्ता
title = soup.select_one("h1.title")

# फॉलबैक
if not title:
    title = soup.find("h1")

print(title.text)

5. डुप्लिकेट कंटेंट संग्रह

ऐसे URLs जैसे /page?id=123&session=abc डुप्लिकेट बना सकते हैं।

समाधान: URLs को सामान्य करें

from urllib.parse import urlparse, urlunparse

def normalize(url):
    parsed = urlparse(url)
    clean = parsed._replace(query="")
    return urlunparse(clean)

print(normalize("https://example.com/page?id=1&session=xyz"))
# -> https://example.com/page

6. आईपी ब्लॉकिंग और एंटी-बॉट तंत्र

वेबसाइटें दर की अनियमितताओं, फिंगरप्रिंट्स और CAPTCHA के माध्यम से बॉट्स का पता लगाती हैं।

बुनियादी रोटेशन शक्र में:

class RotateUserAgentMiddleware:
    user_agents = [
        "Mozilla/5.0 ...",
        "Chrome/91.0 ...",
        "Safari/537.36 ..."
    ]

    def process_request(self, request, spider):
        import random
        request.headers['User-Agent'] = random.choice(self.user_agents)

समाधान ढेर:

• प्रॉक्सियों और यूजर एजेंटों का रोटेशन करें
• रेडिसिडेंशियल/मोबाइल प्रॉक्सीज का उपयोग करें
• आवश्यक होने पर CAPTCHA सॉल्वर शामिल करें

7. त्रुटि प्रबंधन

नेटवर्क त्रुटियाँ अनिवार्य हैं। बिना पुनः प्रयास के, क्रॉलर चुपचाप विफल हो जाते हैं।

पुनः प्रयास के साथ उदाहरण:

import requests, time

def fetch(url, retries=3):
    for i in range(retries):
        try:
            return requests.get(url, timeout=5)
        except requests.exceptions.RequestException as e:
            print(f"त्रुटि: {e}, पुनः प्रयास {i+1}")
            time.sleep(2**i)
    return None

8. स्केलेबिलिटी चुनौतियाँ

एक क्रॉलर जो 1,000 पृष्ठों के लिए काम करता है, 10 मिलियन पर विफल हो सकता है।

Distrubted Crawling का उदाहरण Scrapy + Redis के साथ:

scrapy runspider crawler.py -s JOBDIR=crawls/job1

उपयोग करें:

• वितरण कार्य कतारों के लिए Redis/Kafka
• स्केलिंग के लिए Scrapy Cluster / Nutch
• क्रॉल परिणामों के लिए क्लाउड संग्रहण

9. डेटा गुणवत्ता मुद्दे

क्रॉल की गई डेटा में डुप्लिकेट, खाली फ़ील्ड या अवैध प्रारूप हो सकते हैं।

समाधान: स्कीमा मान्यता

from pydantic import BaseModel, ValidationError

class Product(BaseModel):
    name: str
    price: float

try:
    item = Product(name="लैपटॉप", price="संख्या नहीं है")
except ValidationError as e:
    print(e)

10. सुरक्षा और अनुपालन

क्रॉलर को PII या प्रतिबंधित डेटा को स्क्रैप करने से बचना चाहिए।
उपयोगकर्ता डेटा संग्रहीत करने से पहले हमेशा GDPR/CCPA अनुपालन की जांच करें।

निष्कर्ष

एक मजबूत क्रॉलर बनाने के लिए तकनीकी सटीकता और नैतिक जिम्मेदारी की आवश्यकता होती है। आक्रामक क्रॉलिंग, जावास्क्रिप्ट रेंडरिंग, एंटी-बॉट सुरक्षा और स्केलेबिलिटी जैसी गडबडियों को संबोधित करके, डेवलपर्स ऐसे क्रॉलर डिज़ाइन कर सकते हैं जो:

• कुशल (संसाधनों का अनुकूलित उपयोग)
• लचीला (त्रुटि-सहिष्णु)
• अनुपालन (कानूनी और नैतिक)