प्रॉक्सी पूल के लिए हेल्थ चेक कैसे सेट करें: 15 मिनट में स्वचालित निगरानी

यदि आप कई प्रॉक्सी के साथ काम कर रहे हैं - मार्केटप्लेस को पार्स कर रहे हैं, सोशल मीडिया पर कई अकाउंट चला रहे हैं या विज्ञापन चला रहे हैं - तो आप इस समस्या को जानते हैं: अचानक कुछ प्रॉक्सी काम करना बंद कर देती हैं, और आपके कार्य रुक जाते हैं। प्रॉक्सी पूल के लिए हेल्थ चेक (कार्यशीलता की जांच) इस समस्या को स्वचालित रूप से हल करता है: सिस्टम स्वयं प्रत्येक आईपी की जांच करता है, गैर-कार्यात्मक को बाहर करता है और केवल स्थिर कनेक्शन का उपयोग करता है।

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

प्रॉक्सी का हेल्थ चेक क्या है और इसकी आवश्यकता क्यों है

हेल्थ चेक (कार्यशीलता की जांच) एक स्वचालित निगरानी प्रणाली है जो प्रॉक्सी पूल की नियमित रूप से प्रत्येक आईपी पते की उपलब्धता, गति और कार्यक्षमता की जांच करती है। जब आप दर्जनों या सैकड़ों प्रॉक्सी के साथ काम कर रहे होते हैं, तो उनमें से कुछ काम करना बंद कर देते हैं: समय सीमा समाप्त हो जाती है, आईपी बैन हो जाता है, प्रदाता पहुंच को अवरुद्ध कर देता है या बस गति गिर जाती है।

बिना हेल्थ चेक के, आप समस्या के बारे में केवल तब जानेंगे जब कार्य एक त्रुटि के साथ गिर जाएगा: पार्सर डेटा नहीं इकट्ठा करेगा, अकाउंट काम नहीं करेगा क्योंकि प्रॉक्सी काम नहीं कर रहा है, या विज्ञापन नहीं चलेगा। सेट किए गए हेल्थ चेक के साथ, सिस्टम स्वयं दोषपूर्ण प्रॉक्सी को रोटेशन से बाहर करता है और केवल स्थिर कनेक्शन का उपयोग करता है।

विशेष रूप से व्यावसायिक कार्यों के लिए हेल्थ चेक महत्वपूर्ण है: यदि आप इंस्टाग्राम पर 30 क्लाइंट अकाउंट चला रहे हैं, ओज़ोन पर प्रतिस्पर्धियों की कीमतें पार्स कर रहे हैं या फेसबुक विज्ञापनों पर विज्ञापन चला रहे हैं - एक गैर-कार्यात्मक प्रॉक्सी के कारण रुकावट पैसे और प्रतिष्ठा की कीमत चुकाती है।

प्रॉक्सी की कार्यशीलता की जांच के तरीके

प्रॉक्सी की जांच के कई स्तर हैं - सरल उपलब्धता जांच से लेकर गहरी गुमनामी और गति विश्लेषण तक। विधि का चयन आपके कार्यों पर निर्भर करता है: पार्सिंग के लिए मूल जांच पर्याप्त है, जबकि सोशल मीडिया में मल्टी-एकाउंटिंग के लिए भू-स्थान और गुमनामी की जांच की आवश्यकता होती है।

1. मूल उपलब्धता जांच (Ping Check)

सबसे सरल विधि - प्रॉक्सी के माध्यम से एक परीक्षण सर्वर पर HTTP अनुरोध भेजना और यह जांचना कि क्या उत्तर प्राप्त हुआ है। आमतौर पर सार्वजनिक सेवाओं का उपयोग किया जाता है जैसे httpbin.org, ip-api.com या अपना स्वयं का परीक्षण सर्वर।

क्या जांचा जाता है: प्रॉक्सी अनुरोधों का उत्तर देती है या नहीं (स्थिति 200 OK)। यह न्यूनतम जांच है, जो पूरी तरह से गैर-कार्यात्मक आईपी को बाहर करती है।

कब पर्याप्त है: सार्वजनिक डेटा की पार्सिंग, बिना कड़े सुरक्षा के वेबसाइटों से जानकारी इकट्ठा करना, बड़े कार्य जहां जांच की गति महत्वपूर्ण है।

2. प्रतिक्रिया गति की जांच (Latency Check)

प्रॉक्सी की प्रतिक्रिया समय को मापा जाता है - अनुरोध भेजने से लेकर उत्तर प्राप्त करने तक कितने मिलीसेकंड लगते हैं। धीमी प्रॉक्सी (3-5 सेकंड से अधिक) समय समाप्ति और प्लेटफार्मों पर संदेह पैदा कर सकती हैं।

क्या जांचा जाता है: प्रतिक्रिया का समय (latency) और गति की स्थिरता। 5000 मि.से. से अधिक latency वाली प्रॉक्सी आमतौर पर पूल से बाहर कर दी जाती हैं।

कब महत्वपूर्ण है: सोशल मीडिया (इंस्टाग्राम, टिकटॉक), विज्ञापन कार्यालय (फेसबुक विज्ञापन, गूगल विज्ञापन), ऐसे कार्य जहां पृष्ठों के लोड होने की गति महत्वपूर्ण है।

3. भू-स्थान और आईपी की प्रतिष्ठा की जांच

आईपी की घोषित देश और शहर के साथ संगतता की जांच की जाती है, साथ ही आईपी की प्रतिष्ठा (क्या यह काले सूचियों में है, क्या इसका उपयोग स्पैम के लिए किया जा रहा है)। रिज़िडेंट प्रॉक्सी के लिए यह महत्वपूर्ण है - प्लेटफार्म भू-स्थान के डेटा के साथ अकाउंट के डेटा की संगति की जांच करते हैं।

क्या जांचा जाता है: आईपी का देश और शहर, प्रदाता, स्पैम डेटाबेस में उपस्थिति (DNSBL, Spamhaus), कनेक्शन का प्रकार (residential/datacenter)।

कब महत्वपूर्ण है: सोशल मीडिया में मल्टी-एकाउंटिंग, ट्रैफिक का आर्बिट्राज, ऐसे अकाउंट के साथ काम करना जो विशिष्ट शहरों से जुड़े हैं (उदाहरण के लिए, अवितो पर विज्ञापन पोस्ट करना)।

4. गुमनामी की जांच (Anonymity Level)

प्रॉक्सी की गुमनामी के स्तर को निर्धारित किया जाता है - क्या यह आपके वास्तविक आईपी को प्रकट करने वाले हेडर (X-Forwarded-For, Via) को भेजता है। प्रॉक्सी तीन प्रकार की होती हैं: पारदर्शी (transparent), गुमनाम (anonymous) और एलीट (elite)।

क्या जांचा जाता है: X-Forwarded-For, X-Real-IP, Via, Proxy-Connection हेडर की उपस्थिति। व्यावसायिक कार्यों के लिए केवल एलीट प्रॉक्सी की आवश्यकता होती है।

कब अनिवार्य है: प्लेटफार्मों के साथ काम करते समय जो कठोर एंटी-फ्रॉड सुरक्षा रखते हैं (फेसबुक, गूगल, टिकटॉक), मल्टी-एकाउंटिंग, ट्रैफिक का आर्बिट्राज।

हेल्थ चेक की मूल सेटिंग: उपलब्धता की जांच

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

चरण 1: प्रॉक्सी की सूची तैयार करना

अपने प्रॉक्सी के साथ एक फ़ाइल बनाएं IP:PORT:USER:PASS या http://user:pass@ip:port प्रारूप में। प्रत्येक प्रॉक्सी एक नई पंक्ति में होनी चाहिए।

proxies.txt फ़ाइल का उदाहरण:

192.168.1.100:8080:user1:pass1
192.168.1.101:8080:user2:pass2
192.168.1.102:8080:user3:pass3

चरण 2: परीक्षण URL का चयन

उपलब्धता की जांच के लिए एक स्थिर सर्वर की आवश्यकता होती है, जो एक सरल उत्तर लौटाता है। लोकप्रिय विकल्प:

• httpbin.org/ip — प्रॉक्सी का आईपी पता JSON प्रारूप में लौटाता है
• ip-api.com/json — आईपी और भू-स्थान लौटाता है
• icanhazip.com — केवल आईपी लौटाता है (सबसे तेज़)
• आपका अपना सर्वर — यदि किसी विशिष्ट वेबसाइट की पहुंच की जांच की आवश्यकता है

मूल जांच के लिए httpbin.org/ip पर्याप्त है - यह स्थिर है और संरचित उत्तर लौटाता है।

चरण 3: जांच स्क्रिप्ट सेट करना

एक सरल स्क्रिप्ट बनाएं, जो प्रॉक्सी की सूची पढ़ती है, प्रत्येक के माध्यम से अनुरोध भेजती है और उत्तर की स्थिति की जांच करती है। यहाँ एक उदाहरण है Python में (इस तरह के कार्यों के लिए सबसे लोकप्रिय भाषा):

import requests
from concurrent.futures import ThreadPoolExecutor
import time

def check_proxy(proxy_line):
    """एक प्रॉक्सी की जांच"""
    try:
        # प्रॉक्सी की पंक्ति को पार्स करें
        parts = proxy_line.strip().split(':')
        proxy_url = f"http://{parts[2]}:{parts[3]}@{parts[0]}:{parts[1]}"
        
        proxies = {
            'http': proxy_url,
            'https': proxy_url
        }
        
        # 10 सेकंड का टाइमआउट के साथ अनुरोध भेजें
        start_time = time.time()
        response = requests.get('http://httpbin.org/ip', 
                              proxies=proxies, 
                              timeout=10)
        latency = (time.time() - start_time) * 1000  # मिलीसेकंड में
        
        if response.status_code == 200:
            return {
                'proxy': proxy_line,
                'status': 'working',
                'latency': round(latency, 2),
                'ip': response.json().get('origin')
            }
    except Exception as e:
        return {
            'proxy': proxy_line,
            'status': 'failed',
            'error': str(e)
        }

# प्रॉक्सी के साथ फ़ाइल पढ़ें
with open('proxies.txt', 'r') as f:
    proxies = f.readlines()

# सभी प्रॉक्सी को समानांतर में जांचें (20 एक साथ)
with ThreadPoolExecutor(max_workers=20) as executor:
    results = list(executor.map(check_proxy, proxies))

# कार्यशील प्रॉक्सी को सहेजें
working_proxies = [r for r in results if r and r['status'] == 'working']

with open('working_proxies.txt', 'w') as f:
    for proxy in working_proxies:
        f.write(proxy['proxy'])
        
print(f"जांच की गई: {len(proxies)}")
print(f"कार्यशील: {len(working_proxies)}")
print(f"गैर-कार्यशील: {len(proxies) - len(working_proxies)}")

यह स्क्रिप्ट सभी प्रॉक्सी को समानांतर में जांचती है (20 एक साथ), जो प्रक्रिया को कई गुना तेज करती है। परिणाम - केवल कार्यशील प्रॉक्सी के साथ working_proxies.txt फ़ाइल।

चरण 4: जांच का स्वचालन

ताकि हेल्थ चेक निरंतर काम करे, स्क्रिप्ट को शेड्यूल के अनुसार स्वचालित रूप से चलाने के लिए सेट करें:

Linux/Mac (cron):

# हर 30 मिनट में जांच
*/30 * * * * /usr/bin/python3 /path/to/check_proxies.py

Windows (कार्यक्रम शेड्यूलर):

• "कार्यक्रम शेड्यूलर" (Task Scheduler) खोलें
• एक नया कार्य बनाएं → ट्रिगर: हर 30 मिनट में
• क्रिया: अपने स्क्रिप्ट के पथ के साथ python.exe चलाना

उन्नत निगरानी: गति, भू-स्थान, गुमनामी

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

गति और स्थिरता की जांच

धीमी प्रॉक्सी (latency 3-5 सेकंड से अधिक) प्लेटफार्मों पर संदेह पैदा कर सकती है: इंस्टाग्राम और फेसबुक पृष्ठों के लोड होने के समय की निगरानी करते हैं, और धीमी कनेक्शन प्रॉक्सी के उपयोग का संकेत है। इसके अलावा, धीमी प्रॉक्सी आपकी कार्यक्षमता को धीमा कर सकती हैं और समय समाप्ति का कारण बन सकती हैं।

क्या जांचना है:

• Latency (प्रतिक्रिया का समय): अनुरोध से उत्तर तक का औसत समय। मानक: निवासी प्रॉक्सी के लिए 1000 मि.से. तक, डेटा केंद्रों के लिए 300 मि.से. तक
• लोडिंग गति: प्रॉक्सी के माध्यम से प्रति सेकंड कितने किलोबाइट डाउनलोड होते हैं। मानक: न्यूनतम 500 Kbps
• स्थिरता: लगातार 3-5 अनुरोधों की जांच - latency में अधिक उतार-चढ़ाव नहीं होना चाहिए (50% से अधिक का अंतर - खराब संकेत)

गति की विस्तृत जांच का उदाहरण:

def check_proxy_speed(proxy_url):
    """गति और स्थिरता की जांच"""
    latencies = []
    
    # स्थिरता की जांच के लिए 5 अनुरोध करें
    for i in range(5):
        try:
            start = time.time()
            response = requests.get('http://httpbin.org/ip',
                                  proxies={'http': proxy_url, 'https': proxy_url},
                                  timeout=10)
            latency = (time.time() - start) * 1000
            latencies.append(latency)
            time.sleep(0.5)  # अनुरोधों के बीच में विराम
        except:
            return None
    
    avg_latency = sum(latencies) / len(latencies)
    max_latency = max(latencies)
    min_latency = min(latencies)
    stability = (max_latency - min_latency) / avg_latency * 100
    
    return {
        'avg_latency': round(avg_latency, 2),
        'stability': round(stability, 2),  # % का अंतर
        'status': 'good' if avg_latency < 3000 and stability < 50 else 'slow'
    }

भू-स्थान की जांच

मल्टी-एकाउंटिंग के लिए यह महत्वपूर्ण है कि प्रॉक्सी का भू-स्थान अकाउंट के डेटा के साथ मेल खाता हो। यदि आप एक मॉस्को कंपनी के अकाउंट को व्लादिवोस्तोक की प्रॉक्सी के माध्यम से चला रहे हैं - तो यह प्लेटफार्म के लिए एक लाल झंडा है। भू-स्थान की जांच के लिए ip-api.com सेवा का उपयोग करें:

def check_proxy_geo(proxy_url):
    """प्रॉक्सी के भू-स्थान की जांच"""
    try:
        response = requests.get('http://ip-api.com/json',
                              proxies={'http': proxy_url, 'https': proxy_url},
                              timeout=10)
        data = response.json()
        
        return {
            'ip': data.get('query'),
            'country': data.get('country'),
            'city': data.get('city'),
            'isp': data.get('isp'),
            'proxy_type': data.get('proxy'),  # यदि प्रॉक्सी का पता लगाया गया है तो True
            'mobile': data.get('mobile')  # मोबाइल आईपी के लिए True
        }
    except:
        return None

प्रत्येक प्रॉक्सी के लिए भू-स्थान के डेटा को सहेजें और कार्यों के वितरण के समय उनका उपयोग करें: मॉस्को के अकाउंट - मॉस्को की प्रॉक्सी के माध्यम से, क्षेत्रीय विज्ञापन अवितो पर - आवश्यक शहर की प्रॉक्सी के माध्यम से।

गुमनामी की जांच

प्रॉक्सी तीन गुमनामी स्तरों की होती हैं: पारदर्शी (transparent), गुमनाम (anonymous) और एलीट (elite)। फेसबुक, इंस्टाग्राम, टिकटॉक और अन्य एंटी-फ्रॉड सुरक्षा वाले प्लेटफार्मों के साथ काम करने के लिए केवल एलीट प्रॉक्सी की आवश्यकता होती है - ये हेडर को प्रकट नहीं करते जो प्रॉक्सी के उपयोग को उजागर करते हैं।

क्या जांचना है:

• X-Forwarded-For, X-Real-IP, Via हेडर - अनुपस्थित होने चाहिए
• उत्तर में आईपी प्रॉक्सी के आईपी से मेल खाना चाहिए (आपका वास्तविक आईपी नहीं)
• User-Agent को बिना बदलाव के भेजा जाना चाहिए

def check_proxy_anonymity(proxy_url):
    """गुमनामी के स्तर की जांच"""
    try:
        response = requests.get('http://httpbin.org/headers',
                              proxies={'http': proxy_url, 'https': proxy_url},
                              timeout=10)
        headers = response.json()['headers']
        
        # प्रॉक्सी को उजागर करने वाले हेडर की उपस्थिति की जांच करें
        proxy_headers = ['X-Forwarded-For', 'X-Real-Ip', 'Via', 'Proxy-Connection']
        detected_headers = [h for h in proxy_headers if h in headers]
        
        if len(detected_headers) == 0:
            return 'elite'  # पूरी तरह से गुमनाम
        elif 'X-Forwarded-For' not in headers:
            return 'anonymous'  # आईपी को छिपाता है, लेकिन यह दिखाता है कि यह प्रॉक्सी है
        else:
            return 'transparent'  # वास्तविक आईपी को प्रकट करता है
    except:
        return None

व्यावसायिक कार्यों के लिए केवल एलीट प्रॉक्सी का उपयोग करें। मोबाइल प्रॉक्सी डिफ़ॉल्ट रूप से एलीट स्तर पर होती हैं, क्योंकि वे मोबाइल ऑपरेटरों के वास्तविक आईपी का उपयोग करती हैं।

स्वचालित रोटेशन: दोषपूर्ण प्रॉक्सी का प्रतिस्थापन

हेल्थ चेक तब वास्तव में उपयोगी होता है जब यह केवल प्रॉक्सी की जांच नहीं करता है, बल्कि स्वचालित रूप से गैर-कार्यशील को कार्यशील से बदलता है। यह निरंतर कार्यों के लिए महत्वपूर्ण है: मार्केटप्लेस की पार्सिंग, मूल्य निगरानी, सोशल मीडिया में ऑटो-पोस्टिंग।

रणनीति 1: प्राथमिकता के साथ पूल

दो प्रॉक्सी सूचियाँ बनाएं: मुख्य (working) और बैकअप (backup)। हेल्थ चेक लगातार मुख्य पूल की जांच करता है, और जब एक गैर-कार्यशील प्रॉक्सी का पता चलता है, तो इसे बैकअप पूल से प्रॉक्सी से बदल देता है।

कैसे काम करता है:

1. हेल्थ चेक हर 30 मिनट में मुख्य पूल की सभी प्रॉक्सी की जांच करता है
2. गैर-कार्यशील प्रॉक्सी "क्वारंटाइन" सूची में चली जाती हैं
3. बैकअप पूल से एक कार्यशील प्रॉक्सी ली जाती है और मुख्य में जोड़ी जाती है
4. 2-4 घंटे बाद क्वारंटाइन में प्रॉक्सी की पुनः जांच की जाती है - यदि वे काम करने लगते हैं, तो उन्हें बैकअप में वापस कर दिया जाता है

कार्यान्वयन का उदाहरण:

import json
from datetime import datetime, timedelta

class ProxyPool:
    def __init__(self):
        self.working = []  # मुख्य पूल
        self.backup = []   # बैकअप पूल
        self.quarantine = {}  # {proxy: timestamp जब क्वारंटाइन में गया}
    
    def check_and_rotate(self):
        """प्रॉक्सी की जांच और रोटेशन"""
        failed_proxies = []
        
        # मुख्य पूल की जांच करें
        for proxy in self.working:
            if not self.is_proxy_working(proxy):
                failed_proxies.append(proxy)
                self.quarantine[proxy] = datetime.now()
        
        # मुख्य पूल से गैर-कार्यशील को हटा दें
        self.working = [p for p in self.working if p not in failed_proxies]
        
        # आवश्यकतानुसार बैकअप से जोड़ें
        needed = len(failed_proxies)
        for i in range(needed):
            if len(self.backup) > 0:
                new_proxy = self.backup.pop(0)
                if self.is_proxy_working(new_proxy):
                    self.working.append(new_proxy)
        
        # क्वारंटाइन की जांच करें - यदि प्रॉक्सी क्वारंटाइन में 4 घंटे से अधिक है, तो उसकी जांच करें
        now = datetime.now()
        for proxy, quarantine_time in list(self.quarantine.items()):
            if now - quarantine_time > timedelta(hours=4):
                if self.is_proxy_working(proxy):
                    self.backup.append(proxy)
                del self.quarantine[proxy]
        
        self.save_state()
    
    def save_state(self):
        """पूल की स्थिति को सहेजें"""
        state = {
            'working': self.working,
            'backup': self.backup,
            'quarantine': {k: v.isoformat() for k, v in self.quarantine.items()}
        }
        with open('proxy_pool_state.json', 'w') as f:
            json.dump(state, f)

रणनीति 2: राउंड-रॉबिन के साथ अपवाद

एक सरल दृष्टिकोण: सभी प्रॉक्सी को बारी-बारी से (round-robin) उपयोग करें, लेकिन त्रुटि होने पर प्रॉक्सी को 30-60 मिनट के लिए अस्थायी रूप से रोटेशन से बाहर करें। यह उन कार्यों के लिए उपयुक्त है जहां गति महत्वपूर्ण है, न कि आदर्श स्थिरता।

कैसे काम करता है:

• प्रॉक्सी को क्रम से चुना जाता है: 1, 2, 3, 4, 1, 2, 3, 4...
• यदि प्रॉक्सी ने त्रुटि लौटाई, तो इसे 30 मिनट के लिए बाहर किया जाता है
• 30 मिनट के बाद प्रॉक्सी स्वचालित रूप से रोटेशन में लौटता है
• यदि प्रॉक्सी लगातार 3 बार गिरता है - तो इसे 4 घंटे के लिए बाहर किया जाता है

यह विधि पार्सिंग और बड़े कार्यों के लिए अच्छी है, जहां कुछ अनुरोधों को बिना गंभीर परिणामों के छोड़ना संभव है।

रणनीति 3: मेट्रिक्स के आधार पर वजनदार रोटेशन

उन्नत दृष्टिकोण: प्रत्येक प्रॉक्सी को मेट्रिक्स (गति, स्थिरता, सफलताओं की दर) के आधार पर "वजन" दिया जाता है। उच्च वजन वाली प्रॉक्सी का अधिक बार उपयोग किया जाता है, जबकि निम्न वजन वाली प्रॉक्सी का कम बार। यह महत्वपूर्ण कार्यों के लिए उपयुक्त है: मल्टी-एकाउंटिंग, आर्बिट्राज।

वजन का सूत्र:

weight = (success_rate * 0.5) + (speed_score * 0.3) + (uptime * 0.2)

जहाँ:
- success_rate: पिछले घंटे में सफल अनुरोधों का % (0-100)
- speed_score: 100 - (latency / 50) — जितना तेज़, उतना अधिक
- uptime: पिछले 24 घंटों में प्रॉक्सी की उपलब्धता का %

70 से अधिक वजन वाली प्रॉक्सी महत्वपूर्ण कार्यों (अकाउंट में लॉगिन) के लिए उपयोग की जाती हैं, 40-70 वजन वाली प्रॉक्सी सामान्य कार्यों के लिए, और 40 से कम वजन वाली प्रॉक्सी को अस्थायी रूप से बाहर किया जाता है।

प्रॉक्सी पूल के लिए हेल्थ चेक के लिए तैयार उपकरण

यदि आप अपनी स्क्रिप्ट लिखना नहीं चाहते हैं, तो तैयार समाधानों का उपयोग करें। इनमें से कई में वेब इंटरफ़ेस, API और लोकप्रिय उपकरणों के साथ एकीकरण होता है।

1. ProxyChecker by Proxy-Store

Windows/Linux के लिए एक मुफ्त उपयोगिता जिसमें ग्राफिकल इंटरफेस है। यह उपलब्धता, गति, गुमनामी और भू-स्थान की जांच करता है। HTTP, HTTPS, SOCKS4/5 का समर्थन करता है। परिणामों को TXT, CSV, JSON में निर्यात करता है।

फायदे: सरल इंटरफेस, तेज़ जांच (एक मिनट में 1000 प्रॉक्सी तक), देश और गति के अनुसार फ़िल्टर।

नुकसान: स्वचालित रोटेशन नहीं है, इसे मैन्युअल रूप से चलाना होगा।

2. Proxy Scraper & Checker

Python में एक ओपन-सोर्स प्रोजेक्ट जिसमें मुफ्त प्रॉक्सी का स्वचालित संग्रह और हेल्थ चेक है। प्रयोगों और परीक्षण के लिए उपयुक्त है, लेकिन व्यवसाय के लिए नहीं (मुफ्त प्रॉक्सी अस्थिर होती हैं)।

फायदे: मुफ्त, स्वचालित प्रॉक्सी संग्रह, अनुकूलन योग्य जांच।

नुकसान: मुफ्त प्रॉक्सी की गुणवत्ता कम है, बार-बार अवरोध।

3. Proxy Pool Manager (व्यावसायिक समाधान)

भुगतान सेवाएँ जो प्रॉक्सी का पूर्ण चक्र प्रबंधन करती हैं: हेल्थ चेक, स्वचालित रोटेशन, API, एंटी-डिटेक्ट ब्राउज़रों (Dolphin Anty, AdsPower, Multilogin) के साथ एकीकरण। उदाहरण: Bright Data Proxy Manager, Smartproxy Dashboard, Oxylabs Proxy Rotator।

फायदे: सब कुछ एक समाधान में, 24/7 समर्थन, तैयार एकीकरण।

नुकसान: उच्च लागत (50 डॉलर/माह से शुरू), प्रॉक्सी प्रदाता से बंधन।

4. एंटी-डिटेक्ट ब्राउज़रों में अंतर्निहित हेल्थ चेक

यदि आप मल्टी-एकाउंटिंग के लिए एंटी-डिटेक्ट ब्राउज़रों का उपयोग कर रहे हैं, तो उनमें से कई में प्रॉक्सी की अंतर्निहित जांच होती है:

• Dolphin Anty: प्रॉक्सी को प्रोफ़ाइल में जोड़ते समय उपलब्धता और गति की जांच
• AdsPower: प्रोफ़ाइल शुरू करने से पहले प्रॉक्सी की स्वचालित जांच
• Multilogin: गुमनामी की जांच के साथ अंतर्निहित प्रॉक्सी परीक्षक
• GoLogin: भू-स्थान और आईपी की प्रतिष्ठा की जांच

ये उपकरण SMM विशेषज्ञों और आर्बिट्राजर्स के लिए सुविधाजनक हैं, जो छोटे संख्या में अकाउंट (50-100 तक) के साथ काम करते हैं। बड़े वॉल्यूम के लिए, आपको अपना समाधान चाहिए।

व्यापार के लिए उपयोग के परिदृश्य

हम विशिष्ट मामलों का विश्लेषण करेंगे कि प्रॉक्सी पूल के हेल्थ चेक कैसे वास्तविक व्यावसायिक कार्यों को हल करता है।

केस 1: मार्केटप्लेस पर प्रतिस्पर्धियों की कीमतों की पार्सिंग

कार्य: वाइल्डबेरीज़ पर एक विक्रेता हर 2 घंटे में 500 प्रतिस्पर्धियों की कीमतों को पार्स करता है, ताकि अपने मूल्य को स्वचालित रूप से समायोजित किया जा सके। 50 प्रॉक्सी का पूल उपयोग किया जाता है।

हेल्थ चेक के बिना समस्या: कुछ प्रॉक्सी 100-200 अनुरोधों के बाद वाइल्डबेरीज़ द्वारा अवरुद्ध हो जाती हैं, पार्सर त्रुटियों के साथ गिरता है, डेटा अधूरा इकट्ठा होता है। हर 2-3 दिन में प्रॉक्सी को मैन्युअल रूप से जांचना और बदलना पड़ता है।

हेल्थ चेक के साथ समाधान: हर 30 मिनट में सिस्टम सभी 50 प्रॉक्सी की जांच वाइल्डबेरीज़ के लिए अनुरोध के साथ करता है। गैर-कार्यशील (स्थिति 403, 429 या टाइमआउट) स्वचालित रूप से 20 बैकअप प्रॉक्सी के पूल से बदल दिए जाते हैं। पार्सर हमेशा केवल कार्यशील प्रॉक्सी का उपयोग करता है।

परिणाम: पार्सिंग की स्थिरता 70% से बढ़कर 98% हो गई, मैन्युअल कार्य 2 घंटे प्रति दिन से घटकर 10 मिनट प्रति सप्ताह हो गया।

केस 2: SMM एजेंसी के लिए मल्टी-एकाउंटिंग

कार्य: SMM एजेंसी डॉल्फिन एंटी के माध्यम से 80 इंस्टाग्राम क्लाइंट अकाउंट चलाती है। प्रत्येक अकाउंट अपने प्रॉक्सी से जुड़ा होता है (1 अकाउंट = 1 प्रॉक्सी)।

हेल्थ चेक के बिना समस्या: यदि प्रॉक्सी काम करना बंद कर देती है, तो प्रबंधक केवल तभी जानता है जब वह क्लाइंट के अकाउंट में लॉगिन नहीं कर सकता। इस समय के दौरान, इंस्टाग्राम "संदिग्ध गतिविधि" के कारण अकाउंट को अवरुद्ध कर सकता है (आईपी का अचानक परिवर्तन)।

हेल्थ चेक के साथ समाधान: हर 60 मिनट में सिस्टम सभी 80 प्रॉक्सी की जांच करता है (उपलब्धता + भू-स्थान)। यदि प्रॉक्सी उत्तर नहीं देती है, तो प्रबंधक को टेलीग्राम में सूचना मिलती है, और डॉल्फिन एंटी में उसी शहर से बैकअप प्रॉक्सी पर प्रोफ़ाइल की सेटिंग स्वचालित रूप से अपडेट हो जाती है।

परिणाम: प्रॉक्सी से संबंधित समस्याओं के कारण अकाउंट के अवरोध की संख्या 5-7 प्रति माह से घटकर 0-1 हो गई। बचत: ~$500/माह अकाउंट की पुनर्प्राप्ति पर।

केस 3: फेसबुक विज्ञापनों पर ट्रैफिक का आर्बिट्राज

कार्य: आर्बिट्राजर 15 फेसबुक विज्ञापन अकाउंट के साथ विज्ञापन चलाता है। प्रत्येक अकाउंट अपने अमेरिका के निवासी प्रॉक्सी का उपयोग करता है।

हेल्थ चेक के बिना समस्या: फेसबुक आईपी की स्थिरता की कठोरता से जांच करता है। यदि प्रॉक्सी "कूदता" है (आईपी बदलता है या कनेक्शन में बाधा आती है), तो अकाउंट की जांच होती है या तुरंत बैन हो जाता है। अकाउंट के नुकसान की लागत: $200-500 (पुनर्प्राप्ति + अभियानों का ठहराव)।

हेल्थ चेक के साथ समाधान: हर 15 मिनट में जांच: उपलब्धता, गति (latency को स्थिर होना चाहिए), गुमनामी (एलीट स्तर)। यदि प्रॉक्सी अस्थिरता दिखाती है (latency में 30% से अधिक का अंतर), तो इसे रोटेशन से बाहर कर दिया जाता है। महत्वपूर्ण अकाउंट के लिए केवल 24 घंटों में 99.5% से अधिक uptime वाली प्रॉक्सी का उपयोग किया जाता है।

परिणाम: प्रॉक्सी से संबंधित समस्याओं के कारण बैन की संख्या 2-3 प्रति माह से घटकर 0 हो गई। ROI स्थिर अभियानों के कारण 15% बढ़ गया।

हेल्थ चेक सेट करते समय सामान्य गलतियाँ

हम सामान्य गलतियों का विश्लेषण करेंगे, जो हेल्थ चेक की प्रभावशीलता को कम करती हैं या नई समस्याएं उत्पन्न करती हैं।

गलती 1: बहुत बार जांच करना

समस्या: हर 1-5 मिनट में जांच करना प्रॉक्सी और परीक्षण सेवाओं पर भारी लोड डालता है। सार्वजनिक सेवाएँ (httpbin.org, ip-api.com) आपके आईपी को फ्लडिंग के लिए अवरुद्ध कर सकती हैं। इसके अलावा, बार-बार जांच करने से ट्रैफिक का उपयोग होता है - यदि आपके पास 100 प्रॉक्सी हैं और हर मिनट जांच करते हैं, तो यह 144,000 अनुरोध प्रति दिन है।

समाधान: स्थिर प्रॉक्सी के लिए हर 30-60 मिनट में जांच करना पर्याप्त है। महत्वपूर्ण कार्यों के लिए - हर 15 मिनट। यदि बार-बार जांच की आवश्यकता है, तो सार्वजनिक सेवाओं के बजाय अपने परीक्षण सर्वर का उपयोग करें।

गलती 2: केवल उपलब्धता की जांच करना

समस्या: प्रॉक्सी अनुरोधों का उत्तर दे सकता है (स्थिति 200 OK), लेकिन धीमा हो सकता है (latency 10 सेकंड) या गलत भू-स्थान हो सकता है। व्यावसायिक कार्यों के लिए ऐसी प्रॉक्सी बेकार या यहां तक कि खतरनाक होती है।

समाधान: समग्र रूप से जांचें - उपलब्धता + गति + भू-स्थान + गुमनामी। मल्टी-एकाउंटिंग के लिए भू-स्थान महत्वपूर्ण है, पार्सिंग के लिए गति, आर्बिट्राज के लिए - सब कुछ एक साथ।

गलती 3: क्वारंटाइन की अनुपस्थिति

समस्या: प्रॉक्सी सर्वर के पुनः लोड होने या प्रदाता की समस्याओं के कारण अस्थायी रूप से "गिर" सकती है, लेकिन 1-2 घंटे बाद फिर से काम करने लगती है। यदि ऐसी प्रॉक्सी को तुरंत पूल से हटा दिया जाए, तो आप कार्यशील आईपी खो देते हैं।

समाधान: क्वारंटाइन प्रणाली का उपयोग करें - गैर-कार्यशील प्रॉक्सी को हटा नहीं किया जाता, बल्कि 2-4 घंटे के लिए बाहर किया जाता है। इस समय के बाद, उन्हें फिर से जांचा जाता है, और यदि वे काम करने लगते हैं - तो उन्हें पूल में वापस कर दिया जाता है।

गलती 4: स्थिरता के मेट्रिक्स की अनदेखी

समस्या: प्रॉक्सी काम कर सकती है, लेकिन अस्थिर हो सकती है - latency 500 मि.से. से 5000 मि.से. तक कूदता है, अवधि...