Goでプロキシを使う方法：HTTPクライアントとSDKガイド

なぜGoでプロキシを使用するのですか?

高性能なネットワークツール、Webスクレーパー、API クライアントの選択肢の言語になりました。 軽量のガルーチン、組み込みの通貨のプリミティブ、戦闘テスト net/http 標準ライブラリは、何千もの同時リクエストを処理する必要があるプロキシ機能のアプリケーションに最適です。

あなたが構築しているかどうか ウェブスクレイピング パイプライン、監視 SERPランキング競争力のある価格設定データを収集したり、プロキシを介してGo HTTPクライアントをルーティングすることで、IPアドレスを回転させ、地理的な制限を回避し、スケールでのレート制限を回避できます。

このガイドでは、設定方法を学びます ゴーでプロキシ 標準ライブラリと標準ライブラリの両方を使用する ProxyHat ゴー SDK. すべてのコードスニペットはコピーペースト読み取りなので、数分でスクレイピングを開始できます。

導入事例

ProxyHat ゴー SDK

スタートする最速の方法は、公式SDKです。 認証、回転、ジオターゲティング、箱から取り出します。

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

標準ライブラリのみ

ゼロの依存関係を好むなら、Go's net/http そして、 net/url パッケージは必要なすべてです。 追加のインストールは必要ありません。

認証と基本設定

ProxyHat は、プロキシエンドポイント上でのユーザー名パスワード認証を使用します。 資格情報を見つける ProxyHatダッシュボード. 典型的なプロキシ 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アドレスが表示されます。 ProxyHat のリクエストは、 住宅のプロキシプール. .

異なるプロキシタイプを使用する

ProxyHat は 3 つのプロキシタイプ、それぞれ異なるワークロードに対応しています。 プロキシポートまたはユーザー名フラグでタイプを選択します。

それぞれのタイプを使うときのより深い比較については、ガイドを参照してください。 住宅対データセンター対モバイルプロキシ. .

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

手動アプローチ: プロキシ構成でnet/http を行きます

完全な制御のために、構成して下さい http.Transport 直接。 これにより、接続プール、TLS設定、およびタイムアウトをチューニングできます。

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

ザ・オブ・ザ・ ProxyHat ゴー SDK すべてのボイラープレートをクリーンな API にラップします。 接続プール、自動レトリー、セッションハンドリング、ジオターゲティングを管理します。

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 は、構造化されたレスポンスを返し、解凍を処理します。また、トランジェントの失敗を自動的に処理します。 チェックイン API ドキュメント 完全な方法参照のため。

回転対粘着セッション

ProxyHat は 2 つのセッションモードをサポートしています。

• 回転 (デフォルト) — すべての人が新しいIPを要求します。 大規模に最適 ウェブスクレイピング. .
• スティッキー — 設定可能な期間(最大30分)で同じIPが保持されます。 ログインシーケンスやペジネーションクロールなどのマルチステップフローに便利です。

回転セッション(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))
}

スティッキーセッション(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)

スティッキーセッション(マニュアル)

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

ジオターゲットリクエスト

特定の国から IP が必要ですか? ProxyHat サポート 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トラッキング, 地域価格設定チェック, コンテンツの可用性テスト.

エラー処理と復元

プロキシによるネットワークリクエストは、接続のリセット、タイムアウト、または一時的なブロックの一時的な理由で失敗することができます。 生産スクレーパーの誤り処理は必須です。

SDK組み込みの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)
}

ゴルチンと並列スクレイピング

ゴールの対立モデルは、そのスーパーパワーです。 goroutinesとチャンネルで、メモリ使用量を最小限に抑えながら、同時に数百のURLをスクレイピングできます。

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

Semaphoreでレート制限

上記のスクレーパーは、既にセマフォアチャンネルを使用して、通貨をキャップします。 細粒率制限(例、毎秒Nリクエスト)の場合は、使用 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)
}

ログおよび観察性

HTTP トランスポートをラップして、タイミングとステータスコードをリクエストします。 これは、生産中のスローターゲットとプロキシエラーを特定するのに役立ちます。

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
}

キーテイクアウト

• Go's goroutines +プロキシ = 大規模な通貨。 最小限のメモリオーバーヘッドで何千ものプロキシルートリクエストを実行できます。
• ProxyHat ゴー SDK 認証、レトリー、セッション、およびジオターゲティングをクリーンなAPIで処理します。 インストール ボイラープレートをスキップします。
• 回転IPを使用する スケールでスクレイピングし、 スティッキーセッション ログインフローなどのマルチステップワークフロー
• 常にタイムアウトを設定 両方で http.Client そして、 context.WithTimeout 要求ごとの制御のため。
• レート・リミットの責任 お問い合わせ golang.org/x/time/rate そしてsemaphoreチャネルが付いている帽子のconcurrency。
• リクエストをジオターゲティング 国コードを渡すことでアクセス 190+店舗 世界中。
• ガイドを見る ウェブスクレイピングに最適なプロキシ ワークロードに適したプランを選ぶ

よくある質問

Goのnet/httpクライアントでプロキシを設定するにはどうすればよいですか?

設定する Proxy フィールド http.Transport お問い合わせ http.ProxyURL(parsedURL) 所在地: parsedURL あなたのプロキシアドレスは、 url.Parse(). それからへの輸送を渡して下さい http.Client. 標準ライブラリは、自動的に HTTPS ターゲットの CONNECT トンネルを処理します。

ProxyHat Go SDK は HTTPS ターゲットをサポートしていますか?

はい。 SDK は、フードの下に HTTP CONNECT トンネルを使用しており、HTTPS トラフィックはすべてクライアントとターゲットサーバー間で暗号化されたエンドツーエンドです。 プロキシは、宛先のホスト名だけが表示されます。

Goプロキシを通して、同時リクエスト数がいくつあるのでしょうか?

ゴルテインは、非常に軽量(それぞれ4 KBのスタック)なので、何千人もの同時実行が可能です。 実用的な限界はあなたのです ProxyHatプラン 同時接続許容とターゲットサーバの容量。 セマフォアチャンネルを使用して、安全なレベルでの対立性をキャップします。

回転と粘りのあるプロキシセッションの違いは何ですか?

セッションを回転させると、新しいIPアドレスをすべてのリクエストに割り当て、広範なスクレイピングに最適です。 スティッキーセッションは、同じIPをセット期間(最大30分)に保ち、ターゲットがログインシーケンスやチェックアウトページなど、一貫した訪問者を期待するマルチステップフローに適しています。

どのようにしてプロキシエラーとレトリーを処理しますか?

ProxyHat Go SDK は、組み込みのリトライロジックをコンフィギュラブルで提供します。 MaxRetries そして、 RetryDelay. 標準ライブラリを使用する場合は、失敗した試みの後の遅延を倍増させるループでリクエストをラップすることで、指数関数的なバックオフを実行します。 ネットワークエラーとHTTP 5xxステータスコードの両方を常にチェックします。