Korzystanie z Proxies in Go: HTTP Client & SDK Guide

Dlaczego używać Proxies in Go?

Go stał się językiem wyboru dla wysokowydajnych narzędzi sieciowych, scrapperów internetowych i klientów API. Jego lekkie gorotyny, wbudowane w współwalutowe prymitywy i bitewne testowane net/http standardowa biblioteka sprawia, że idealnie nadaje się do aplikacji proksydowych, które muszą obsłużyć tysiące równoległych żądań.

Czy budujesz drapanie stron internetowych rurociąg, monitorowanie rankingi SERP, lub zbieranie konkurencyjnych danych cenowych, routing klientów Go HTTP poprzez proxy pozwala obracać adresy IP, omijać ograniczenia geo- i unikać limitów stawek w skali.

W tym przewodniku nauczysz się konfigurować proxy in Go korzystanie z biblioteki standardowej i ProxyHat Go SDKKażdy kod jest copy- paste- gotowy, więc można rozpocząć skrobanie w ciągu kilku minut.

Instalacja

ProxyHat Go SDK

Najszybszy sposób, aby rozpocząć jest z oficjalnym SDK. Zajmuje się uwierzytelnianiem, rotacją, geocelowaniem i powtórnie wyciąga się z pudełka.

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

Wyłącznie standardowa biblioteka

Jeśli wolisz zero zależności, Go 's net/http oraz net/url Paczki są wszystkim czego potrzebujesz. Nie jest wymagana dodatkowa instalacja.

Uwierzytelnianie i konfiguracja podstawowa

ProxyHat wykorzystuje uwierzytelnianie hasłem użytkownika w punkcie końcowym proxy. Znajdziesz swoje referencje w Deska rozdzielcza ProxyHatTypowy proxy URL wygląda następująco:

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

Utrzymuj referencje z dala od kodu źródłowego. Użyj zmiennych środowiskowych lub .env plik:

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

Prosty GET Prośba o proxy

Oto minimalne podejście przy użyciu tylko biblioteki standardowej:

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

Uruchom go, a zobaczysz adres IP zamiast własnego. Każda prośba jest przekazywana przez ProxyHat pula proxy mieszkalnych.

Korzystanie z różnych typów proxy

ProxyHat obsługuje trzy typy proxy, każdy nadaje się do różnych obciążeń roboczych. Wybierz typ przez port pośredniczący lub flagę nazwy użytkownika:

Aby uzyskać głębsze porównanie kiedy używać każdego typu, zobacz nasz przewodnik na mieszkaniowe vs datacenter vs mobilne 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"

Ręczne podejście: Go net / http z konfiguracją Proxy

Dla pełnej kontroli, skonfigurować http.Transport bezpośrednio. Pozwala to nastroić łączenie połączeń, ustawienia TLS i timeout:

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
}

Zalecane podejście: ProxyHat Go SDK

W ProxyHat Go SDK Zawija całą płytę do czystego API. Zarządza łączeniem połączeń, automatycznymi powtórkami, obsługą sesji i geocelowaniem dla Ciebie.

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 zwraca ustrukturyzowaną odpowiedź, obsługuje dekompresję i automatycznie ponownie włącza awarie przejściowe. Sprawdzić Dokumentacja API dla pełnego odniesienia metody.

Obracanie vs Sticky Sessions

ProxyHat obsługuje dwa tryby sesji:

• Obrót (domyślnie) - każda prośba otrzymuje nowy IP. Idealny dla dużej skali drapanie stron internetowych.
• Sticky - ten sam IP jest przechowywany przez konfigurowalny czas trwania (do 30 minut). Przydatne do wielostopniowych przepływów, takich jak sekwencje logowania lub pagowane pełzania.

Sesje obrotowe (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))
}

Sesje Sticky (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)

Nalepkie sesje (manualne)

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

Wnioski o udzielenie pozwolenia na dopuszczenie do obrotu

Potrzebujesz IP z konkretnego kraju? Podpory ProxyHat 190 + lokalizacje. Podaj kod kraju za pośrednictwem SDK lub jako znacznik nazwy użytkownika:

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

Geocelowanie jest niezbędne dla lokalizacji Śledzenie SERP, regionalne kontrole cen oraz testy dostępności treści.

Błąd obsługi i zatrzymywania

Żądania sieciowe poprzez proxy mogą się nie udać z przyczyn przejściowych: resety połączeń, timeout lub bloki tymczasowe. Solidne obchodzenie się z błędami jest kluczowe dla trzęsawek produkcyjnych.

SDK built- in retries

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

Ręczne powtórzenie z odwróceniem wykładniczym

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

Równoczesne zeskrobywanie z Goroutines

Model wymiany walut jest jego supermocarstwem. Z gorotynami i kanałami, można skrobać setki adresów URL jednocześnie zachowując minimalne zużycie pamięci.

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

Ograniczona stawka z semaforem

Rozdrabniacz powyżej już używa kanału semaforowego do zamykania połączeń. W celu ograniczenia wielkości ziaren (np. wymagania N na sekundę) należy użyć 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)
    }
}

Wskazówki dotyczące produkcji

Łączenie

Idź. http.Transport domyślnie utrzymuje pulę połączeń bezczynności. Dla proxy workloads, dostroić te ustawienia:

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

Czas

Zawsze ustalaj czas. Scraper bez timeout ostatecznie powieszą na zablokowanym połączeniu:

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)

Wyłączenie pełne gracji

W długotrwale biegnących scrappers, słuchać sygnałów OS, aby wyłączyć czysto:

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

Logowanie i obserwowalność

Owiń swój transport HTTP, aby zalogować się w czasie i kody stanu. Pomaga to zidentyfikować powolne cele i błędy proxy w produkcji:

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

• Gorotyny Go + proxy = masywna współzależność. Możesz uruchomić tysiące proksydowych żądań z minimalną pamięcią nad głową.
• ProxyHat Go SDK obsługuje uwierzytelnianie, powtórne próby, sesje i geocelowanie z czystym API. Zainstaluj Żeby pominąć płytę.
• Użyj rotacyjnych IP do skrobania w skali oraz lepkie sesje dla wielostopniowych przepływów roboczych, takich jak przepływ logowania.
• Zawsze ustaw czas na obu http.Client oraz poprzez context.WithTimeout do kontroli żądań.
• Odpowiedzialny limit opłat z golang.org/x/time/rate i cap concurrency z kanałami semaforowymi.
• Geo-target your requests poprzez przekazanie kodu kraju dostępu 190 + lokalizacje na całym świecie.
• Sprawdź nasz przewodnik na najlepsze proxy do skrobania stron internetowych wybrać odpowiedni plan dla obciążenia pracą.

Często zadawane pytania

Jak skonfigurować proxy w kliencie Go / http?

Ustaw Proxy pole http.Transport do http.ProxyURL(parsedURL) gdzie parsedURL Twój adres pośredniczący url.Parse()Następnie przekazać transport do http.Client. Standardowa biblioteka obsługuje Tunneling CONNECT dla celów HTTPS automatycznie.

Czy ProxyHat Go SDK obsługuje cele HTTPS?

Tak. SDK używa tunelowania HTTP CONNECT pod maską, więc cały ruch HTTPS jest zaszyfrowany end- to- end pomiędzy klientem a serwerem docelowym. Proxy widzi tylko adres docelowy.

Ile równoległych żądań mogę zrobić przez Go Proxy?

Gorotyny Go są niezwykle lekkie (około 4 KB stosu każdy), więc można uruchomić dziesiątki tysięcy jednocześnie. Praktyczny limit jest twój Plan ProxyHat równoczesne przyłączenie i pojemność serwera docelowego. Użyj kanału semaforowego, aby ograniczyć współzależność na bezpiecznym poziomie.

Jaka jest różnica między rotacyjnymi a lepkimi sesjami proxy?

Sesje rotacyjne przyporządkowują nowy adres IP do każdej prośby, która jest idealna do szerokiej obróbki. Sesje Sticky zachowują ten sam adres IP przez określony czas (do 30 minut), co sprawia, że nadają się do wielostopniowych przepływów tam, gdzie cel spodziewa się stałego gościa, takich jak sekwencje logowania lub strony wymeldowania.

Jak poradzić sobie z błędami proxy i powtórkami w Go?

ProxyHat Go SDK zapewnia wbudowaną logikę retry z konfigurowalną MaxRetries oraz RetryDelayJeśli korzystasz ze standardowej biblioteki, zaimplementuj backup wykładniczy poprzez owinięcie swojego żądania w pętlę, która podwaja opóźnienie po każdej nieudanej próbie. Zawsze sprawdzaj zarówno błędy sieciowe jak i kody stanu HTTP 5xx.