Go'da Proxy Kullanımı: HTTP Client ve SDK Rehberi

Neden Go'da Proxies Kullanın?

Go yüksek performanslı ağ araçları, web hurdaları ve API müşterileri için seçim dili haline geldi. Hafif goroutines, inşa edilebilir ilkeller ve bir savaş-testi net/http Standart kütüphane, binlerce eş zamanlı istek işlemek için gereken proxy destekli uygulamalar için idealdir.

İsterseniz Web scraping Boru hattı, izleme SERP sıralama sıralamaları, veya rekabetçi fiyatlandırma verilerini toplamak, Go HTTP müşterilerinizi proxy aracılığıyla kurtarmak IP adreslerini döndürmenize, geo-restrictions'ı atlatmanıza ve ölçekdeki hız limitlerinden kaçınmanıza izin verir.

Bu kılavuzda, nasıl yapılandırılacağını öğreneceksiniz Go Hem standart kütüphane hem de standart kütüphaneyi kullanarak ProxyHat Go SDKHer kod parçaları kopya-paste-ready, böylece dakikalar içinde kazıya başlayabilirsiniz.

Kurulum

ProxyHat Go SDK

Başlamak için en hızlı yol resmi SDK ile. Bu, kimlik doğrulama, rotasyon, geo-targeting ve kutudan geri dönüyor.

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

Standart kütüphane sadece

Sıfır bağımlılıkları tercih ederseniz Go's net/http ve net/url paketler ihtiyacınız olan her şeydir. Gerekli ekstra yükleme yok.

Doğrulama ve Temel Kurulum

ProxyHat, proxy uç noktası üzerinde kullanıcı doğrulama kullanır. Bilgilerinizi size bulacaksınız ProxyHat dashboardTipik bir proxy URL böyle görünüyor:

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

Kaynak kodundan haberdar olun. Çevre değişkenleri veya bir .env Dosya:

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

Basit GET Proxy with a Proxy

İşte sadece standart kütüphaneyi kullanarak en az yaklaşım:

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))
}

Onu çalıştırın ve kendi yerine bir konut IP adresini göreceksiniz. Her istek ProxyHat'ın yollarından geçiyor konut havuzu proxy.

Farklı Proxy Türleri Kullanımı

ProxyHat üç proxy türünü destekler, her biri farklı iş yüklerine uygundur. Türi proxy portu veya bir kullanıcı bayrağı aracılığıyla seçin:

Her türü kullanmak için daha derin bir karşılaştırma için rehberimizi görün Konut vs datacenter vs mobil proxy.

// 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"

Manual Approach: Go net/http with Proxy Build

Tam kontrol için, yapılandırın http.Transport Doğrudan. Bu, bağlantı havuzunu, TLS ayarlarını ve zamanı ayarlamanızı sağlar:

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
}

Önerilen Yaklaşım: ProxyHat Go SDK

The The The The The The The The ProxyHat Go SDK Tüm kazan plakayı temiz bir API'ye dönüştürür. Bağlantı havuzunu, otomatik retries, seans işlemlerini ve sizin için geo-targetingi yönetiyor.

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))
}

SDK yapılandırılmış bir yanıt döndürür, baskıyı ele alır ve geçici başarısızlıkları otomatik olarak geri döndürür. Check the Check the API belgeleri Tam yöntem referansı için.

Bloking vs Sticky Sessions

ProxyHat iki seans modunu destekler:

• Rotating (default) Her istek yeni bir IP alır. Büyük ölçekli için ideal Web scraping.
• Sticky - aynı IP yapılandırılabilir bir süre için tutulur ( 30 dakikaya kadar). Çok adımlı akışlar için giriş dizileri veya paginated taramalar.

Rotating seansları (SDK)

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))
}

Sticky seansları (SDK)

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)

Sticky seansları (manual)

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

Geo-Targeted Requests

Belirli bir ülkeden IP'lere mi ihtiyacınız var? ProxyHat destek 190+ lokasyon. Ülke kodunu SDK aracılığıyla veya bir kullanıcı bayrağı olarak gönder:

// 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"

Geo-targeting yerelleştirilmiş için önemlidir SERP izleme, bölgesel fiyat kontrolleri ve içerik kullanılabilirlik testleri.

Hata işleme ve Retries

Bağlantılar aracılığıyla ağ talepleri geçici nedenlerle başarısız olabilir: bağlantı resetleri, zamanouts veya geçici bloklar. Robust hatası işleme, üretim hurdaları için kritiktir.

SDK inşa-in retries

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

Manual yenidentry ile birlikte

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)
}

Eş zamanlı olarak Goroutines ile birlikte

Go's concurrency modeli onun süper gücüdür. Goroutines ve kanallarla, hafıza kullanımını minimum tutarken yüzlerce URL'yi kapatabilirsiniz.

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))
        }
    }
}

Bir Semaphore ile Sınırlama

Yukarıdaki trer zaten bir semaphore kanalını cap concurrency için kullanıyor. İyileştirilmiş oran sınırlaması için (e.g., N requests per second), kullanım 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)
    }
}

Üretim İpuçları

Bağlantı havuzu

Go's http.Transport Varsayılan olarak boş bağlantıların bir havuzu korur. İş proxyları için, bu ayarları ayarlayın:

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

Timeouts

Her zaman zaman zaman aralıkları ayarlar. Zamansız bir hurda sonunda bir tezgahta asılacaktır:

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)

Grace

Uzun süren kazıcılarda, OS sinyallerinin temiz bir şekilde kapatılmasını dinleyin:

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)
}

Logging ve gözlemlenebilirlik

HTTP taşımanızı istediğiniz zaman ve durum kodlarına girin. Bu, üretimdeki yavaş hedefleri ve proxy hatalarını tanımlamaya yardımcı olur:

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
}

Key Takeaways

• Go's goroutines + proxy = büyük koncurrency. En az hafıza yükü ile binlerce proxy destekli istek çalıştırabilirsiniz.
• ProxyHat Go SDK Kontrollü, retries, seanslar ve temiz bir API ile geo-ticaret. İndir Pablock atlamak için.
• Geri dönen IP'leri kullanın ölçeklendirmek ve yapışkan seanslar Çok adımlı akışlar için giriş akışları gibi.
• Her zaman zaman zaman ayarlanır Her ikisinde de http.Client ve context.WithTimeout per-request kontrolü için.
• Rate-limit sorumlu olarak ile birlikte golang.org/x/time/rate ve semaphore kanalları ile tutarlılık.
• Geo-target your requests Bir ülke koduna erişmek için 190+ lokasyon Dünya çapında.
• rehberimizi kontrol edin Web için en iyi referanslar İş yükleriniz için doğru planı seçmek.

Sık Sorulan Sorular

Go'nun net/http müşterisinde bir proxy nasıl yapılandırabilirim?

Set the Set the Set the Set Proxy Alan üzerinde http.Transport toklanmak için http.ProxyURL(parsedURL) nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede nerede? parsedURL Adresiniz ile parsed url.Parse()Sonra ulaşımı geç http.Client. Standart kütüphane, HTTPS hedeflerini otomatik olarak ele alır.

ProxyHat Go SDK HTTPS hedeflerini destekliyor mu?

Evet. SDK, tüm HTTPS trafiği istemciniz ve hedef sunucunuz arasında şifreli son devredir. Proxy sadece varış adlarını görür.

Kaç tane eşzamanlı istek Go proxy aracılığıyla yapabilir miyim?

Go's goroutines son derece hafiftir (her biri 4 KB'ye kadar) bu yüzden on binlerce eş zamanlı çalıştırabilirsiniz. Pratik limit sizindir ProxyHat planı Eş zamanlı bağlantı ücreti ve hedef sunucunun kapasitesi. Güvenli bir seviyede karşılıklılık kurmak için bir semaphore kanalı kullanın.

Dönen ve yapışkan seanslar arasındaki fark nedir?

Rotating seansları, geniş kazı için ideal olan her istek için yeni bir IP adresi tayin eder. Sticky seansları, belirli bir süre için aynı IP'yi tutar ( 30 dakikaya kadar), hedefin tutarlı bir ziyaretçi beklediği, giriş sıraları veya kontrol sayfaları gibi tutarlı bir ziyaretçi için uygun hale getirir.

Go'da proxy hataları ve retries nasıl idare ediyorum?

ProxyHat Go SDK, yapılandırılabilir ayarlı yeniden deneme mantığı sağlar. MaxRetries ve RetryDelayStandart kütüphaneyi kullanıyorsanız, isteğinizi her başarısız denemeden sonra ikiye katlayan bir döngüde kapatarak üst üste uygulayın. Her zaman ağ hataları ve HTTP 5xx durum kodları için kontrol edin.