समाचारों को पार्स करने के लिए प्रॉक्सी: बिना ब्लॉक के डेटा कैसे इकट्ठा करें

```html

समाचार साइटें इंटरनेट पर सबसे सुरक्षित संसाधनों में से एक हैं। Cloudflare, दर सीमित करना, IP द्वारा ब्लॉक करना — ये सभी समाचारों के पार्सिंग को एक गंभीर तकनीकी चुनौती बनाते हैं। इस मार्गदर्शिका में, हम देखेंगे कि समाचार पोर्टलों से डेटा को स्थिरता से इकट्ठा करने के लिए प्रॉक्सी को सही तरीके से कैसे सेटअप करें, विभिन्न कार्यों के लिए किस प्रकार की प्रॉक्सी का चयन करें और आधुनिक सुरक्षा प्रणालियों को कैसे बायपास करें।

समाचार साइटें पार्सर्स को क्यों ब्लॉक करती हैं

समाचार पोर्टल विशेष रूप से डेटा के स्वचालित संग्रह के प्रति संवेदनशील होते हैं कई कारणों से। सबसे पहले, सामग्री उनका मुख्य संपत्ति है, जिसे वे विज्ञापनों और सदस्यताओं के माध्यम से मुद्रीकरण करते हैं। बड़े पैमाने पर पार्सिंग प्रतिस्पर्धियों को सामग्री की नकल करने की अनुमति देती है और अद्वितीय ट्रैफ़िक को कम करती है। दूसरी बात, बॉट्स से उच्च लोड सर्वरों और CDN पर खर्च बढ़ाता है।

आधुनिक समाचार साइटें बहु-स्तरीय सुरक्षा का उपयोग करती हैं:

Cloudflare और समान — JavaScript, TLS-ब्राउज़र फ़िंगरप्रिंट, व्यवहार पैटर्न की जांच करते हैं
दर सीमित करना — एक IP से अनुरोधों की संख्या को सीमित करते हैं (आमतौर पर प्रति मिनट 10-50 अनुरोध)
User-Agent द्वारा ब्लॉक करना — मानक लाइब्रेरी हेडर (Python-requests, curl) को बैन करते हैं
CAPTCHA — संदिग्ध गतिविधि पर प्रदर्शित करते हैं
भौगोलिक ब्लॉकिंग — कुछ समाचार पोर्टल केवल निश्चित देशों से उपलब्ध हैं

समाचार साइटें पार्सर्स का पता लगाने के लिए सामान्य संकेत: समान IP लगातार कई अनुरोध करता है, JavaScript की अनुपस्थिति, HTTP हेडर का असामान्य क्रम, अनुरोधों की बहुत तेज़ गति (एक व्यक्ति 10 पृष्ठ प्रति सेकंड नहीं खोल सकता), कुकीज़ और रेफरर की अनुपस्थिति।

महत्वपूर्ण: समाचार साइटों का पार्सिंग ग्रे ज़ोन में है। हमेशा लक्षित संसाधन के robots.txt और सेवा की शर्तों की जांच करें। डेटा के व्यावसायिक उपयोग के लिए आधिकारिक API का उपयोग करने या साझेदारी समझौतों पर हस्ताक्षर करने की सिफारिश की जाती है।

समाचार पार्सिंग के लिए किस प्रकार की प्रॉक्सी का चयन करें

प्रॉक्सी के प्रकार का चयन कार्य के पैमाने, बजट और लक्षित साइटों की सुरक्षा के स्तर पर निर्भर करता है। हम तीन मुख्य विकल्पों और समाचार पार्सिंग के लिए उनकी उपयुक्तता पर विचार करेंगे।

प्रॉक्सी का प्रकार	गति	लागत	कब उपयोग करें
डेटा सेंटर प्रॉक्सी	उच्च (50-100 मि.सेक)	कम	Cloudflare के बिना साइटें, बड़े डेटा का मात्रा, परीक्षण
रिज़िडेंट प्रॉक्सी	मध्यम (200-500 मि.सेक)	उच्च	Cloudflare के साथ साइटें, कड़ी सुरक्षा, भू-लक्षित
मोबाइल प्रॉक्सी	मध्यम (300-600 मि.सेक)	बहुत उच्च	अधिकतम सुरक्षा, समाचार साइटों के मोबाइल संस्करण

समाचार पार्सिंग के लिए डेटा सेंटर प्रॉक्सी

ये समाचार साइटों के पार्सिंग के लिए उपयुक्त हैं जिनकी सुरक्षा गंभीर नहीं है: क्षेत्रीय प्रकाशन, ब्लॉग, छोटे सूचना पोर्टल। लाभ: उच्च गति (सैकड़ों स्रोतों के पार्सिंग के लिए महत्वपूर्ण), कम लागत (50-100 IP का पूल किराए पर लिया जा सकता है), स्थिर कनेक्शन।

नुकसान: ASN द्वारा आसानी से पता लगाया जाता है (डेटा सेंटर से संबंधित), अक्सर बड़े साइटों की काली सूचियों में पहले से ही शामिल होते हैं, 70% मामलों में Cloudflare Challenge को पार नहीं करते हैं। डेटा सेंटर प्रॉक्सी का उपयोग RSS फ़ीड, sitemap.xml, API endpoints के बड़े पैमाने पर पार्सिंग के लिए करें या बिना पूर्ण सामग्री के मेटाडेटा (हेडर, प्रकाशन तिथियाँ) इकट्ठा करने के लिए करें।

रिज़िडेंट प्रॉक्सी — स्वर्ण मानक

रिज़िडेंट प्रॉक्सी वास्तविक घरेलू उपयोगकर्ताओं के IP पते हैं, जो इंटरनेट सेवा प्रदाताओं द्वारा प्रदान किए जाते हैं। समाचार साइटों के लिए, ये सामान्य आगंतुकों के रूप में दिखते हैं, जो सुरक्षित संसाधनों के साथ काम करते समय महत्वपूर्ण है।

जब रिज़िडेंट प्रॉक्सी अनिवार्य होते हैं: बड़े समाचार पोर्टलों (CNN, BBC, Reuters, RBK, कोमर्सेंट) का पार्सिंग, Cloudflare या समान सुरक्षा वाले साइटें, निश्चित देशों से डेटा इकट्ठा करना (भू-लक्षित), प्रमाणीकरण के साथ लंबे सत्र। रिज़िडेंट प्रॉक्सी Cloudflare की JavaScript जांचों को पार करते हैं, IP की साफ़ प्रतिष्ठा होती है, स्थिर सत्रों का समर्थन करते हैं (10-30 मिनट के लिए IP को स्थिर करना)।

व्यावहारिक सलाह: समय के अनुसार रोटेशन के साथ रिज़िडेंट प्रॉक्सी का उपयोग करें (स्थिर सत्र), न कि अनुरोधों के अनुसार। उदाहरण के लिए, एक IP 10 मिनट काम करता है, 20-30 लेख इकट्ठा करता है, फिर बदल जाता है। यह हर अनुरोध पर IP बदलने की तुलना में अधिक स्वाभाविक लगता है।

विशेष मामलों के लिए मोबाइल प्रॉक्सी

मोबाइल प्रॉक्सी मोबाइल ऑपरेटरों (MTS, Beeline, Tele2) के IP का उपयोग करते हैं। इनका अधिकतम विश्वास होता है, क्योंकि लाखों लोग समाचार पढ़ने के लिए मोबाइल इंटरनेट का उपयोग करते हैं। इनका उपयोग समाचार साइटों के मोबाइल संस्करणों के पार्सिंग के लिए करें (अक्सर सरल सुरक्षा होती है), अत्यधिक कड़ी सुरक्षा वाले साइटों के लिए, Google News के AMP पृष्ठों के लिए।

मोबाइल प्रॉक्सी की विशेषता: IP अक्सर स्वचालित रूप से बदलता है (मोबाइल ऑपरेटर CGNAT का उपयोग करते हैं), एक IP सैकड़ों उपयोगकर्ताओं के पास एक साथ हो सकता है, जिससे ब्लॉक करना बेकार हो जाता है। नुकसान — उच्च कीमत, इसलिए इनका उपयोग केवल विशेष रूप से, सबसे सुरक्षित लक्ष्यों के लिए करें।

Cloudflare और अन्य एंटी-बॉट सिस्टम को बायपास करना

Cloudflare समाचार साइटों के पार्सर्स का मुख्य दुश्मन है। लगभग 40% बड़े समाचार पोर्टल बॉट्स से सुरक्षा के लिए Cloudflare का उपयोग करते हैं। मानक लाइब्रेरी (requests, urllib) जांच को पार नहीं करती हैं, क्योंकि Cloudflare TLS फ़िंगरप्रिंट, JavaScript निष्पादन, HTTP हेडर का क्रम, व्यवहार पैटर्न का विश्लेषण करता है।

Cloudflare को बायपास करने की रणनीतियाँ

1. हेडलेस ब्राउज़र (Selenium, Playwright, Puppeteer)

वास्तविक ब्राउज़र के साथ JavaScript निष्पादन का अनुकरण करते हैं। Cloudflare Chrome/Firefox का सही TLS फ़िंगरप्रिंट देखता है और अनुरोध को पास करता है। नुकसान: धीमा (प्रत्येक पृष्ठ पर 2-5 सेकंड), बहुत सारे संसाधनों की आवश्यकता होती है (RAM, CPU)।

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

# Selenium के लिए प्रॉक्सी सेटअप
chrome_options = Options()
chrome_options.add_argument('--proxy-server=http://username:password@proxy.example.com:8080')
chrome_options.add_argument('--headless')
chrome_options.add_argument('--disable-blink-features=AutomationControlled')

driver = webdriver.Chrome(options=chrome_options)
driver.get('https://news-site.com/article')

# JavaScript लोड होने की प्रतीक्षा करें
driver.implicitly_wait(10)
html = driver.page_source
driver.quit()

2. TLS-फिंगरप्रिंटिंग वाली लाइब्रेरी (curl_cffi, tls-client)

वास्तविक ब्राउज़र के TLS फ़िंगरप्रिंट का अनुकरण करते हैं बिना हेडलेस ब्राउज़र को चलाए। Selenium की तुलना में 10-20 गुना तेज़ काम करते हैं, लेकिन JavaScript निष्पादित नहीं करते हैं। Cloudflare की बुनियादी जांच (बिना JS-चुनौती) वाले साइटों के लिए उपयुक्त हैं।

from curl_cffi import requests

proxies = {
    'http': 'http://username:password@proxy.example.com:8080',
    'https': 'http://username:password@proxy.example.com:8080'
}

response = requests.get(
    'https://news-site.com/article',
    proxies=proxies,
    impersonate='chrome110'  # Chrome 110 के TLS फ़िंगरप्रिंट का अनुकरण
)

print(response.text)

3. Cloudflare-बायपास सेवाएँ (scraperapi, scrapingbee)

भुगतान किए गए API, जो स्वचालित रूप से Cloudflare को बायपास करते हैं। आप URL भेजते हैं, वे तैयार HTML लौटाते हैं। लाभ: तकनीकी विवरणों में जाने की आवश्यकता नहीं, प्रॉक्सी का स्वचालित रोटेशन, CAPTCHA का प्रबंधन। नुकसान: बड़े मात्रा में महंगा (100K अनुरोधों के लिए $50/महीना से)।

सही HTTP हेडर

प्रॉक्सी के साथ भी सही हेडर भेजना महत्वपूर्ण है, अन्यथा साइट असामान्य User-Agent या Accept-Language की अनुपस्थिति के कारण बॉट का पता लगाएगी।

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8',
    'Accept-Language': 'hi-IN,hi;q=0.9,en-US;q=0.8,en;q=0.7',
    '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',
    'Cache-Control': 'max-age=0'
}

समय-समय पर User-Agent को अपडेट करें — ब्राउज़रों के नवीनतम संस्करणों का उपयोग करें। अपने फ़िंगरप्रिंट की जांच आप whoer.net या browserleaks.com पर कर सकते हैं।

IP रोटेशन सेटअप और अनुरोधों का प्रबंधन

प्रॉक्सी का सही रोटेशन बिना ब्लॉक के स्थिर पार्सिंग की कुंजी है। समाचार साइटें एक IP से अनुरोधों की आवृत्ति को ट्रैक करती हैं, और सीमा से अधिक होने पर अस्थायी या स्थायी बैन होता है।

प्रॉक्सी के रोटेशन के प्रकार

अनुरोधों के अनुसार रोटेशन — प्रत्येक अनुरोध एक नए IP के माध्यम से जाता है। विभिन्न साइटों के बड़े पैमाने पर पार्सिंग के लिए उपयुक्त है, अनुरोधों की आवृत्ति के कारण बैन का जोखिम कम करता है। नुकसान: सत्रों (कुकीज़, प्रमाणीकरण) वाले साइटों के लिए उपयुक्त नहीं है, कुछ सुरक्षा के लिए संदिग्ध लग सकता है।

समय के अनुसार रोटेशन (स्टिकी सत्र) — एक IP एक निश्चित समय (5-30 मिनट) के लिए उपयोग किया जाता है, फिर बदल जाता है। एक समाचार पोर्टल के कई पृष्ठों के पार्सिंग के लिए उपयुक्त है, कुकीज़ और सत्रों को बनाए रखता है, वास्तविक उपयोगकर्ता के व्यवहार के रूप में दिखता है। अधिकांश समाचार पार्सिंग कार्यों के लिए अनुशंसित।

भौगोलिक स्थान के अनुसार रोटेशन — विभिन्न देशों/शहरों से IP का परिवर्तन। भू-निर्भर सामग्री (क्षेत्रीय समाचार) के पार्सिंग, भू-प्रतिबंधों को बायपास करने के लिए उपयोग किया जाता है।

अनुरोधों की अनुकूलतम आवृत्ति

प्रॉक्सी के रोटेशन के साथ भी अनुरोधों को बहुत बार नहीं करना चाहिए। विभिन्न प्रकार की साइटों के लिए सुरक्षित अंतराल:

बड़े समाचार पोर्टल (RBK, कोमर्सेंट, वेदमोस्ती) — एक IP से अनुरोधों के बीच 2-5 सेकंड
मध्यम साइटें — 1-3 सेकंड
छोटे ब्लॉग और क्षेत्रीय प्रकाशन — 0.5-1 सेकंड

अनुरोधों के पैटर्न को स्वाभाविक रूप से दिखाने के लिए यादृच्छिक देरी (randomization) जोड़ें:

import time
import random

def fetch_article(url, proxies):
    response = requests.get(url, proxies=proxies, headers=headers)
    
    # 2 से 5 सेकंड के बीच यादृच्छिक देरी
    delay = random.uniform(2, 5)
    time.sleep(delay)
    
    return response.text

पूल से प्रॉक्सी का रोटेशन का उदाहरण

यदि आपके पास प्रॉक्सी की एक सूची है, तो आप मैन्युअल रूप से एक सरल रोटेशन लागू कर सकते हैं:

import itertools
import requests

# प्रॉक्सी का पूल
proxy_list = [
    'http://user:pass@proxy1.example.com:8080',
    'http://user:pass@proxy2.example.com:8080',
    'http://user:pass@proxy3.example.com:8080',
]

# एक अनंत इटरेटर बनाएं
proxy_pool = itertools.cycle(proxy_list)

def get_next_proxy():
    proxy = next(proxy_pool)
    return {'http': proxy, 'https': proxy}

# उपयोग
urls = ['https://news1.com/article', 'https://news2.com/article']

for url in urls:
    proxies = get_next_proxy()
    response = requests.get(url, proxies=proxies, headers=headers)
    print(f'Fetched {url} via {proxies["http"]}')

कोड के उदाहरण: Python + Scrapy + प्रॉक्सी

Scrapy — एक पेशेवर पार्सिंग फ्रेमवर्क है, जो प्रॉक्सी, मिडलवेयर, रोटेशन और त्रुटियों के प्रबंधन का समर्थन करता है। आइए प्रॉक्सी के रोटेशन के साथ एक समाचार साइट के पार्सर का पूरा उदाहरण देखें।

निर्भरता स्थापित करना

pip install scrapy scrapy-rotating-proxies

प्रॉक्सी के साथ Scrapy सेटअप (settings.py)

# settings.py

# प्रॉक्सी के रोटेशन के लिए मिडलवेयर सक्षम करें
ROTATING_PROXY_LIST = [
    'http://user:pass@proxy1.example.com:8080',
    'http://user:pass@proxy2.example.com:8080',
    'http://user:pass@proxy3.example.com:8080',
]

DOWNLOADER_MIDDLEWARES = {
    'rotating_proxies.middlewares.RotatingProxyMiddleware': 610,
    'rotating_proxies.middlewares.BanDetectionMiddleware': 620,
}

# ब्लॉकों को बायपास करने के लिए सेटिंग्स
CONCURRENT_REQUESTS = 8  # एक समय में अधिकतम 8 समवर्ती अनुरोध
DOWNLOAD_DELAY = 2  # अनुरोधों के बीच 2 सेकंड की देरी
RANDOMIZE_DOWNLOAD_DELAY = True  # यादृच्छिक देरी

# User-Agent
USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'

# त्रुटियों पर पुनः प्रयास
RETRY_TIMES = 3
RETRY_HTTP_CODES = [500, 502, 503, 504, 408, 429]

समाचार पार्सिंग के लिए स्पाइडर

# news_spider.py

import scrapy
from datetime import datetime

class NewsSpider(scrapy.Spider):
    name = 'news_parser'
    
    # पार्सिंग के लिए समाचार साइटों की सूची
    start_urls = [
        'https://example-news.com/latest',
    ]
    
    def parse(self, response):
        # मुख्य पृष्ठ पर लेखों की सूची पार्स करें
        articles = response.css('article.news-item')
        
        for article in articles:
            article_url = article.css('a.title::attr(href)').get()
            
            if article_url:
                # लेख के पृष्ठ पर जाएँ
                yield response.follow(article_url, callback=self.parse_article)
    
    def parse_article(self, response):
        # लेख के डेटा को निकालें
        yield {
            'url': response.url,
            'title': response.css('h1.article-title::text').get(),
            'date': response.css('time.published::attr(datetime)').get(),
            'author': response.css('span.author::text').get(),
            'text': ' '.join(response.css('div.article-body p::text').getall()),
            'tags': response.css('a.tag::text').getall(),
            'scraped_at': datetime.now().isoformat(),
        }

पार्सर चलाना

# JSON में सहेजें
scrapy crawl news_parser -o news_data.json

# CSV में सहेजें
scrapy crawl news_parser -o news_data.csv

requests + BeautifulSoup पर सरल पार्सर

यदि जटिल लॉजिक की आवश्यकता नहीं है, तो आप requests + BeautifulSoup का संयोजन कर सकते हैं:

import requests
from bs4 import BeautifulSoup
import time
import random

# प्रॉक्सी सेटअप
proxies = {
    'http': 'http://user:pass@proxy.example.com:8080',
    'https': 'http://user:pass@proxy.example.com:8080'
}

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
}

def parse_news_article(url):
    try:
        response = requests.get(url, proxies=proxies, headers=headers, timeout=10)
        response.raise_for_status()
        
        soup = BeautifulSoup(response.text, 'html.parser')
        
        # डेटा निकालना (चयनकर्ता साइट पर निर्भर करते हैं)
        title = soup.find('h1', class_='article-title').text.strip()
        date = soup.find('time', class_='published')['datetime']
        text = ' '.join([p.text for p in soup.find_all('p', class_='article-text')])
        
        return {
            'url': url,
            'title': title,
            'date': date,
            'text': text
        }
    
    except Exception as e:
        print(f'Error parsing {url}: {e}')
        return None

# लेखों की सूची पार्स करना
urls = [
    'https://news-site.com/article-1',
    'https://news-site.com/article-2',
]

for url in urls:
    article_data = parse_news_article(url)
    if article_data:
        print(article_data)
    
    # अनुरोधों के बीच देरी
    time.sleep(random.uniform(2, 4))

समाचार पार्सिंग में सामान्य गलतियाँ

सही प्रॉक्सी सेटअप के साथ भी, पार्सर्स अक्सर तकनीकी त्रुटियों के कारण ब्लॉक होते हैं। आइए सबसे सामान्य समस्याओं और उनके समाधानों पर विचार करें।

त्रुटि 1: अनुरोधों की बहुत अधिक आवृत्ति

लक्षण: HTTP 429 (बहुत अधिक अनुरोध), IP का अस्थायी बैन, CAPTCHA। कारण: पार्सर एक IP से प्रति सेकंड 10-50 अनुरोध करता है। समाधान: देरी जोड़ें (time.sleep()), Scrapy में DOWNLOAD_DELAY का उपयोग करें, CONCURRENT_REQUESTS को सीमित करें।

त्रुटि 2: सभी अनुरोधों के लिए एक ही प्रॉक्सी का उपयोग करना

लक्षण: प्रॉक्सी तेजी से बैन हो जाती है, भले ही देरी हो। कारण: एक IP एक साइट पर सैकड़ों अनुरोध करता है। समाधान: रोटेशन के साथ प्रॉक्सी का पूल का उपयोग करें, बड़े साइटों के लिए — कम से कम 10-20 प्रॉक्सी, स्टिकी सत्रों के लिए हर 10-15 मिनट में IP बदलें।

त्रुटि 3: कुकीज़ की अनदेखी करना

कई समाचार साइटें पहले दौरे पर कुकीज़ सेट करती हैं और बाद के अनुरोधों में उनकी उपस्थिति की जांच करती हैं। कुकीज़ की अनुपस्थिति बॉट का संकेत है। समाधान: कुकीज़ को स्वचालित रूप से सहेजने के लिए requests.Session() का उपयोग करें, Scrapy में COOKIES_ENABLED = True सक्षम करें।

import requests

session = requests.Session()
session.proxies = {'http': 'http://proxy.com:8080', 'https': 'http://proxy.com:8080'}

# पहला अनुरोध — कुकीज़ प्राप्त करें
response1 = session.get('https://news-site.com')

# बाद के अनुरोध स्वचालित रूप से कुकीज़ भेजते हैं
response2 = session.get('https://news-site.com/article')

त्रुटि 4: रीडायरेक्ट्स को गलत तरीके से संभालना

समाचार साइटें अक्सर मोबाइल संस्करणों, क्षेत्रीय उपडोमेन, AMP पृष्ठों के लिए रीडायरेक्ट्स (301, 302) का उपयोग करती हैं। यदि पार्सर रीडायरेक्ट्स का पालन नहीं करता है, तो उसे खाली पृष्ठ मिलता है। समाधान: अनुरोधों में रीडायरेक्ट्स डिफ़ॉल्ट रूप से सक्षम होते हैं (allow_redirects=True), अंतिम URL की जांच करें response.url के माध्यम से।

त्रुटि 5: JavaScript के बिना गतिशील सामग्री का पार्सिंग

कई आधुनिक समाचार साइटें सामग्री को JavaScript (React, Vue) के माध्यम से लोड करती हैं। लाइब्रेरी requests खाली HTML ढांचे को प्राप्त करती है जिसमें लेख नहीं होते। समाधान: JavaScript निष्पादन के लिए Selenium/Playwright का उपयोग करें, DevTools में नेटवर्क की जांच करें — संभवतः डेटा API के माध्यम से लोड हो रहा है (JSON को सीधे पार्स करना संभव है)।

स्केलिंग: सैकड़ों स्रोतों का पार्सिंग

जब एक ही समाचार साइट के बजाय सैकड़ों स्रोतों का पार्सिंग करना हो (समाचार एग्रीगेटर्स, मीडिया की निगरानी), तो एक स्केलेबल आर्किटेक्चर की आवश्यकता होती है।

Scrapy Cloud के साथ वितरित पार्सिंग

Scrapy Cloud (Scrapy के निर्माताओं द्वारा) आपको क्लाउड में पार्सर्स को चलाने की अनुमति देता है, जिसमें स्वचालित स्केलिंग होती है। लाभ: अपने स्वयं के सर्वरों की आवश्यकता नहीं, प्रॉक्सी का स्वचालित रोटेशन, निगरानी और लॉग। लागत: बेसिक प्लान के लिए $9/महीना से।

कार्य कतारें (Celery + Redis)

स्वायत्त तैनाती के लिए Celery का उपयोग करें — वितरित कार्यों की प्रणाली। आर्किटेक्चर: Redis पार्सिंग के लिए URL की कतार को स्टोर करता है, कई वर्कर्स (सर्वर) कतार से कार्य लेते हैं और समानांतर में पार्स करते हैं, प्रत्येक वर्कर अपने प्रॉक्सी पूल का उपयोग करता है।

# tasks.py

from celery import Celery
import requests

app = Celery('news_parser', broker='redis://localhost:6379/0')

@app.task
def parse_article(url, proxy):
    proxies = {'http': proxy, 'https': proxy}
    response = requests.get(url, proxies=proxies, timeout=10)
    # पार्सिंग और डेटा को सहेजना
    return response.text

# कतार में कार्य जोड़ना
urls = ['https://news1.com/article', 'https://news2.com/article']
proxies = ['http://proxy1.com:8080', 'http://proxy2.com:8080']

for url in urls:
    proxy = random.choice(proxies)
    parse_article.delay(url, proxy)  # असिंक्रोनस निष्पादन

निगरानी और त्रुटियों का प्रबंधन

बड़े पैमाने पर पार्सिंग में निगरानी महत्वपूर्ण है: कितने URL संसाधित हुए, कितनी त्रुटियाँ, कौन सी प्रॉक्सी बैन हुई। Python त्रुटियों की निगरानी के लिए Sentry का उपयोग करें, मेट्रिक्स (प्रति सेकंड अनुरोध, प्रतिक्रिया समय) के लिए Grafana + Prometheus, ELK Stack (Elasticsearch, Logstash, Kibana) में लॉगिंग करें।

सलाह: प्रॉक्सी की स्वचालित जांच की प्रणाली बनाएं। हर 5-10 मिनट में प्रत्येक प्रॉक्सी पर whoer.net या httpbin.org पर परीक्षण अनुरोध भेजें। यदि प्रॉक्सी उत्तर नहीं देती है या बैन हो जाती है — इसे पूल से बाहर करें और नया जोड़ें।

प्रॉक्सी पर खर्चों का अनुकूलन

सैकड़ों स्रोतों के पार्सिंग के दौरान प्रॉक्सी पर खर्च हजारों डॉलर प्रति माह हो सकता है। अनुकूलन रणनीतियाँ: सरल साइटों (RSS, API) के लिए डेटा सेंटर प्रॉक्सी का उपयोग करें, सुरक्षित साइटों के लिए रिज़िडेंट प्रॉक्सी — केवल, डेटा को कैश करें — एक ही लेख को दो बार पार्स न करें, पीक घंटों (रात में साइटों पर लोड कम होता है, बैन का जोखिम कम होता है) में पार्स करें।

उदाहरण: 500 समाचार साइटों के पार्सिंग के लिए 80% डेटा सेंटर प्रॉक्सी (RSS और सरल साइटों के लिए) और 20% रिज़िडेंट (टॉप-100 सुरक्षित पोर्टलों के लिए) का उपयोग किया जा सकता है। यह खर्च को 3-5 गुना कम कर देगा।

निष्कर्ष

समाचार साइटों का पार्सिंग एक तकनीकी रूप से जटिल कार्य है, जिसमें प्रॉक्सी का सही चयन, रोटेशन का सेटअप और एंटी-बॉट सिस्टम को बायपास करना शामिल है। लेख से मुख्य निष्कर्ष: सुरक्षित समाचार पोर्टलों (Cloudflare, कड़ी दर सीमित करना) के लिए स्टिकी सत्रों के साथ रिज़िडेंट प्रॉक्सी का उपयोग करें, सैकड़ों स्रोतों के बड़े पैमाने पर पार्सिंग के लिए तेज़ रोटेशन के साथ डेटा सेंटर प्रॉक्सी उपयुक्त हैं, अनुरोधों के बीच (2-5 सेकंड) और सही HTTP हेडर जोड़ना अनिवार्य है, Cloudflare को बायपास करने के लिए हेडलेस ब्राउज़रों (Selenium, Playwright) या TLS-फिंगरप्रिंटिंग वाली लाइब्रेरी का उपयोग करें।

स्केलिंग के दौरान वितरित प्रणालियों (Celery, Scrapy Cloud) और त्रुटियों की निगरानी का उपयोग करें। याद रखें कि पार्सिंग को नैतिक होना चाहिए — robots.txt का पालन करें, सर्वरों पर अत्यधिक लोड न बनाएं और सामग्री पर कॉपीराइट का सम्मान करें।

यदि आप Cloudflare सुरक्षा के साथ बड़े समाचार पोर्टलों का पार्सिंग करने की योजना बना रहे हैं, तो हम रिज़िडेंट प्रॉक्सी का उपयोग करने की सिफारिश करते हैं — ये उच्च स्तर का विश्वास और ब्लॉक होने का न्यूनतम जोखिम प्रदान करते हैं। जहां गति और डेटा की मात्रा महत्वपूर्ण है (RSS, API endpoints का पार्सिंग), वहाँ डेटा सेंटर प्रॉक्सी उपयुक्त हैं।

```

बिना ब्लॉक के समाचार साइटों को कैसे पार्स करें: प्रॉक्सी सेटअप और सुरक्षा को बायपास करना