curl और wget में प्रॉक्सी सेटअप: पूर्ण मार्गदर्शिका

```html

वेबसाइटों को पार्स करते समय, API अनुरोधों का स्वचालन करते समय या मार्केटप्लेस पर प्रतिस्पर्धियों की कीमतों की निगरानी करते समय, आप अनिवार्य रूप से IP द्वारा अवरोधों का सामना करेंगे। curl और wget उपयोगिताएँ - कमांड लाइन में HTTP अनुरोधों के साथ काम करने के लिए मानक उपकरण हैं, और इनमें प्रॉक्सी का सही सेटअप अवरोधों को पार करने के लिए महत्वपूर्ण है। इस लेख में, हम curl और wget में प्रॉक्सी के उपयोग के सभी तरीकों का विश्लेषण करेंगे: बुनियादी कमांड से लेकर IP रोटेशन और त्रुटि हैंडलिंग के उन्नत परिदृश्यों तक।

curl और wget में प्रॉक्सी का बुनियादी सिंटैक्स

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

curl में प्रॉक्सी का उपयोग

curl में प्रॉक्सी को -x या --proxy पैरामीटर के माध्यम से निर्दिष्ट किया जाता है। कमांड का बुनियादी प्रारूप:

curl -x http://proxy-server:port http://example.com

वास्तविक प्रॉक्सी सर्वर के साथ एक विशिष्ट उदाहरण:

curl -x http://45.130.123.45:8080 http://api.ipify.org

यह कमांड api.ipify.org (एक सेवा जो आपका IP पता लौटाती है) पर अनुरोध को निर्दिष्ट प्रॉक्सी सर्वर के माध्यम से भेजेगी। आप प्रॉक्सी का IP देखेंगे, न कि आपका वास्तविक पता।

wget में प्रॉक्सी का उपयोग

wget में प्रॉक्सी को -e use_proxy=yes और पर्यावरण चर के माध्यम से सेट किया जाता है, या सीधे विकल्पों के माध्यम से:

wget -e use_proxy=yes -e http_proxy=http://45.130.123.45:8080 http://example.com

या पर्यावरण चर के माध्यम से एक संक्षिप्त विकल्प (इस पर नीचे के अनुभाग में अधिक जानकारी):

export http_proxy="http://45.130.123.45:8080"
wget http://example.com

प्रॉक्सी सर्वर पर प्रमाणीकरण

अधिकांश व्यावसायिक प्रॉक्सी सेवाएँ लॉगिन और पासवर्ड के माध्यम से प्रमाणीकरण की आवश्यकता होती हैं। यह प्रॉक्सी को अनधिकृत उपयोग से बचाता है और प्रत्येक ग्राहक के ट्रैफ़िक को ट्रैक करने की अनुमति देता है। चलिए देखते हैं कि curl और wget में क्रेडेंशियल्स को कैसे पास किया जाए।

curl में प्रमाणीकरण

curl में, लॉगिन और पासवर्ड को प्रॉक्सी सर्वर के URL में सीधे या -U पैरामीटर के माध्यम से निर्दिष्ट किया जा सकता है:

# तरीका 1: URL में लॉगिन और पासवर्ड
curl -x http://username:password@proxy-server:port http://example.com

# तरीका 2: -U पैरामीटर के माध्यम से
curl -x http://proxy-server:port -U username:password http://example.com

क्रेडेंशियल्स के साथ एक विशिष्ट उदाहरण:

curl -x http://user123:pass456@45.130.123.45:8080 http://api.ipify.org

एक महत्वपूर्ण बिंदु: यदि पासवर्ड में विशेष वर्ण (@, :, /, ?), हैं, तो उन्हें URL प्रारूप में एन्कोड करना आवश्यक है। उदाहरण के लिए, @ प्रतीक को %40 से बदल दिया जाता है:

# यदि पासवर्ड में @ है: pass@456
curl -x http://user123:pass%40456@45.130.123.45:8080 http://api.ipify.org

wget में प्रमाणीकरण

wget में प्रमाणीकरण को --proxy-user और --proxy-password पैरामीटर के माध्यम से सेट किया जाता है:

wget --proxy-user=username --proxy-password=password \
     -e use_proxy=yes -e http_proxy=http://45.130.123.45:8080 \
     http://example.com

या URL में क्रेडेंशियल्स के साथ पर्यावरण चर के माध्यम से:

export http_proxy="http://username:password@45.130.123.45:8080"
wget http://example.com

विभिन्न प्रकार के प्रॉक्सी के साथ काम करना: HTTP, HTTPS, SOCKS5

प्रॉक्सी सर्वर विभिन्न प्रोटोकॉल पर काम करते हैं, और प्रकार का चयन कार्य पर निर्भर करता है। HTTP प्रॉक्सी सरल अनुरोधों के लिए उपयुक्त होते हैं, HTTPS एन्क्रिप्शन प्रदान करते हैं, और SOCKS5 निम्न स्तर पर काम करते हैं और किसी भी ट्रैफ़िक का समर्थन करते हैं। Wildberries या Ozon जैसे मार्केटप्लेस को पार्स करते समय अक्सर रेसिडेंशियल प्रॉक्सी का उपयोग किया जाता है, जो इन प्रोटोकॉल में से किसी एक पर काम कर सकते हैं।

HTTP और HTTPS प्रॉक्सी

HTTP प्रॉक्सी सबसे सामान्य प्रकार हैं। वे HTTP प्रोटोकॉल के स्तर पर काम करते हैं और अधिकांश वेब पार्सिंग कार्यों के लिए उपयुक्त होते हैं:

# curl में HTTP प्रॉक्सी
curl -x http://proxy-server:8080 http://example.com

# curl में HTTPS प्रॉक्सी (सुरक्षित कनेक्शनों के लिए)
curl -x https://proxy-server:8080 https://example.com

महत्वपूर्ण: भले ही लक्षित वेबसाइट HTTPS का उपयोग कर रही हो, प्रॉक्सी HTTP हो सकता है। Curl स्वचालित रूप से CONNECT विधि के माध्यम से एक टनल स्थापित करेगा:

# HTTPS साइट के लिए HTTP प्रॉक्सी (सही ढंग से काम करता है)
curl -x http://proxy-server:8080 https://secure-site.com

SOCKS5 प्रॉक्सी

SOCKS5 एक अधिक सार्वभौमिक प्रोटोकॉल है, जो TCP स्तर पर काम करता है और किसी भी प्रकार के ट्रैफ़िक (HTTP, HTTPS, FTP, यहां तक कि UDP) का समर्थन करता है। यह SOCKS5 को जटिल स्वचालन कार्यों के लिए आदर्श विकल्प बनाता है:

# curl में SOCKS5
curl -x socks5://proxy-server:1080 http://example.com

# प्रमाणीकरण के साथ SOCKS5
curl -x socks5://username:password@proxy-server:1080 http://example.com

# SOCKS5h (प्रॉक्सी के माध्यम से DNS का समाधान)
curl -x socks5h://proxy-server:1080 http://example.com

socks5 और socks5h के बीच का अंतर: पहले मामले में DNS अनुरोध आपके कंप्यूटर से होते हैं, दूसरे में - प्रॉक्सी सर्वर के माध्यम से। यदि आप अपनी गतिविधियों को पूरी तरह से छिपाना चाहते हैं, जिसमें DNS अनुरोध शामिल हैं, तो socks5h का उपयोग करें।

wget में SOCKS5 का समर्थन सीमित है, इसलिए ऐसे कार्यों के लिए curl या proxychains जैसी अतिरिक्त उपयोगिताओं का उपयोग करना बेहतर है।

टिप: मार्केटप्लेस (Wildberries, Ozon, Yandex.Market) को पार्स करते समय, HTTP/HTTPS प्रोटोकॉल के साथ रेसिडेंशियल या मोबाइल प्रॉक्सी का उपयोग करने की सिफारिश की जाती है - ये अवरोधों के तहत कम आते हैं, क्योंकि इनमें वास्तविक उपयोगकर्ताओं के IP होते हैं।

पर्यावरण चर के माध्यम से प्रॉक्सी सेटअप

यदि आप नियमित रूप से प्रॉक्सी के माध्यम से काम करते हैं, तो हर कमांड में पैरामीटर निर्दिष्ट करने के बजाय एक बार पर्यावरण चर सेट करना अधिक सुविधाजनक है। Curl और wget स्वचालित रूप से इन चर को पढ़ते हैं।

वर्तमान सत्र के लिए सेटअप

टर्मिनल में चर को एक्सपोर्ट करें (ये सत्र बंद होने तक लागू होते हैं):

# HTTP ट्रैफ़िक के लिए
export http_proxy="http://username:password@proxy-server:8080"

# HTTPS ट्रैफ़िक के लिए
export https_proxy="http://username:password@proxy-server:8080"

# FTP ट्रैफ़िक के लिए
export ftp_proxy="http://username:password@proxy-server:8080"

# SOCKS5 के लिए
export all_proxy="socks5://username:password@proxy-server:1080"

इसके बाद curl और wget स्वचालित रूप से प्रॉक्सी का उपयोग करेंगे:

# प्रॉक्सी स्वचालित रूप से लागू होगा
curl http://api.ipify.org
wget http://example.com

.bashrc या .zshrc में स्थायी सेटअप

ताकि प्रॉक्सी हर टर्मिनल के लॉन्च पर लागू हो, अपनी शेल की कॉन्फ़िगरेशन फ़ाइल में चर जोड़ें:

# संपादक में फ़ाइल खोलें
nano ~/.bashrc  # bash के लिए
# या
nano ~/.zshrc   # zsh के लिए

# फ़ाइल के अंत में जोड़ें:
export http_proxy="http://username:password@proxy-server:8080"
export https_proxy="http://username:password@proxy-server:8080"

# परिवर्तनों को सहेजें और लागू करें:
source ~/.bashrc

अपवाद: no_proxy

कभी-कभी कुछ पते को प्रॉक्सीकरण से बाहर करना आवश्यक होता है (जैसे, localhost या आंतरिक सेवाएँ):

export no_proxy="localhost,127.0.0.1,192.168.0.0/16,.local"

अब इन पते के लिए अनुरोध सीधे जाएंगे, प्रॉक्सी को बाईपास करते हुए।

bash स्क्रिप्ट में प्रॉक्सी का रोटेशन

बड़े पैमाने पर पार्सिंग करते समय (जैसे, Wildberries पर हजारों उत्पाद कार्ड से कीमतें एकत्र करना) एक प्रॉक्सी का उपयोग अवरोध का कारण बनेगा। समाधान - IP पते का रोटेशन। चलिए देखते हैं कि इसे bash स्क्रिप्ट में कैसे लागू किया जाए।

प्रॉक्सी की सूची से सरल रोटेशन

प्रॉक्सी सर्वरों की सूची के साथ proxies.txt फ़ाइल बनाएं (प्रत्येक एक पंक्ति में):

http://user1:pass1@proxy1.example.com:8080
http://user2:pass2@proxy2.example.com:8080
http://user3:pass3@proxy3.example.com:8080

प्रॉक्सी के अनुक्रमिक रोटेशन के लिए स्क्रिप्ट:

#!/bin/bash

# पार्सिंग के लिए URL की सूची वाली फ़ाइल
urls_file="urls.txt"
# प्रॉक्सी की सूची वाली फ़ाइल
proxies_file="proxies.txt"

# प्रॉक्सी को एक ऐरे में पढ़ें
mapfile -t proxies < "$proxies_file"
proxy_count=${#proxies[@]}
current_proxy=0

# प्रत्येक URL को प्रोसेस करें
while IFS= read -r url; do
    # राउंड रॉबिन के अनुसार प्रॉक्सी चुनें
    proxy="${proxies[$current_proxy]}"
    
    echo "$url पर $proxy के माध्यम से अनुरोध"
    curl -x "$proxy" -s "$url" -o "output_$(basename $url).html"
    
    # अगले प्रॉक्सी पर स्विच करें
    current_proxy=$(( (current_proxy + 1) % proxy_count ))
    
    # अनुरोधों के बीच में विराम (1-3 सेकंड)
    sleep $((RANDOM % 3 + 1))
done < "$urls_file"

यह स्क्रिप्ट सूची से प्रॉक्सी का अनुक्रमिक रूप से उपयोग करती है, अंतिम के बाद पहले पर लौटती है। अनुरोधों के बीच यादृच्छिक विराम गतिविधि को अधिक स्वाभाविक बनाता है।

यादृच्छिक प्रॉक्सी का चयन

अधिक अप्रत्याशितता के लिए, आप यादृच्छिक रूप से प्रॉक्सी का चयन कर सकते हैं:

#!/bin/bash

proxies_file="proxies.txt"
mapfile -t proxies < "$proxies_file"
proxy_count=${#proxies[@]}

while IFS= read -r url; do
    # यादृच्छिक प्रॉक्सी का चयन
    random_index=$((RANDOM % proxy_count))
    proxy="${proxies[$random_index]}"
    
    echo "$url पर प्रॉक्सी #$random_index के माध्यम से अनुरोध"
    curl -x "$proxy" -s "$url" -o "output_$(date +%s).html"
    
    sleep $((RANDOM % 3 + 1))
done < "urls.txt"

प्रॉक्सी सेवा के API के माध्यम से स्वचालित रोटेशन

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

# स्वचालित रोटेशन के साथ प्रॉक्सी
# IP हर अनुरोध पर बदलता है
curl -x http://username:password@rotating.proxy.com:8080 http://api.ipify.org
curl -x http://username:password@rotating.proxy.com:8080 http://api.ipify.org

# ऊपर के दो अनुरोध अलग-अलग IP पते प्राप्त करेंगे

यह बड़े पैमाने पर पार्सिंग के लिए सबसे सुविधाजनक तरीका है - प्रॉक्सी की सूची को मैन्युअल रूप से प्रबंधित करने की आवश्यकता नहीं है।

प्रॉक्सी के माध्यम से हेडर और User-Agent भेजना

आधुनिक वेबसाइटें केवल IP पते का ही नहीं, बल्कि HTTP अनुरोध के हेडर का भी विश्लेषण करती हैं। User-Agent की अनुपस्थिति या संदिग्ध हेडर का उपयोग करने से गुणवत्ता वाली प्रॉक्सी का उपयोग करते समय भी अवरोध हो सकता है। चलिए देखते हैं कि curl और wget में हेडर को सही तरीके से कैसे सेट करें।

curl में User-Agent

User-Agent एक हेडर है, जो ब्राउज़र और ऑपरेटिंग सिस्टम की पहचान करता है। Curl डिफ़ॉल्ट रूप से अपना खुद का User-Agent (curl/7.x.x) भेजता है, जो स्वचालन को तुरंत प्रकट करता है। इसे वास्तविक ब्राउज़र से बदलें:

# Windows पर Chrome
curl -x http://proxy:8080 \
     -A "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36" \
     http://example.com

# macOS पर Firefox
curl -x http://proxy:8080 \
     -A "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:121.0) Gecko/20100101 Firefox/121.0" \
     http://example.com

अतिरिक्त हेडर

अधिक यथार्थवादी अनुरोध के लिए सामान्य ब्राउज़र हेडर जोड़ें:

curl -x http://proxy:8080 \
     -H "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0" \
     -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8" \
     -H "Accept-Language: hi-IN,hi;q=0.9,en;q=0.8" \
     -H "Accept-Encoding: gzip, deflate, br" \
     -H "Connection: keep-alive" \
     -H "Upgrade-Insecure-Requests: 1" \
     http://example.com

wget में User-Agent

wget में User-Agent को --user-agent पैरामीटर के माध्यम से सेट किया जाता है:

wget --user-agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0" \
     -e use_proxy=yes -e http_proxy=http://proxy:8080 \
     http://example.com

स्क्रिप्ट में User-Agent का यादृच्छिककरण

बड़े पैमाने पर पार्सिंग के लिए, User-Agent को बदलना उपयोगी होता है, ताकि अनुरोध विभिन्न उपयोगकर्ताओं के रूप में दिखें:

#!/bin/bash

# User-Agent का ऐरे
user_agents=(
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0 Safari/537.36"
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) Safari/605.1.15"
    "Mozilla/5.0 (X11; Linux x86_64) Firefox/121.0"
    "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) Safari/604.1"
)

while IFS= read -r url; do
    # यादृच्छिक User-Agent
    random_ua=${user_agents[$RANDOM % ${#user_agents[@]}]}
    
    curl -x http://proxy:8080 -A "$random_ua" -s "$url"
    sleep 2
done < "urls.txt"

समस्याओं का निदान और त्रुटियों को संभालना

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

प्रॉक्सी की कार्यक्षमता की जांच

प्रॉक्सी की जांच करने का सबसे सरल तरीका है, एक सेवा का अनुरोध करना जो आपका IP लौटाती है:

# HTTP प्रॉक्सी की जांच
curl -x http://proxy:8080 http://api.ipify.org

# SOCKS5 प्रॉक्सी की जांच
curl -x socks5://proxy:1080 http://api.ipify.org

# विस्तृत जानकारी के साथ
curl -x http://proxy:8080 -v http://api.ipify.org

-v (verbose) पैरामीटर कनेक्शन के विवरण, हेडर और त्रुटियों को दिखाएगा।

टाइमआउट को संभालना

धीमी प्रॉक्सी या ओवरलोडेड सर्वर टाइमआउट का कारण बन सकते हैं। उचित समय सीमा निर्धारित करें:

# कनेक्शन टाइमआउट 10 सेकंड, कुल टाइमआउट 30 सेकंड
curl -x http://proxy:8080 --connect-timeout 10 --max-time 30 http://example.com

# wget में
wget --timeout=30 --tries=3 -e http_proxy=http://proxy:8080 http://example.com

स्क्रिप्ट में त्रुटियों का स्वचालित प्रबंधन

त्रुटियों के मामले में अगले प्रॉक्सी पर स्वचालित रूप से स्विच करने के लिए पार्सिंग के लिए स्क्रिप्ट:

#!/bin/bash

proxies_file="proxies.txt"
mapfile -t proxies < "$proxies_file"

fetch_with_retry() {
    local url=$1
    local max_attempts=3
    
    for proxy in "${proxies[@]}"; do
        echo "प्रॉक्सी के माध्यम से प्रयास: $proxy"
        
        if curl -x "$proxy" \
                --connect-timeout 10 \
                --max-time 30 \
                -s -f "$url" -o output.html; then
            echo "प्रॉक्सी के साथ सफलता: $proxy"
            return 0
        else
            echo "प्रॉक्सी के साथ त्रुटि: $proxy, अगले पर प्रयास कर रहे हैं"
        fi
    done
    
    echo "$url के लिए सभी प्रॉक्सी अनुपलब्ध हैं"
    return 1
}

# उपयोग
fetch_with_retry "http://example.com/page1"

-f पैरामीटर curl को HTTP स्थिति 4xx और 5xx पर त्रुटि लौटाने के लिए मजबूर करता है, जिससे नेटवर्क त्रुटियों के साथ-साथ एप्लिकेशन स्तर पर अवरोधों को संभालना संभव होता है।

डिबगिंग के लिए लॉगिंग

समस्याओं के विश्लेषण के लिए अनुरोधों के विस्तृत लॉग रखें:

# उत्तर के हेडर को सहेजना
curl -x http://proxy:8080 -D headers.txt http://example.com

# बातचीत का पूर्ण लॉग
curl -x http://proxy:8080 -v http://example.com 2>&1 | tee curl.log

# केवल HTTP स्थिति
curl -x http://proxy:8080 -o /dev/null -s -w "%{http_code}\n" http://example.com

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

चलिए वास्तविक कार्यों पर विचार करते हैं, जहाँ curl और wget प्रॉक्सी के साथ विशिष्ट व्यावसायिक समस्याओं को हल करते हैं।

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

कार्य: Wildberries से प्रतिस्पर्धियों के 500 उत्पादों की कीमतें एकत्र करना ताकि मूल्य रणनीति का विश्लेषण किया जा सके। Wildberries एक IP से बड़े पैमाने पर अनुरोधों को सक्रिय रूप से अवरुद्ध करता है।

समाधान: रोटेशन और User-Agent के यादृच्छिककरण के साथ रेसिडेंशियल प्रॉक्सी का उपयोग:

#!/bin/bash

# स्वचालित रोटेशन के साथ प्रॉक्सी
PROXY="http://user:pass@rotating-residential.proxy.com:8080"

# User-Agent का ऐरे
user_agents=(
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0"
    "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0) Safari/604.1"
)

# उत्पादों के ID को फ़ाइल से पढ़ें
while IFS= read -r product_id; do
    ua=${user_agents[$RANDOM % ${#user_agents[@]}]}
    
    curl -x "$PROXY" \
         -A "$ua" \
         -H "Accept-Language: hi-IN,hi;q=0.9" \
         -s "https://www.wildberries.ru/catalog/${product_id}/detail.aspx" \
         -o "products/${product_id}.html"
    
    echo "उत्पाद $product_id डाउनलोड किया गया"
    sleep $((RANDOM % 5 + 3))  # 3-8 सेकंड का विराम
done < product_ids.txt

विभिन्न क्षेत्रों से API की उपलब्धता की निगरानी

कार्य: यह जांचना कि आपके सेवा का API विभिन्न देशों के उपयोगकर्ताओं के लिए कैसे काम करता है (भौगोलिक अवरोध, प्रतिक्रिया की गति)।

समाधान: आवश्यक देशों से IP के साथ प्रॉक्सी:

#!/bin/bash

# विभिन्न देशों से प्रॉक्सी
declare -A proxies=(
    ["US"]="http://user:pass@us-proxy.com:8080"
    ["DE"]="http://user:pass@de-proxy.com:8080"
    ["JP"]="http://user:pass@jp-proxy.com:8080"
)

API_URL="https://api.yourservice.com/v1/status"

for country in "${!proxies[@]}"; do
    echo "$country से जांचना..."
    
    response_time=$(curl -x "${proxies[$country]}" \
                         -s -o /dev/null \
                         -w "%{time_total}" \
                         "$API_URL")
    
    http_code=$(curl -x "${proxies[$country]}" \
                     -s -o /dev/null \
                     -w "%{http_code}" \
                     "$API_URL")
    
    echo "$country: HTTP $http_code, प्रतिक्रिया का समय ${response_time}s"
done

wget के माध्यम से फ़ाइलें डाउनलोड करना प्रॉक्सी के रोटेशन के साथ

कार्य: एक वेबसाइट से फ़ाइलों का संग्रह (उत्पाद छवियाँ, दस्तावेज़) डाउनलोड करना, जो एक IP के लिए गति को सीमित करती है।

#!/bin/bash

proxies_file="proxies.txt"
mapfile -t proxies < "$proxies_file"
proxy_count=${#proxies[@]}
current=0

while IFS= read -r file_url; do
    proxy="${proxies[$current]}"
    filename=$(basename "$file_url")
    
    echo "$filename को प्रॉक्सी #$current के माध्यम से डाउनलोड कर रहे हैं"
    
    wget --proxy-user=username --proxy-password=password \
         -e use_proxy=yes -e http_proxy="$proxy" \
         -O "downloads/$filename" \
         "$file_url"
    
    current=$(( (current + 1) % proxy_count ))
    sleep 2
done < file_urls.txt

विभिन्न GEO में विज्ञापन क्रिएटिव का परीक्षण

कार्य: यह जांचना कि Facebook Ads के विज्ञापन कैसे दिखते हैं, अमेरिका, कनाडा और ब्रिटेन के उपयोगकर्ताओं के लिए (विभिन्न मुद्राएँ, भाषाएँ, ऑफ़र्स की उपलब्धता)।

#!/bin/bash

# यथार्थता के लिए विभिन्न देशों से मोबाइल प्रॉक्सी
declare -A mobile_proxies=(
    ["US"]="http://user:pass@us-mobile.proxy.com:8080"
    ["CA"]="http://user:pass@ca-mobile.proxy.com:8080"
    ["GB"]="http://user:pass@gb-mobile.proxy.com:8080"
)

AD_URL="https://www.facebook.com/ads/library/?id=YOUR_AD_ID"

for country in "${!mobile_proxies[@]}"; do
    curl -x "${mobile_proxies[$country]}" \
         -A "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0) Safari/604.1" \
         -H "Accept-Language: en-US,en;q=0.9" \
         -s "$AD_URL" \
         -o "ads_preview_${country}.html"
    
    echo "$country के लिए प्रीव्यू सहेजा गया"
done

ऐसे कार्यों के लिए मोबाइल प्रॉक्सी विशेष रूप से प्रभावी होते हैं, क्योंकि वे वास्तविक स्मार्टफोन उपयोगकर्ताओं का अनुकरण करते हैं और Facebook के एंटी-फ्रॉड सिस्टम द्वारा कम संदेह उत्पन्न करते हैं।

अर्थव्यवस्था के लिए महत्वपूर्ण: प्रॉक्सी के माध्यम से विज्ञापन क्रिएटिव का परीक्षण करते समय मोबाइल IP और मोबाइल उपकरणों के लिए उपयुक्त User-Agent का उपयोग करें। Facebook डेटा की निरंतरता का विश्लेषण करता है (User-Agent द्वारा उपकरण का प्रकार IP के प्रकार से मेल खाना चाहिए)।

वेबसाइट की उपलब्धता की स्वचालित जांच

कार्य: हर 5 मिनट में आपकी वेबसाइट की उपलब्धता की निगरानी करना, वास्तविक उपयोगकर्ताओं से अनुरोधों का अनुकरण करना (सर्वर IP से नहीं)।

#!/bin/bash

PROXY="http://user:pass@residential.proxy.com:8080"
SITE_URL="https://yoursite.com"
LOG_FILE="uptime.log"

while true; do
    timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    
    http_code=$(curl -x "$PROXY" \
                     -s -o /dev/null \
                     -w "%{http_code}" \
                     --max-time 10 \
                     "$SITE_URL")
    
    if [ "$http_code" -eq 200 ]; then
        echo "[$timestamp] OK - HTTP $http_code" >> "$LOG_FILE"
    else
        echo "[$timestamp] ERROR - HTTP $http_code" >> "$LOG_FILE"
        # अलर्ट भेजना (उदाहरण के लिए, Telegram API के माध्यम से)
        curl -s "https://api.telegram.org/botTOKEN/sendMessage" \
             -d "chat_id=CHAT_ID&text=वेबसाइट अनुपलब्ध: HTTP $http_code"
    fi
    
    sleep 300  # 5 मिनट
done

निष्कर्ष

Curl और wget HTTP अनुरोधों के स्वचालन के लिए शक्तिशाली उपकरण हैं, और प्रॉक्सी का सही सेटअप उन्हें पार्सिंग, निगरानी और परीक्षण के लिए अनिवार्य बनाता है। हमने सभी प्रमुख पहलुओं का विश्लेषण किया: बुनियादी सिंटैक्स से लेकर IP रोटेशन, त्रुटियों के प्रबंधन और हेडर के यादृच्छिककरण के उन्नत परिदृश्यों तक।

लेख से मुख्य निष्कर्ष:

curl में प्रॉक्सी सेटअप के लिए -x पैरामीटर और पर्यावरण चर का उपयोग करें
कार्य के अनुसार प्रॉक्सी का प्रकार चुनें: सरल अनुरोधों के लिए HTTP, बहुपरकारिता के लिए SOCKS5
हमेशा मानक User-Agent को यथार्थवादी ब्राउज़र में बदलें
बड़े पैमाने पर पार्सिंग के लिए प्रॉक्सी का रोटेशन लागू करें - यह अवरोधों को पार करने के लिए महत्वपूर्ण है
प्रोडक्शन स्क्रिप्ट में त्रुटियों और टाइमआउट को संभालने का कार्यान्वयन करें
अनुरोधों के बीच यादृच्छिक विराम जोड़ें ताकि मानव व्यवहार का अनुकरण किया जा सके

उच्च स्तर की गुमनामी और अवरोधों के न्यूनतम जोखिम की आवश्यकता वाले कार्यों (मार्केटप्लेस पार्सिंग, विज्ञापन परीक्षण, प्रतिस्पर्धियों की निगरानी) के लिए, हम रेसिडेंशियल प्रॉक्सी का उपयोग करने की सिफारिश करते हैं। उनके पास वास्तविक घरेलू उपयोगकर्ताओं के IP होते हैं, जो आपके अनुरोधों को सामान्य ट्रैफ़िक के रूप में पहचानने योग्य बनाते हैं और बैन लिस्ट में आने की संभावना को काफी कम करते हैं।

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

```

curl और wget में प्रॉक्सी सेटअप: पार्सिंग के लिए उदाहरणों के साथ पूर्ण गाइड