استخدام البروكسيات في Go: دليل HTTP Client وSDK

لماذا نستخدم العملاء في الذهاب؟

وقد أصبح الذهاب هو لغة الاختيار لأدوات الربط الشبكي ذات الأداء العالي، وخرائط الإنترنت، وزبائن نظام المعلومات الإدارية المتكامل. فطائرها ذات الوزن الخفيف و البدائيات المتوافقة net/http فالمكتبة العادية تجعلها مثالية للتطبيقات ذات القدرة البديلة التي تحتاج إلى معالجة آلاف الطلبات المتزامنة.

سواء كنت تبني تخريد الشبكة خط أنابيب، رصد رتب نظام تخطيط الموارد المؤسسيةأو جمع بيانات تسعير تنافسيّة، تقريب عملائك من (جو هي تي بي) عن طريق البركات، يجعلك تتناوب عناوين آي بي، وتتجاوز الحدود الجيولوجية، وتتجنب حدود الأسعار على نطاق واسع.

في هذا الدليل، سوف تتعلم كيف تتغاضى محترفون في الذهاب استخدام المكتبة القياسية ProxyHat Go SDKكُلّ قناصة شفرةِ كُلّ مُخَدّرةُ مُقَرَّدةُ لذا أنت يُمْكِنُ أَنْ تَبْدأَ الخردةَ في غضون دقائقِ.

التركيب

ProxyHat Go SDK

أسرع طريقة للبدء هي مع النائب العام إنه يتعامل مع التوثيق، التناوب، الهدف الجيووي، والإعادة من الصندوق

go get github.com/ProxyHatCom/go-sdk@latest

المكتبة القياسية فقط

إذا كنت تفضّل عدم وجود عُلَم، إذهب net/http و net/url الطرود هي كل ما تحتاجه لا حاجة لتركيب إضافي

التوثيق والإنشاءات الأساسية

يستخدم (بروكسي هات) توثيق كلمة المرور على نقطة النهاية ستجد أوراق اعتمادك في لوح الصراخالوكيل العادي يبدو مثل هذا:

http://USERNAME:PASSWORD@gate.proxyhat.com:8080

أبقي أوراق الاعتماد خارج رمز المصدر متغيرات بيئة الاستخدام أو .env ملف:

export PROXYHAT_USER="your_username"
export PROXYHAT_PASS="your_password"

بسيطة طلب مع الوكيل

وهذا هو النهج الأدنى الذي يستخدم المكتبة الموحدة فقط:

package main
import (
    "fmt"
    "io"
    "log"
    "net/http"
    "net/url"
    "os"
)
func main() {
    proxyURL, err := url.Parse(fmt.Sprintf(
        "http://%s:%s@gate.proxyhat.com:8080",
        os.Getenv("PROXYHAT_USER"),
        os.Getenv("PROXYHAT_PASS"),
    ))
    if err != nil {
        log.Fatal(err)
    }
    client := &http.Client{
        Transport: &http.Transport{
            Proxy: http.ProxyURL(proxyURL),
        },
    }
    resp, err := client.Get("https://httpbin.org/ip")
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

تشغيله وسوف نرى عنوان IP السكني بدلا من الخاص بك. كل طلب يتم توجيهه عبر (بروكسي هات) حوض سباحة سكني.

استخدام أنواع مختلفة من البروكسي

ويدعم برنامج " بروكس هات " ثلاثة أنواع بديلة، كل منها يناسب أعباء العمل المختلفة. انت تختار من النوع عبر المرفأ المحترف أو العلم المستخدم

لمقارنة أعمق لمتى نستخدم كل نوع، انظر دليلنا مركز بيانات ضد شركات متنقلة.

// Switch proxy type by changing the port
residentialProxy := "http://user:pass@gate.proxyhat.com:8080"
datacenterProxy  := "http://user:pass@gate.proxyhat.com:8080"
mobileProxy      := "http://user:pass@gate.proxyhat.com:8080"

النهج الدليلي: صافي/http with Proxy Configuration

من أجل السيطرة الكاملة http.Transport مباشرة هذا يدعك تتجمعين وتضعين نظام "تي إل إس" والوقت المناسب

package main
import (
    "crypto/tls"
    "net/http"
    "net/url"
    "time"
)
func newProxyClient(proxyAddr string) (*http.Client, error) {
    proxyURL, err := url.Parse(proxyAddr)
    if err != nil {
        return nil, err
    }
    transport := &http.Transport{
        Proxy:               http.ProxyURL(proxyURL),
        MaxIdleConns:        100,
        MaxIdleConnsPerHost: 10,
        IdleConnTimeout:     90 * time.Second,
        TLSClientConfig:     &tls.Config{MinVersion: tls.VersionTLS12},
    }
    client := &http.Client{
        Transport: transport,
        Timeout:   30 * time.Second,
    }
    return client, nil
}

النهج الموصى به: ProxyHat Go SDK

The ProxyHat Go SDK يلفّ كلّ المزمار إلى a مشغل نظيف. إنه يُدير عملية تجميع الإتصالات، عمليات التلقائية، مناولة الجلسات، ووضع الأهداف الجغرافية لك.

package main
import (
    "context"
    "fmt"
    "log"
    proxyhat "github.com/ProxyHatCom/go-sdk"
)
func main() {
    client, err := proxyhat.NewClient(proxyhat.Config{
        Username:  "your_username",
        Password:  "your_password",
        ProxyType: proxyhat.Residential,
    })
    if err != nil {
        log.Fatal(err)
    }
    defer client.Close()
    resp, err := client.Get(context.Background(), "https://httpbin.org/ip")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Status:", resp.StatusCode)
    fmt.Println("Body:", string(resp.Body))
}

The SDK returns a structured response, handles decompression, and retries transient failures automatically. تحقق وثائق API للطريقة الكاملة المرجعية.

التناوب ضد الدورات المرنة

يدعم مكتب المدعي العام أسلوبين للدورة:

• التناوب (العجز) -كل طلب يحصل على آي بي جديد مثالية على نطاق واسع تخريد الشبكة.
• عصا - يُحتفظ بنفس البرنامج لفترة قابلة للتشكيل (حتى 30 دقيقة). مفيدة للتدفقات المتعددة الخطوات مثل تسلسلات قطع الأشجار أو الزحف المهددة

دورات التناوب

client, _ := proxyhat.NewClient(proxyhat.Config{
    Username:  "your_username",
    Password:  "your_password",
    ProxyType: proxyhat.Residential,
    // Rotating is the default — no extra config needed
})
// Each call uses a different IP
for i := 0; i < 5; i++ {
    resp, _ := client.Get(context.Background(), "https://httpbin.org/ip")
    fmt.Printf("Request %d: %s\n", i+1, string(resp.Body))
}

جلسات صعبة

session, _ := client.NewSession(proxyhat.SessionConfig{
    Duration: 10 * time.Minute,
})
// All requests through this session use the same IP
resp1, _ := session.Get(context.Background(), "https://example.com/login")
resp2, _ := session.Post(context.Background(), "https://example.com/dashboard", payload)

الجلسات العلنية (الرسمية)

// Append session ID to the username
// Format: USERNAME-session-SESSIONID
proxyURL := "http://user-session-abc123:pass@gate.proxyhat.com:8080"

الطلبات ذات الأهداف الجغرافية

هل تحتاج شركاء من بلد محدد؟ ProxyHat supports 190 موقعا- تمرير الرمز القطري عبر SDK أو كعلامة مستخدم:

// SDK approach
client, _ := proxyhat.NewClient(proxyhat.Config{
    Username:  "your_username",
    Password:  "your_password",
    ProxyType: proxyhat.Residential,
    Country:   "US",   // ISO 3166-1 alpha-2
    State:     "CA",   // optional: state/region
    City:      "LA",   // optional: city
})
resp, _ := client.Get(context.Background(), "https://httpbin.org/ip")
fmt.Println(string(resp.Body)) // US-based IP

// Manual approach — append country to username
// Format: USERNAME-country-US
proxyURL := "http://user-country-US:pass@gate.proxyhat.com:8080"

تحديد الأهداف الجغرافية أمر أساسي لإضفاء الطابع المحلي عليه SERP tracking- التحقق من الأسعار الإقليمية، واختبار مدى توافر المحتوى.

التعامل مع الأخطاء ومعالجتها

ويمكن أن تفشل طلبات الشبكة من خلال العملاء لأسباب عابرة: رهانات الاتصال، أو فترات التوقف، أو الوحدات المؤقتة. ومن الأهمية بمكان معالجة الأخطاء الصارخة في إنتاج الخردة.

SDK built-in retries

client, _ := proxyhat.NewClient(proxyhat.Config{
    Username:   "your_username",
    Password:   "your_password",
    ProxyType:  proxyhat.Residential,
    MaxRetries: 3,
    RetryDelay: 2 * time.Second,
})

إعادة صياغة دليلية مع التخلف الهائل

package main
import (
    "fmt"
    "math"
    "net/http"
    "time"
)
func fetchWithRetry(client *http.Client, url string, maxRetries int) (*http.Response, error) {
    var lastErr error
    for attempt := 0; attempt <= maxRetries; attempt++ {
        resp, err := client.Get(url)
        if err == nil && resp.StatusCode < 500 {
            return resp, nil
        }
        if err != nil {
            lastErr = err
        } else {
            lastErr = fmt.Errorf("HTTP %d", resp.StatusCode)
            resp.Body.Close()
        }
        backoff := time.Duration(math.Pow(2, float64(attempt))) * time.Second
        time.Sleep(backoff)
    }
    return nil, fmt.Errorf("all %d retries failed: %w", maxRetries, lastErr)
}

التسلل مع (غوروتين)

نموذج تزامن الذهاب هو قوته الخارقة. مع العفاريت والقنوات، يمكنك أن تخرّب المئات من الـ(يور إل) في نفس الوقت بينما تحافظ على استخدام الذاكرة

package main
import (
    "context"
    "fmt"
    "sync"
    proxyhat "github.com/ProxyHatCom/go-sdk"
)
type Result struct {
    URL        string
    StatusCode int
    Body       string
    Err        error
}
func scrape(ctx context.Context, client *proxyhat.Client, urls []string, concurrency int) []Result {
    results := make([]Result, len(urls))
    sem := make(chan struct{}, concurrency) // semaphore
    var wg sync.WaitGroup
    for i, u := range urls {
        wg.Add(1)
        go func(idx int, target string) {
            defer wg.Done()
            sem <- struct{}{}        // acquire
            defer func() { <-sem }() // release
            resp, err := client.Get(ctx, target)
            if err != nil {
                results[idx] = Result{URL: target, Err: err}
                return
            }
            results[idx] = Result{
                URL:        target,
                StatusCode: resp.StatusCode,
                Body:       string(resp.Body),
            }
        }(i, u)
    }
    wg.Wait()
    return results
}
func main() {
    client, _ := proxyhat.NewClient(proxyhat.Config{
        Username:  "your_username",
        Password:  "your_password",
        ProxyType: proxyhat.Residential,
    })
    defer client.Close()
    urls := []string{
        "https://example.com/page/1",
        "https://example.com/page/2",
        "https://example.com/page/3",
        // ... hundreds more
    }
    results := scrape(context.Background(), client, urls, 20)
    for _, r := range results {
        if r.Err != nil {
            fmt.Printf("FAIL %s: %v\n", r.URL, r.Err)
        } else {
            fmt.Printf("OK   %s: %d bytes\n", r.URL, len(r.Body))
        }
    }
}

الحد الأدنى مع سيمافور

الخردة فوق تستخدم بالفعل قناة سيمافور لضبط التطابق في حالة الحد من المعدل المحمَّل (على سبيل المثال، الطلبات المقدمة من بلدان الشمال) golang.org/x/time/rate:

package main
import (
    "context"
    "fmt"
    "log"
    proxyhat "github.com/ProxyHatCom/go-sdk"
    "golang.org/x/time/rate"
)
func main() {
    client, _ := proxyhat.NewClient(proxyhat.Config{
        Username:  "your_username",
        Password:  "your_password",
        ProxyType: proxyhat.Residential,
    })
    defer client.Close()
    // Allow 10 requests per second, burst of 20
    limiter := rate.NewLimiter(10, 20)
    urls := []string{"https://example.com/1", "https://example.com/2"}
    for _, u := range urls {
        if err := limiter.Wait(context.Background()); err != nil {
            log.Fatal(err)
        }
        resp, err := client.Get(context.Background(), u)
        if err != nil {
            fmt.Printf("Error: %v\n", err)
            continue
        }
        fmt.Printf("%s — %d\n", u, resp.StatusCode)
    }
}

الإنتاج

تجميع المعلومات

هيا http.Transport يحافظ على مجموعة من الاتصالات العقيمة عن طريق التقصير. وفيما يتعلق بعبء العمل العميل، تضبط هذه البيئات:

transport := &http.Transport{
    Proxy:                 http.ProxyURL(proxyURL),
    MaxIdleConns:          200,
    MaxIdleConnsPerHost:   50,
    MaxConnsPerHost:       100,
    IdleConnTimeout:       90 * time.Second,
    ResponseHeaderTimeout: 15 * time.Second,
}

الوقت

دائماً ما نحدد الوقت الخردة التي لا تملك الوقت ستعلق في النهاية على اتصال متوقف

client := &http.Client{
    Transport: transport,
    Timeout:   30 * time.Second, // total request timeout
}
// Or use context for per-request control
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
req, _ := http.NewRequestWithContext(ctx, "GET", targetURL, nil)
resp, err := client.Do(req)

إغلاق رائع

في الخرافات البعيدة المدى، والاستماع لاشارات OS لإغلاق نظيفة:

package main
import (
    "context"
    "os"
    "os/signal"
    "syscall"
)
func main() {
    ctx, stop := signal.NotifyContext(
        context.Background(),
        os.Interrupt, syscall.SIGTERM,
    )
    defer stop()
    // Pass ctx to your scraping functions
    // When Ctrl+C is pressed, ctx is cancelled
    // and in-flight requests wind down gracefully
    runScraper(ctx)
}

التعبئة والحفظ

جهزوا نقلكم لسجل التوقيت و رموز الحالة وهذا يساعد على تحديد الأهداف البطيئة والأخطاء الظاهرية في الإنتاج:

type loggingTransport struct {
    inner http.RoundTripper
}
func (t *loggingTransport) RoundTrip(req *http.Request) (*http.Response, error) {
    start := time.Now()
    resp, err := t.inner.RoundTrip(req)
    elapsed := time.Since(start)
    if err != nil {
        log.Printf("ERR  %s %s (%v) err=%v", req.Method, req.URL, elapsed, err)
    } else {
        log.Printf("OK   %s %s (%v) status=%d", req.Method, req.URL, elapsed, resp.StatusCode)
    }
    return resp, err
}

المداخل الرئيسية

• إذهبي إلى "غوروبينز" و "الوكالة" يمكنك أن تدير آلاف من الطلبات التي تُدير بالوكالة مع الحد الأدنى من الذاكرة
• The ProxyHat Go SDK يتعامل مع التوثيق، وال retries، والجلسات، والهدف الجيوغرافي مع تطبيق نظيف. ضعه لتخطي الغليبوت
• استخدام IPs التناوبية للخردة على نطاق واسع الجلسات الملصقة لتدفقات العمل المتعددة الخطوات مثل تدفق قطع الأشجار
• دائماً ما نحدد الوقت على حد سواء http.Client وعبر context.WithTimeout للتحكم في كل طلب
• الحد النهائي على نحو مسؤول مع golang.org/x/time/rate و تطابق مع قنوات الترميز
• توجيه طلباتك عن طريق إصدار قانون قطري للوصول إلى 190 موقعا في جميع أنحاء العالم
• تحقق من دليلنا على أفضل محترفين لخردة الإنترنت لاختيار الخطة الصحيحة لحجم عملك

الأسئلة المتكررة

كيف أتحدّى عميلاً في شركة (غو) للشبكة؟

وضع Proxy الميدان http.Transport إلى http.ProxyURL(parsedURL) حيث parsedURL عنوانك المحترف url.Parse()ثم نقل إلى http.Client- تتولى المكتبة المعيارية نفق الشبكة من أجل أهداف برنامج نقل الأسلحة البشرية بصورة تلقائية.

هل يدعم (بروكسي هات غو إس دي كي) أهداف (هاتيبس)؟

نعم الـ (إس دي كيه) يستعمل نفق (هاتف كونينت) تحت الغطاء لذا كل حركة المرور الخاصة بـ (هوب) تم تشفيرها بين زبونك والخادم المستهدف الوكيل لا يرى سوى اسم مضيف الوجهة

كم عدد الطلبات المتزامنة التي يمكن أن أقدمها من خلال وكالة جو؟

"الغوروتينات" خفيفة جداً (تقريباً 4 كيلو بي من الكسر كل واحد)، لذا يمكنك تشغيل عشرات الآلاف في نفس الوقت. الحد العملي لك خطة بروكس هات علاوة اتصال متزامنة وقدرة الخادم المستهدف استخدم قناة سيمافوري لضبط الاتّفاق على مستوى آمن

ما الفرق بين جلسات التدوير و جلسات المحترفين؟

وتخصص جلسات التناوب عنوانا جديدا لبرنامج شركاء التنفيذ لكل طلب، وهو مثال مثالي للخردة الواسعة النطاق. وتحتفظ الدورات المرهقة بنفس البرنامج لفترة محددة (حتى 30 دقيقة)، مما يجعلها مناسبة للتدفقات المتعددة الخطوات حيث يتوقع الهدف من زائر ثابت، مثل تسلسل قطع الأشجار أو صفحات المغادرة.

كيف أتعامل مع الأخطاء و الفحوصات في (جو)؟

يقوم (بروكسي هات غو إس دي كي) بتوفير منطق إعادة البناء MaxRetries و RetryDelay- إذا كان استخدام المكتبة القياسية، تنفيذ التراجع المكثف عن طريق ملفوفة طلبكم في حلقة تضاعف التأخير بعد كل محاولة فاشلة. تحقق دائماً من أخطاء الشبكة ورموز المركز 5x