Usando Proxies em Go: Guia do Cliente HTTP e SDK

Por que usar Proxies em movimento?

Go tornou-se a linguagem de escolha para ferramentas de rede de alto desempenho, raspadores de web e clientes de API. Suas gorotinas leves, primitivas de concorrência incorporadas, e uma batalha testada net/http biblioteca padrão torná-lo ideal para aplicações proxy-powered que precisam lidar com milhares de pedidos concorrentes.

Se você está construindo um raspagem da web canalização, monitorização Rankings SERP, ou coletando dados de preços competitivos, roteando seus clientes Ir HTTP através de proxies permite girar endereços IP, contornar as restrições geográficas e evitar limites de taxa em escala.

Neste guia, você aprenderá a configurar Proxies em Go usando tanto a biblioteca padrão quanto o ProxyHat Ir para SDK. Cada trecho de código está pronto para copiar-colar para que você possa começar a raspar dentro de minutos.

Instalação

ProxyHat Ir para SDK

A maneira mais rápida de começar é com o SDK oficial. Ele lida com autenticação, rotação, geo-alvo, e volta fora da caixa.

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

Apenas biblioteca padrão

Se preferir zero dependências, vá net/http e net/url Os pacotes são tudo o que precisas. Nenhuma instalação extra necessária.

Autenticação e Configuração Básica

O ProxyHat usa autenticação de senha de usuário sobre o endpoint do proxy. Você encontrará suas credenciais no Painel do ProxyHat. Uma URL de proxy típica se parece com esta:

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

Mantenha as credenciais fora do código fonte. Usar variáveis de ambiente ou um .env arquivo:

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

Simples GET Pedido com um Proxy

Aqui está a abordagem mínima usando apenas a biblioteca padrão:

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

Execute-o e você verá um endereço IP residencial em vez de seu próprio. Cada pedido é encaminhado através do ProxyHat Grupo de procuração residencial.

Usando Tipos de Proxy Diferentes

ProxyHat suporta três tipos de proxy, cada um adequado para diferentes cargas de trabalho. Você seleciona o tipo através da porta proxy ou uma bandeira de nome de usuário:

Para uma comparação mais profunda de quando usar cada tipo, consulte nosso guia sobre residencial vs datacenter vs proxies móveis.

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

Abordagem Manual: Ir net/http com Configuração do Proxy

Para controle completo, configure o http.Transport directamente. Isso permite que você ajuste o agrupamento de conexões, as configurações do TLS e os timeouts:

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
}

Abordagem recomendada: ProxyHat Go SDK

A ProxyHat Ir para SDK envolve toda a caldeira em uma API limpa. Ele gerencia agrupamento de conexão, repetições automáticas, manipulação de sessão e geo-segmentação para você.

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

O SDK retorna uma resposta estruturada, lida com descompressão e tenta falhas transitórias automaticamente. Verificar o Documentação da API Para o método completo de referência.

Rodando vs Sessões Fixos

O ProxyHat suporta dois modos de sessão:

• Rodando (padrão) — cada pedido recebe um novo IP. Ideal para grandes dimensões raspagem da web.
• Fixo — o mesmo IP é mantido durante uma duração configurável (até 30 minutos). Útil para fluxos multi-step como sequências de login ou rastejamentos paginados.

Sessões rotativas (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))
}

Sessões fixas (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)

Sessões fixas (manuais)

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

Pedidos Geo- Targeted

Precisa de IPs de um país específico? Suportes do ProxyHat 190+ locais. Passe o código do país através do SDK ou como um nome de usuário:

// 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- direcionamento é essencial para localizado Monitoramento SERP, verificações regionais de preços e testes de disponibilidade de conteúdo.

Tratamento de Erros e Repetições

Pedidos de rede através de proxies podem falhar por razões transitórias: redefinições de conexão, timeouts ou blocos temporários. O manuseio robusto de erros é fundamental para raspadores de produção.

Reivindicações incorporadas do SDK

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

Repetir manualmente com recuo exponencial

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

Raspar concomitantemente com Goroutines

O modelo de concorrência da Go é a sua superpotência. Com gorotinas e canais, você pode raspar centenas de URLs simultaneamente, mantendo o uso mínimo de memória.

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

Taxa Limitando com um Semaphore

O raspador acima já usa um canal semáforo para fechar a concorrência. Para limites de taxa mais finos (por exemplo, pedidos de N por segundo), utilizar 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)
    }
}

Dicas de produção

Conjunto de ligações

Vai. http.Transport mantém um pool de conexões ociosas por padrão. Para cargas de trabalho de proxy, afina estas configurações:

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

Tempo- limite

Marca sempre os intervalos. Um raspador sem pausas acabará por manter uma ligação parada:

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)

Desligamento gracioso

Em raspadores de longa duração, ouça os sinais do SO para desligar de forma limpa:

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

Registo e observação

Enrole seu transporte HTTP para registrar os códigos de tempo e status da solicitação. Isso ajuda a identificar alvos lentos e erros de proxy na produção:

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
}

Tiras de Chaves

• Go's gorotines + proxies = concorrência maciça. Você pode executar milhares de pedidos de proxy com memória mínima em cima.
• O ProxyHat Ir SDK lida com autenticação, repetições, sessões e geo-alvo com uma API limpa. Instalar Para saltar a caldeira.
• Usar IPs rotativos para raspagem em escala e sessões pegajosas para fluxos de trabalho multi-step como fluxos de login.
• Sempre definir os timeouts em ambos os http.Client e via context.WithTimeout para controlo por pedido.
• Limite de taxa responsável com golang.org/x/time/rate e concorrência de tampa com canais semáforos.
• Geo- direcionar seus pedidos passando um código de país ao acesso 190+ locais mundial.
• Confira nosso guia sobre o melhores proxies para raspagem web escolher o plano certo para sua carga de trabalho.

Perguntas Frequentes

Como configuro um proxy no cliente de rede/http do Go?

Definir a Proxy campo em http.Transport para http.ProxyURL(parsedURL) em que parsedURL é o seu endereço proxy analisado com url.Parse(). Em seguida, passar o transporte para http.Client. A biblioteca padrão lida com o túnel CONNECT para alvos HTTPS automaticamente.

O ProxyHat Go SDK suporta alvos HTTPS?

Sim. O SDK usa o túnel HTTP CONNECT sob o capô, então todo o tráfego HTTPS é criptografado de ponta a ponta entre seu cliente e o servidor alvo. O proxy só vê o nome da máquina de destino.

Quantos pedidos simultâneos posso fazer através do Go proxies?

As gorotinas de Go são extremamente leves (cerca de 4 KB de pilha cada), então você pode executar dezenas de milhares simultaneamente. O limite prático é o seu Plano do ProxyHat a possibilidade de ligação simultânea e a capacidade do servidor alvo. Use um canal semáforo para reduzir a concorrência a um nível seguro.

Qual é a diferença entre sessões de proxy rotativas e grudentas?

Sessões rotativas atribuem um novo endereço IP a cada solicitação, que é ideal para raspagem ampla. Sessões fixas mantêm o mesmo IP por uma duração definida (até 30 minutos), tornando-os adequados para fluxos multi-step onde o alvo espera um visitante consistente, como sequências de login ou páginas de checkout.

Como faço para lidar com erros de proxy e repetições no Go?

O SDK ProxyHat Go fornece lógica de repetição incorporada com configurável MaxRetries e RetryDelay. Se usar a biblioteca padrão, implemente backoff exponencial, envolvendo sua solicitação em um loop que dobra o atraso após cada tentativa falhada. Verifique sempre se há erros de rede e códigos de estado HTTP 5xx.