गो (Golang) में प्रॉक्सी सेटअप: http.Client, SOCKS5 और आईपी रोटेशन के लिए पार्सिंग और ऑटोमेशन

```html

यदि आप एक पार्सर लिख रहे हैं, डेटा संग्रहण को स्वचालित कर रहे हैं या विभिन्न क्षेत्रों से API का परीक्षण कर रहे हैं — न sooner या later आप IP द्वारा ब्लॉक का सामना करेंगे। Go उच्च प्रदर्शन वाले नेटवर्क उपकरणों के लिए सबसे लोकप्रिय भाषाओं में से एक है, और यहां प्रॉक्सी सेटअप की अपनी विशेषताएँ हैं। इस मार्गदर्शिका में हम बुनियादी कॉन्फ़िगरेशन http.Client से लेकर SOCKS5 समर्थन के साथ उन्नत IP रोटेशन तक सब कुछ देखेंगे।

Go ऐप्लिकेशन में प्रॉक्सी की आवश्यकता क्यों है

Go उच्च लोड वाले नेटवर्क उपकरणों के लिए एक मानक बन गया है: पार्सर, क्रॉलर, मूल्य निगरानी बॉट, API स्वचालन उपकरण। यहीं पर प्रॉक्सी की आवश्यकता सबसे अधिक होती है — और यहीं पर इसे सही तरीके से सेट करना महत्वपूर्ण है।

मुख्य परिदृश्य जब प्रॉक्सी की आवश्यकता होती है:

• मार्केटप्लेस पार्सिंग — Wildberries, Ozon, AliExpress एक ही पते से 50–200 अनुरोधों के बाद IP को ब्लॉक करते हैं। IP बदले बिना पार्सर रुक जाता है।
• जियो-टेस्टिंग — विभिन्न देशों और क्षेत्रों से खोज इंजन, विज्ञापन या कीमतों की जांच करना।
• रेट-सीमा को बायपास करना — कई IPs के माध्यम से लोड को वितरित करना प्रति मिनट अनुरोधों की संख्या पर प्रतिबंधों को बायपास करने की अनुमति देता है।
• गुमनामी — बाहरी API के साथ काम करते समय सर्वर के वास्तविक IP को छिपाना।
• CDN और भू-स्थान परीक्षण — विभिन्न क्षेत्रों के लिए सामग्री की सही डिलीवरी की जांच करना।

Go की मानक लाइब्रेरी प्रॉक्सी के साथ काम करने के लिए लचीले उपकरण प्रदान करती है — http.Transport और http.Client के माध्यम से। हम प्रत्येक तरीके को विस्तार से देखेंगे।

http.Client के माध्यम से HTTP प्रॉक्सी की बुनियादी सेटिंग

Go में प्रॉक्सी http.Transport के स्तर पर सेट की जाती है — HTTP क्लाइंट के परिवहन स्तर पर। यह यह नियंत्रित करने की पूरी स्वतंत्रता देता है कि अनुरोध किस प्रॉक्सी के माध्यम से जाते हैं, और एक साथ विभिन्न प्रॉक्सी के साथ कई क्लाइंट बनाने की अनुमति देता है।

HTTP प्रॉक्सी सेटअप का न्यूनतम कार्यशील उदाहरण:

package main

import (
    "fmt"
    "io"
    "net/http"
    "net/url"
)

func main() {
    // प्रॉक्सी सर्वर का पता निर्दिष्ट करें
    proxyURL, err := url.Parse("http://123.45.67.89:8080")
    if err != nil {
        panic(err)
    }

    // प्रॉक्सी के साथ परिवहन बनाएं
    transport := &http.Transport{
        Proxy: http.ProxyURL(proxyURL),
    }

    // हमारे परिवहन के साथ क्लाइंट बनाएं
    client := &http.Client{
        Transport: transport,
    }

    // प्रॉक्सी के माध्यम से अनुरोध करें
    resp, err := client.Get("https://httpbin.org/ip")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

इस कोड में क्या हो रहा है:

1. url.Parse — प्रॉक्सी के पते के साथ स्ट्रिंग को *url.URL संरचना में पार्स करता है
2. http.Transport{Proxy: http.ProxyURL(proxyURL)} — एक परिवहन बनाता है जो सभी अनुरोधों को निर्दिष्ट प्रॉक्सी के माध्यम से भेजता है
3. http.Client{Transport: transport} — हमारे परिवहन के साथ क्लाइंट बनाता है

एक महत्वपूर्ण बिंदु: यदि आप http.DefaultClient का उपयोग कर रहे हैं (यानी बस http.Get() बिना स्पष्ट क्लाइंट के), तो प्रॉक्सी लागू नहीं होगा। हमेशा प्रॉक्सी के साथ काम करने के लिए अपना खुद का http.Client बनाएं।

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

Go प्रॉक्सी के लिए मानक पर्यावरण चर का समर्थन करता है — HTTP_PROXY, HTTPS_PROXY और NO_PROXY. मानक परिवहन http.DefaultTransport स्वचालित रूप से उन्हें http.ProxyFromEnvironment फ़ंक्शन के माध्यम से पढ़ता है।

एप्लिकेशन शुरू करने से पहले पर्यावरण चर सेट करना:

# टर्मिनल में (Linux/macOS)
export HTTP_PROXY="http://123.45.67.89:8080"
export HTTPS_PROXY="http://123.45.67.89:8080"
export NO_PROXY="localhost,127.0.0.1"

# एप्लिकेशन चलाएं
go run main.go

यदि आप अपने परिवहन में ProxyFromEnvironment का उपयोग करना चाहते हैं (उदाहरण के लिए, अतिरिक्त TLS सेटिंग्स के साथ), तो ऐसा करें:

transport := &http.Transport{
    Proxy: http.ProxyFromEnvironment,
    // अतिरिक्त सेटिंग्स...
    TLSHandshakeTimeout:   10 * time.Second,
    ResponseHeaderTimeout: 30 * time.Second,
}

client := &http.Client{
    Transport: transport,
    Timeout:   60 * time.Second,
}

यह दृष्टिकोण उत्पादन वातावरण के लिए सुविधाजनक है, जहां प्रॉक्सी का पता तैनाती कॉन्फ़िगरेशन (Docker, Kubernetes, systemd) के माध्यम से सेट किया जाता है, न कि कोड में हार्डकोड किया जाता है। यह प्रॉक्सी को बिना पुनः संकलन के बदलने को भी सरल बनाता है।

Golang में SOCKS5 प्रॉक्सी कनेक्शन

SOCKS5 HTTP प्रॉक्सी की तुलना में एक अधिक बहुपरकारी प्रोटोकॉल है। यह निम्न स्तर पर काम करता है और किसी भी TCP/UDP कनेक्शन का समर्थन करता है, न कि केवल HTTP/HTTPS। पार्सर और स्वचालन के साथ काम करने के लिए SOCKS5 अक्सर प्राथमिकता दी जाती है — विशेष रूप से रहवासी प्रॉक्सी का उपयोग करते समय, जो अक्सर इसी प्रोटोकॉल के माध्यम से प्रदान किए जाते हैं।

Go में SOCKS5 के साथ काम करने के लिए golang.org/x/net/proxy पैकेज की आवश्यकता है:

go get golang.org/x/net/proxy

प्रमाणीकरण के बिना SOCKS5 प्रॉक्सी कनेक्ट करने का उदाहरण:

package main

import (
    "fmt"
    "io"
    "net/http"
    "golang.org/x/net/proxy"
)

func main() {
    // SOCKS5 डायलर बनाएं
    dialer, err := proxy.SOCKS5("tcp", "123.45.67.89:1080", nil, proxy.Direct)
    if err != nil {
        panic(err)
    }

    // कस्टम डायलर के साथ परिवहन बनाएं
    transport := &http.Transport{
        Dial: dialer.Dial,
    }

    client := &http.Client{
        Transport: transport,
    }

    resp, err := client.Get("https://httpbin.org/ip")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

Go 1.20+ से आप url.Parse के माध्यम से SOCKS5 के लिए अंतर्निहित समर्थन का भी उपयोग कर सकते हैं, जिसमें socks5:// प्रीफिक्स है:

proxyURL, _ := url.Parse("socks5://123.45.67.89:1080")

transport := &http.Transport{
    Proxy: http.ProxyURL(proxyURL),
}

client := &http.Client{Transport: transport}

यह सिंटैक्स सरल है और अतिरिक्त निर्भरताओं की आवश्यकता नहीं है। हालाँकि, अधिक जटिल परिदृश्यों (उदाहरण के लिए, पुराने Go संस्करणों में प्रमाणीकरण के साथ SOCKS5) के लिए golang.org/x/net/proxy पैकेज अभी भी प्रासंगिक है।

प्रॉक्सी में लॉगिन और पासवर्ड के साथ प्रमाणीकरण

अधिकांश वाणिज्यिक प्रॉक्सी प्रदाता लॉगिन और पासवर्ड के माध्यम से प्रमाणीकरण का उपयोग करते हैं। Go में क्रेडेंशियल्स को पास करने के दो तरीके हैं।

तरीका 1: URL में एम्बेड करना

// प्रारूप: protocol://username:password@host:port
proxyURL, err := url.Parse("http://myuser:[email protected]:8080")
if err != nil {
    panic(err)
}

transport := &http.Transport{
    Proxy: http.ProxyURL(proxyURL),
}

client := &http.Client{
    Transport: transport,
    Timeout:   30 * time.Second,
}

तरीका 2: url.URL संरचना के माध्यम से (अधिक सुरक्षित)

proxyURL := &url.URL{
    Scheme: "http",
    Host:   "proxy.example.com:8080",
    User:   url.UserPassword("myuser", "mypassword"),
}

transport := &http.Transport{
    Proxy: http.ProxyURL(proxyURL),
}

client := &http.Client{
    Transport: transport,
    Timeout:   30 * time.Second,
}

दूसरा तरीका प्राथमिकता का है — यह पासवर्ड में विशेष वर्णों (जैसे @, #, :) को सही ढंग से संभालता है, जो पहले विकल्प में URL पार्सिंग को तोड़ सकता है।

SOCKS5 के लिए प्रमाणीकरण के साथ golang.org/x/net/proxy पैकेज के माध्यम से:

auth := &proxy.Auth{
    User:     "myuser",
    Password: "mypassword",
}

dialer, err := proxy.SOCKS5("tcp", "proxy.example.com:1080", auth, proxy.Direct)
if err != nil {
    panic(err)
}

transport := &http.Transport{
    Dial: dialer.Dial,
}

client := &http.Client{
    Transport: transport,
    Timeout:   30 * time.Second,
}

प्रॉक्सी रोटेशन: अनुरोधों के बीच IP स्विच करना

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

Go में रोटेशन के लिए दो दृष्टिकोण हैं:

दृष्टिकोण 1: राउंड-रॉबिन के साथ प्रॉक्सी सूची

package main

import (
    "fmt"
    "io"
    "net/http"
    "net/url"
    "sync/atomic"
    "time"
)

type ProxyRotator struct {
    proxies []*url.URL
    counter uint64
}

func NewProxyRotator(proxyURLs []string) (*ProxyRotator, error) {
    proxies := make([]*url.URL, 0, len(proxyURLs))
    for _, p := range proxyURLs {
        u, err := url.Parse(p)
        if err != nil {
            return nil, err
        }
        proxies = append(proxies, u)
    }
    return &ProxyRotator{proxies: proxies}, nil
}

// GetClient अगले प्रॉक्सी के साथ क्लाइंट लौटाता है
func (r *ProxyRotator) GetClient() *http.Client {
    idx := atomic.AddUint64(&r.counter, 1) % uint64(len(r.proxies))
    proxyURL := r.proxies[idx]

    transport := &http.Transport{
        Proxy: http.ProxyURL(proxyURL),
    }

    return &http.Client{
        Transport: transport,
        Timeout:   30 * time.Second,
    }
}

func main() {
    proxyList := []string{
        "http://user:[email protected]:8080",
        "http://user:[email protected]:8080",
        "http://user:[email protected]:8080",
    }

    rotator, err := NewProxyRotator(proxyList)
    if err != nil {
        panic(err)
    }

    // प्रत्येक अनुरोध अगले प्रॉक्सी के माध्यम से जाता है
    for i := 0; i < 10; i++ {
        client := rotator.GetClient()
        resp, err := client.Get("https://httpbin.org/ip")
        if err != nil {
            fmt.Printf("अनुरोध %d में त्रुटि: %v\n", i, err)
            continue
        }
        body, _ := io.ReadAll(resp.Body)
        resp.Body.Close()
        fmt.Printf("अनुरोध %d: %s\n", i, string(body))
    }
}

दृष्टिकोण 2: फ़ंक्शन के माध्यम से प्रॉक्सी का गतिशील चयन

http.Transport में Proxy फ़ील्ड एक फ़ंक्शन को स्वीकार करता है जिसका संकेत func(*http.Request) (*url.URL, error) है। यह प्रत्येक अनुरोध के लिए गतिशील रूप से प्रॉक्सी का चयन करने की अनुमति देता है:

proxies := []*url.URL{
    mustParseURL("http://proxy1.example.com:8080"),
    mustParseURL("http://proxy2.example.com:8080"),
    mustParseURL("http://proxy3.example.com:8080"),
}

var counter uint64

transport := &http.Transport{
    Proxy: func(req *http.Request) (*url.URL, error) {
        // अनुरोध के आधार पर प्रॉक्सी का चयन करें (राउंड-रॉबिन)
        idx := atomic.AddUint64(&counter, 1) % uint64(len(proxies))
        return proxies[idx], nil
    },
}

client := &http.Client{
    Transport: transport,
    Timeout:   30 * time.Second,
}

func mustParseURL(s string) *url.URL {
    u, err := url.Parse(s)
    if err != nil {
        panic(err)
    }
    return u
}

दूसरा दृष्टिकोण अधिक सुरुचिपूर्ण है — एक क्लाइंट प्रत्येक अनुरोध के लिए स्वचालित रूप से प्रॉक्सी को रोटेट करता है। यह गोरूटीन के माध्यम से प्रतिस्पर्धी अनुरोधों के लिए विशेष रूप से सुविधाजनक है।

Go प्रोजेक्ट के लिए कौन सा प्रॉक्सी प्रकार चुनें

प्रॉक्सी के प्रकार का चयन आपके प्रोजेक्ट की सफलता पर सीधा प्रभाव डालता है। विभिन्न कार्यों के लिए विभिन्न प्रकार उपयुक्त हैं — हम मुख्य विकल्पों पर चर्चा करेंगे:

मार्केटप्लेस पार्सिंग के लिए (Wildberries, Ozon, Avito): रहवासी प्रॉक्सी का उपयोग करें। ये प्लेटफार्म सक्रिय रूप से बॉट पहचान प्रणाली (Cloudflare, अपने समाधान) का उपयोग करते हैं और डेटा सेंटर के IP को आसानी से ब्लॉक कर देते हैं। रहवासी IP सामान्य घरेलू उपयोगकर्ताओं की तरह दिखते हैं।

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

जियो-टेस्टिंग के लिए: देश/शहर के चयन के साथ रहवासी प्रॉक्सी। यह आपको यह जांचने की अनुमति देता है कि आपका सेवा या विज्ञापन किसी विशेष क्षेत्र के उपयोगकर्ताओं के लिए कैसा दिखता है।

आम गलतियाँ और सर्वोत्तम प्रथाएँ

Go प्रोजेक्ट्स में प्रॉक्सी के साथ काम करते समय कई वर्षों में कुछ सामान्य गलतियों की सूची विकसित हुई है, जो विकास को धीमा करती हैं और पार्सरों की विश्वसनीयता को कम करती हैं। हम प्रत्येक पर चर्चा करेंगे।

गलती 1: कनेक्शन को रीसेट किए बिना परिवहन का पुन: उपयोग करना

http.Transport TCP कनेक्शनों को कैश करता है (कीप-एलाइव)। यदि आप प्रत्येक अनुरोध के लिए एक नया परिवहन बनाते हैं, तो आप इस लाभ को खो देते हैं। लेकिन यदि आप रोटेशन के दौरान एक निश्चित प्रॉक्सी के साथ एक परिवहन का पुन: उपयोग करते हैं — अनुरोध पुराने कनेक्शन के माध्यम से जा सकते हैं, नए प्रॉक्सी को बायपास करते हुए।

समाधान: प्रॉक्सी बदलने पर transport.CloseIdleConnections() को कॉल करें या रोटेशन के अनुभाग में वर्णित गतिशील प्रॉक्सी चयन के साथ कार्यात्मक दृष्टिकोण का उपयोग करें।

गलती 2: प्रॉक्सी त्रुटियों का कोई प्रबंधन नहीं

प्रॉक्सी अनुपलब्ध, अधिभारित या लक्षित साइट द्वारा ब्लॉक हो सकते हैं। बिना रीट्राई लॉजिक के, आपका पार्सर पहली ही त्रुटि पर रुक जाएगा।

func fetchWithRetry(client *http.Client, targetURL string, maxRetries int) ([]byte, error) {
    var lastErr error
    for i := 0; i < maxRetries; i++ {
        resp, err := client.Get(targetURL)
        if err != nil {
            lastErr = err
            time.Sleep(time.Duration(i+1) * time.Second) // एक्सपोनेंशियल डिले
            continue
        }
        defer resp.Body.Close()

        if resp.StatusCode == 429 || resp.StatusCode == 403 {
            lastErr = fmt.Errorf("ब्लॉक किया गया: स्थिति %d", resp.StatusCode)
            time.Sleep(time.Duration(i+1) * 2 * time.Second)
            continue
        }

        return io.ReadAll(resp.Body)
    }
    return nil, fmt.Errorf("सभी प्रयास समाप्त: %w", lastErr)
}

गलती 3: TLS सत्यापन की अनदेखी

कुछ डेवलपर्स प्रॉक्सी के लिए TLS प्रमाणपत्रों की सत्यापन को बंद कर देते हैं (InsecureSkipVerify: true). यह MITM हमलों के लिए एक भेद्यता पैदा करता है। यदि प्रॉक्सी सर्वर एक स्व-हस्ताक्षरित प्रमाणपत्र का उपयोग करता है — तो इसे विश्वसनीय पूल में जोड़ें, न कि सत्यापन को पूरी तरह से बंद करें।

गलती 4: सभी अनुरोधों के लिए समान हेडर

प्रॉक्सी के रोटेशन के साथ भी आपको हेडर पैटर्न के कारण ब्लॉक किया जा सकता है। प्रॉक्सी के साथ User-Agent को बदलें, वास्तविक ब्राउज़र हेडर जोड़ें:

userAgents := []string{
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/119.0.0.0 Safari/537.36",
    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/118.0.0.0 Safari/537.36",
}

req, _ := http.NewRequest("GET", targetURL, nil)
req.Header.Set("User-Agent", userAgents[rand.Intn(len(userAgents))])
req.Header.Set("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8")
req.Header.Set("Accept-Language", "ru-RU,ru;q=0.9,en-US;q=0.8,en;q=0.7")
req.Header.Set("Accept-Encoding", "gzip, deflate, br")

Go में विश्वसनीय प्रॉक्सी क्लाइंट की चेकलिस्ट

• ✅ क्लाइंट पर टाइमआउट (Timeout: 30 * time.Second)
• ✅ एक्सपोनेंशियल डिले के साथ रीट्राई लॉजिक
• ✅ 403/429 त्रुटियों पर प्रॉक्सी रोटेशन
• ✅ प्रॉक्सी के साथ User-Agent का रोटेशन
• ✅ उपयोग किए गए प्रॉक्सी के साथ त्रुटियों का लॉगिंग
• ✅ पर्यावरण चर के माध्यम से क्रेडेंशियल्स, कोड में हार्डकोड नहीं
• ✅ resp.Body को defer के माध्यम से बंद करना
• ✅ सेमाफोर या worker pool के माध्यम से प्रतिस्पर्धा को सीमित करना

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

package main

import (
    "fmt"
    "io"
    "net/http"
    "net/url"
    "sync"
    "sync/atomic"
    "time"
)

type Scraper struct {
    proxies []*url.URL
    counter uint64
    workers int
}

func (s *Scraper) getClient() *http.Client {
    idx := atomic.AddUint64(&s.counter, 1) % uint64(len(s.proxies))
    return &http.Client{
        Transport: &http.Transport{
            Proxy: http.ProxyURL(s.proxies[idx]),
        },
        Timeout: 30 * time.Second,
    }
}

func (s *Scraper) Scrape(urls []string) map[string]string {
    results := make(map[string]string)
    var mu sync.Mutex
    var wg sync.WaitGroup

    sem := make(chan struct{}, s.workers) // प्रतिस्पर्धा को सीमित करने के लिए सेमाफोर

    for _, u := range urls {
        wg.Add(1)
        go func(targetURL string) {
            defer wg.Done()
            sem <- struct{}{}
            defer func() { <-sem }()

            client := s.getClient()
            resp, err := client.Get(targetURL)
            if err != nil {
                fmt.Printf("त्रुटि: %v\n", err)
                return
            }
            defer resp.Body.Close()

            body, _ := io.ReadAll(resp.Body)

            mu.Lock()
            results[targetURL] = string(body)
            mu.Unlock()
        }(u)
    }

    wg.Wait()
    return results
}

निष्कर्ष

Go में प्रॉक्सी सेट करना एक ऐसा कार्य है जिसे कुछ कोड की पंक्तियों में हल किया जा सकता है, लेकिन इसके बारीकियों को समझने की आवश्यकता होती है: http.Transport का सही उपयोग, प्रमाणीकरण की सही हैंडलिंग, IP का सही रोटेशन और त्रुटियों का प्रबंधन। मानक लाइब्रेरी HTTP प्रॉक्सी के लिए आवश्यक सभी चीजें प्रदान करती है, और golang.org/x/net/proxy SOCKS5 की आवश्यकता को पूरा करता है।

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

• हमेशा अपना खुद का http.Client बनाएं — http.DefaultClient सीधे प्रॉक्सी का समर्थन नहीं करता है
• गतिशील रोटेशन के लिए कार्यात्मक दृष्टिकोण का उपयोग करें (Proxy: func(r *Request) (*url.URL, error))
• क्रेडेंशियल्स को कोड में नहीं, बल्कि पर्यावरण चर में रखें
• रीट्राई लॉजिक जोड़ें — प्रॉक्सी 100% विश्वसनीय नहीं होते हैं
• अधिकतम प्रभावशीलता के लिए प्रॉक्सी के साथ User-Agent बदलें

यदि आप Wildberries या Ozon जैसे मार्केटप्लेस के लिए पार्सर लिख रहे हैं, तो हम रहवासी प्रॉक्सी का उपयोग करने की सिफारिश करते हैं — इनमें वास्तविक घरेलू उपयोगकर्ताओं के IP होते हैं और ये एंटी-बॉट सिस्टम द्वारा बहुत कम ब्लॉक होते हैं। हजारों अनुरोधों प्रति मिनट के उच्च-लोड परिदृश्यों के लिए, डेटा सेंटर प्रॉक्सी सबसे अच्छा विकल्प हैं — ये अधिकतम गति और कनेक्शन की स्थिरता प्रदान करते हैं।