Proxy in Go: Konfiguration von http.Client mit einem Proxy-Server

```html

Wenn Sie einen Parser schreiben, Datenautomatisierung durchführen oder APIs aus verschiedenen Regionen testen – werden Sie früher oder später auf IP-Sperren stoßen. Go ist eine der beliebtesten Sprachen zur Erstellung von leistungsstarken Netzwerktools, und die Einrichtung von Proxys hat hier ihre Besonderheiten. In diesem Leitfaden werden wir alles von der grundlegenden Konfiguration des http.Client bis zur fortgeschrittenen IP-Rotation mit SOCKS5-Unterstützung behandeln.

Warum Proxys in Go-Anwendungen benötigt werden

Go ist zum De-facto-Standard für die Erstellung von hochbelasteten Netzwerktools geworden: Parser, Crawler, Preisüberwachungsbots, API-Automatisierungstools. Hier entsteht am häufigsten der Bedarf an Proxys – und hier ist es wichtig, alles von Anfang an richtig einzurichten.

Die Hauptszenarien, in denen man nicht auf Proxys verzichten kann:

Parsing von Marktplätzen – Wildberries, Ozon, AliExpress blockieren IPs nach 50–200 Anfragen von einer Adresse. Ohne IP-Wechsel stoppt der Parser.
Geo-Testing – Überprüfung der Suchergebnisse, Werbeanzeigen oder Preise aus verschiedenen Ländern und Regionen.
Umgehung von Rate-Limits – Verteilung der Last auf mehrere IPs ermöglicht es, die Beschränkungen für die Anzahl der Anfragen pro Minute zu umgehen.
Anonymität – Verbergen der echten IP des Servers bei der Arbeit mit externen APIs.
Testen von CDN und Geolokalisierung – Überprüfung der korrekten Bereitstellung von Inhalten für verschiedene Regionen.

Die Standardbibliothek von Go bietet flexible Werkzeuge für die Arbeit mit Proxys – über http.Transport und http.Client. Lassen Sie uns jeden Ansatz im Detail betrachten.

Grundlegende Einrichtung von HTTP-Proxys über http.Client

In Go wird der Proxy auf der Ebene von http.Transport – der Transportschicht des HTTP-Clients – eingerichtet. Dies gibt Ihnen die volle Kontrolle darüber, über welchen Proxy die Anfragen gesendet werden, und ermöglicht es, mehrere Clients mit unterschiedlichen Proxys gleichzeitig zu erstellen.

Ein minimales funktionierendes Beispiel zur Einrichtung eines HTTP-Proxys:

package main

import (
    "fmt"
    "io"
    "net/http"
    "net/url"
)

func main() {
    // Geben Sie die Adresse des Proxy-Servers an
    proxyURL, err := url.Parse("http://123.45.67.89:8080")
    if err != nil {
        panic(err)
    }

    // Erstellen Sie einen Transport mit Proxy
    transport := &http.Transport{
        Proxy: http.ProxyURL(proxyURL),
    }

    // Erstellen Sie einen Client mit unserem Transport
    client := &http.Client{
        Transport: transport,
    }

    // Machen Sie eine Anfrage über den Proxy
    resp, err := client.Get("https://httpbin.org/ip")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

Was in diesem Code passiert:

url.Parse – parst die Zeichenfolge mit der Proxy-Adresse in eine *url.URL Struktur
http.Transport{Proxy: http.ProxyURL(proxyURL)} – erstellt einen Transport, der alle Anfragen über den angegebenen Proxy leitet
http.Client{Transport: transport} – erstellt einen Client mit unserem Transport

Ein wichtiger Punkt: Wenn Sie http.DefaultClient verwenden (d.h. einfach http.Get() ohne expliziten Client), wird der Proxy nicht angewendet. Erstellen Sie immer Ihren eigenen http.Client für die Arbeit mit Proxys.

💡 Tipp

Fügen Sie einen Timeout in http.Client hinzu: Timeout: 30 * time.Second. Proxy-Server können langsamer antworten als eine direkte Verbindung, und ohne Timeout können Goroutinen endlos hängen bleiben.

Proxys über Umgebungsvariablen

Go unterstützt Standard-Umgebungsvariablen für Proxys – HTTP_PROXY, HTTPS_PROXY und NO_PROXY. Der Standardtransport http.DefaultTransport liest sie automatisch über die Funktion http.ProxyFromEnvironment.

Setzen Sie die Umgebungsvariablen vor dem Start der Anwendung:

# Im Terminal (Linux/macOS)
export HTTP_PROXY="http://123.45.67.89:8080"
export HTTPS_PROXY="http://123.45.67.89:8080"
export NO_PROXY="localhost,127.0.0.1"

# Starten Sie die Anwendung
go run main.go

Wenn Sie ProxyFromEnvironment in Ihrem eigenen Transport verwenden möchten (z.B. mit zusätzlichen TLS-Einstellungen), tun Sie Folgendes:

transport := &http.Transport{
    Proxy: http.ProxyFromEnvironment,
    // Zusätzliche Einstellungen...
    TLSHandshakeTimeout:   10 * time.Second,
    ResponseHeaderTimeout: 30 * time.Second,
}

client := &http.Client{
    Transport: transport,
    Timeout:   60 * time.Second,
}

Dieser Ansatz ist praktisch für Produktionsumgebungen, in denen die Proxy-Adresse über die Bereitstellungskonfiguration (Docker, Kubernetes, systemd) festgelegt wird und nicht im Code hardcodiert ist. Dies erleichtert auch den Wechsel des Proxys ohne eine erneute Kompilierung der Anwendung.

Anschluss von SOCKS5-Proxys in Golang

SOCKS5 ist ein universellerer Protokolltyp im Vergleich zu HTTP-Proxys. Es arbeitet auf einer niedrigeren Ebene und unterstützt alle TCP/UDP-Verbindungen, nicht nur HTTP/HTTPS. Für die Arbeit mit Parsern und Automatisierungen ist SOCKS5 oft vorzuziehen – insbesondere bei der Verwendung von residential Proxys, die in der Regel genau über dieses Protokoll bereitgestellt werden.

Um mit SOCKS5 in Go zu arbeiten, benötigen Sie das Paket golang.org/x/net/proxy:

go get golang.org/x/net/proxy

Beispiel für die Verbindung zu einem SOCKS5-Proxy ohne Authentifizierung:

package main

import (
    "fmt"
    "io"
    "net/http"
    "golang.org/x/net/proxy"
)

func main() {
    // Erstellen Sie einen SOCKS5-Dialer
    dialer, err := proxy.SOCKS5("tcp", "123.45.67.89:1080", nil, proxy.Direct)
    if err != nil {
        panic(err)
    }

    // Erstellen Sie einen Transport mit benutzerdefiniertem Dialer
    transport := &http.Transport{
        Dial: dialer.Dial,
    }

    client := &http.Client{
        Transport: transport,
    }

    resp, err := client.Get("https://httpbin.org/ip")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))
}

Seit Go 1.20+ kann auch die integrierte Unterstützung für SOCKS5 über url.Parse mit dem Präfix socks5:// verwendet werden:

proxyURL, _ := url.Parse("socks5://123.45.67.89:1080")

transport := &http.Transport{
    Proxy: http.ProxyURL(proxyURL),
}

client := &http.Client{Transport: transport}

Diese Syntax ist einfacher und erfordert keine zusätzlichen Abhängigkeiten. Für komplexere Szenarien (z.B. SOCKS5 mit Authentifizierung in älteren Go-Versionen) bleibt das Paket golang.org/x/net/proxy jedoch relevant.

Authentifizierung: Benutzername und Passwort im Proxy

Die meisten kommerziellen Proxy-Anbieter verwenden die Authentifizierung mit Benutzername und Passwort. Es gibt zwei Möglichkeiten, die Anmeldeinformationen in Go zu übergeben.

Methode 1: In die URL einbetten

// Format: protocol://username:password@host:port
proxyURL, err := url.Parse("http://myuser:[email protected]:8080")
if err != nil {
    panic(err)
}

transport := &http.Transport{
    Proxy: http.ProxyURL(proxyURL),
}

client := &http.Client{
    Transport: transport,
    Timeout:   30 * time.Second,
}

Methode 2: Über die Struktur url.URL (sicherer)

proxyURL := &url.URL{
    Scheme: "http",
    Host:   "proxy.example.com:8080",
    User:   url.UserPassword("myuser", "mypassword"),
}

transport := &http.Transport{
    Proxy: http.ProxyURL(proxyURL),
}

client := &http.Client{
    Transport: transport,
    Timeout:   30 * time.Second,
}

Die zweite Methode ist vorzuziehen – sie behandelt spezielle Zeichen im Passwort (z.B. @, #, :), die das Parsen der URL in der ersten Variante stören könnten.

Für SOCKS5 mit Authentifizierung über das Paket golang.org/x/net/proxy:

auth := &proxy.Auth{
    User:     "myuser",
    Password: "mypassword",
}

dialer, err := proxy.SOCKS5("tcp", "proxy.example.com:1080", auth, proxy.Direct)
if err != nil {
    panic(err)
}

transport := &http.Transport{
    Dial: dialer.Dial,
}

client := &http.Client{
    Transport: transport,
    Timeout:   30 * time.Second,
}

⚠️ Sicherheit

Hardcodieren Sie niemals Benutzername und Passwort des Proxys direkt im Code. Verwenden Sie Umgebungsvariablen oder Konfigurationsdateien, die nicht in das Repository gelangen. Fügen Sie .env zu .gitignore hinzu.

Proxy-Rotation: IP-Wechsel zwischen Anfragen

Ein Proxy ist gut für Tests, aber für echtes Parsing ist eine IP-Rotation erforderlich. Websites verfolgen die Häufigkeit von Anfragen von einer Adresse, und selbst ein guter Proxy wird blockiert, wenn Sie tausende Anfragen hintereinander senden.

Es gibt zwei Ansätze zur Rotation in Go:

Ansatz 1: Liste von Proxys mit Round-Robin

package main

import (
    "fmt"
    "io"
    "net/http"
    "net/url"
    "sync/atomic"
    "time"
)

type ProxyRotator struct {
    proxies []*url.URL
    counter uint64
}

func NewProxyRotator(proxyURLs []string) (*ProxyRotator, error) {
    proxies := make([]*url.URL, 0, len(proxyURLs))
    for _, p := range proxyURLs {
        u, err := url.Parse(p)
        if err != nil {
            return nil, err
        }
        proxies = append(proxies, u)
    }
    return &ProxyRotator{proxies: proxies}, nil
}

// GetClient gibt einen Client mit dem nächsten Proxy im Kreis zurück
func (r *ProxyRotator) GetClient() *http.Client {
    idx := atomic.AddUint64(&r.counter, 1) % uint64(len(r.proxies))
    proxyURL := r.proxies[idx]

    transport := &http.Transport{
        Proxy: http.ProxyURL(proxyURL),
    }

    return &http.Client{
        Transport: transport,
        Timeout:   30 * time.Second,
    }
}

func main() {
    proxyList := []string{
        "http://user:[email protected]:8080",
        "http://user:[email protected]:8080",
        "http://user:[email protected]:8080",
    }

    rotator, err := NewProxyRotator(proxyList)
    if err != nil {
        panic(err)
    }

    // Jede Anfrage geht über den nächsten Proxy
    for i := 0; i < 10; i++ {
        client := rotator.GetClient()
        resp, err := client.Get("https://httpbin.org/ip")
        if err != nil {
            fmt.Printf("Fehler bei Anfrage %d: %v\n", i, err)
            continue
        }
        body, _ := io.ReadAll(resp.Body)
        resp.Body.Close()
        fmt.Printf("Anfrage %d: %s\n", i, string(body))
    }
}

Ansatz 2: Dynamische Auswahl von Proxys über eine Funktion

Das Feld Proxy in http.Transport akzeptiert eine Funktion mit der Signatur func(*http.Request) (*url.URL, error). Dies ermöglicht es, Proxys dynamisch für jede Anfrage auszuwählen:

proxies := []*url.URL{
    mustParseURL("http://proxy1.example.com:8080"),
    mustParseURL("http://proxy2.example.com:8080"),
    mustParseURL("http://proxy3.example.com:8080"),
}

var counter uint64

transport := &http.Transport{
    Proxy: func(req *http.Request) (*url.URL, error) {
        // Wählen Sie den Proxy basierend auf der Anfrage (Round-Robin)
        idx := atomic.AddUint64(&counter, 1) % uint64(len(proxies))
        return proxies[idx], nil
    },
}

client := &http.Client{
    Transport: transport,
    Timeout:   30 * time.Second,
}

func mustParseURL(s string) *url.URL {
    u, err := url.Parse(s)
    if err != nil {
        panic(err)
    }
    return u
}

Der zweite Ansatz ist eleganter – ein Client rotiert automatisch die Proxys für jede Anfrage. Dies ist besonders praktisch bei gleichzeitigen Anfragen über Goroutinen.

Welchen Proxy-Typ für ein Go-Projekt wählen

Die Wahl des Proxy-Typs hat direkten Einfluss auf den Erfolg Ihres Projekts. Für verschiedene Aufgaben eignen sich unterschiedliche Typen – lassen Sie uns die Hauptvarianten durchgehen:

Proxy-Typ	Geschwindigkeit	Anonymität	Am besten geeignet für
Rechenzentrum	⚡ Hoch	Mittel	Parsing von offenen Daten, API-Tests, Lasttests
Residential	🔄 Mittel	Hoch	Parsing von Marktplätzen (Wildberries, Ozon), Umgehung von Anti-Bot-Schutz
Mobile	🔄 Mittel	Maximal	Arbeiten mit sozialen Netzwerken, Diensten mit strenger Anti-Bot-Schutz

Für das Parsing von Marktplätzen (Wildberries, Ozon, Avito): Verwenden Sie Residential-Proxys. Diese Plattformen nutzen aktiv Bot-Erkennungssysteme (Cloudflare, eigene Lösungen) und blockieren leicht IPs von Rechenzentren. Residential-IPs sehen aus wie normale Heimbenutzer.

Für API-Tests und Lasttests: Rechenzentrums-Proxys sind die optimale Wahl. Hohe Geschwindigkeit, stabile Verbindung, vorhersehbare Latenz.

Für Geo-Tests: Residential-Proxys mit Länder-/Stadtwahl. Sie ermöglichen es, zu überprüfen, wie Ihr Dienst oder Ihre Werbung für Benutzer aus einer bestimmten Region aussieht.

Häufige Fehler und bewährte Praktiken

Über die Jahre der Arbeit mit Proxys in Go-Projekten hat sich eine Liste typischer Fehler herauskristallisiert, die die Entwicklung verlangsamen und die Zuverlässigkeit von Parsern verringern. Lassen Sie uns jeden einzelnen betrachten.

Fehler 1: Wiederverwendung des Transports ohne Schließen von Verbindungen

http.Transport cached TCP-Verbindungen (Keep-Alive). Wenn Sie für jede Anfrage einen neuen Transport erstellen, verlieren Sie diesen Vorteil. Wenn Sie jedoch einen Transport mit festem Proxy bei der Rotation wiederverwenden – können Anfragen über die alte Verbindung laufen, ohne den neuen Proxy zu nutzen.

Lösung: Rufen Sie beim Wechsel des Proxys transport.CloseIdleConnections() auf oder verwenden Sie einen funktionalen Ansatz mit dynamischer Proxy-Auswahl (beschrieben im Abschnitt über Rotation).

Fehler 2: Keine Fehlerbehandlung für Proxys

Proxys können nicht verfügbar, überlastet oder von der Zielwebsite blockiert sein. Ohne Retry-Logik stoppt Ihr Parser beim ersten Fehler.

func fetchWithRetry(client *http.Client, targetURL string, maxRetries int) ([]byte, error) {
    var lastErr error
    for i := 0; i < maxRetries; i++ {
        resp, err := client.Get(targetURL)
        if err != nil {
            lastErr = err
            time.Sleep(time.Duration(i+1) * time.Second) // Exponentielle Verzögerung
            continue
        }
        defer resp.Body.Close()

        if resp.StatusCode == 429 || resp.StatusCode == 403 {
            lastErr = fmt.Errorf("blockiert: Status %d", resp.StatusCode)
            time.Sleep(time.Duration(i+1) * 2 * time.Second)
            continue
        }

        return io.ReadAll(resp.Body)
    }
    return nil, fmt.Errorf("alle Versuche erschöpft: %w", lastErr)
}

Fehler 3: Ignorieren der TLS-Überprüfung

Einige Entwickler deaktivieren die Überprüfung von TLS-Zertifikaten für Proxys (InsecureSkipVerify: true). Dies schafft eine Schwachstelle für MITM-Angriffe. Wenn der Proxy-Server ein selbstsigniertes Zertifikat verwendet – fügen Sie es dem vertrauenswürdigen Pool hinzu, anstatt die Überprüfung vollständig zu deaktivieren.

Fehler 4: Gleiche Header für alle Anfragen

Selbst mit Proxy-Rotation können Sie aufgrund des Header-Musters blockiert werden. Ändern Sie User-Agent zusammen mit dem Proxy, fügen Sie realistische Browser-Header hinzu:

userAgents := []string{
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/119.0.0.0 Safari/537.36",
    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 Chrome/118.0.0.0 Safari/537.36",
}

req, _ := http.NewRequest("GET", targetURL, nil)
req.Header.Set("User-Agent", userAgents[rand.Intn(len(userAgents))])
req.Header.Set("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8")
req.Header.Set("Accept-Language", "ru-RU,ru;q=0.9,en-US;q=0.8,en;q=0.7")
req.Header.Set("Accept-Encoding", "gzip, deflate, br")

Checkliste für einen zuverlässigen Proxy-Client in Go

✅ Timeout beim Client (Timeout: 30 * time.Second)
✅ Retry-Logik mit exponentieller Verzögerung
✅ Proxy-Rotation bei Fehlern 403/429
✅ Rotation des User-Agent zusammen mit dem Proxy
✅ Protokollierung von Fehlern mit Angabe des verwendeten Proxys
✅ Anmeldeinformationen über Umgebungsvariablen, nicht hardcodiert
✅ Schließen von resp.Body über defer
✅ Begrenzung der Parallelität über Semaphore oder Worker-Pool

Beispiel eines vollständigen Worker-Pools mit Proxy-Rotation

package main

import (
    "fmt"
    "io"
    "net/http"
    "net/url"
    "sync"
    "sync/atomic"
    "time"
)

type Scraper struct {
    proxies []*url.URL
    counter uint64
    workers int
}

func (s *Scraper) getClient() *http.Client {
    idx := atomic.AddUint64(&s.counter, 1) % uint64(len(s.proxies))
    return &http.Client{
        Transport: &http.Transport{
            Proxy: http.ProxyURL(s.proxies[idx]),
        },
        Timeout: 30 * time.Second,
    }
}

func (s *Scraper) Scrape(urls []string) map[string]string {
    results := make(map[string]string)
    var mu sync.Mutex
    var wg sync.WaitGroup

    sem := make(chan struct{}, s.workers) // Semaphore zur Begrenzung der Parallelität

    for _, u := range urls {
        wg.Add(1)
        go func(targetURL string) {
            defer wg.Done()
            sem <- struct{}{}
            defer func() { <-sem }()

            client := s.getClient()
            resp, err := client.Get(targetURL)
            if err != nil {
                fmt.Printf("Fehler: %v\n", err)
                return
            }
            defer resp.Body.Close()

            body, _ := io.ReadAll(resp.Body)

            mu.Lock()
            results[targetURL] = string(body)
            mu.Unlock()
        }(u)
    }

    wg.Wait()
    return results
}

Fazit

Die Einrichtung von Proxys in Go ist eine Aufgabe, die mit wenigen Codezeilen gelöst werden kann, aber ein Verständnis der Nuancen erfordert: die richtige Verwendung von http.Transport, die korrekte Handhabung der Authentifizierung, die geschickte Rotation von IPs und die Fehlerbehandlung. Die Standardbibliothek bietet alles Notwendige für HTTP-Proxys, und das Paket golang.org/x/net/proxy deckt den Bedarf an SOCKS5 ab.

Wichtige Erkenntnisse aus dem Artikel:

Erstellen Sie immer Ihren eigenen http.Client – http.DefaultClient unterstützt Proxys nicht direkt
Verwenden Sie einen funktionalen Ansatz (Proxy: func(r *Request) (*url.URL, error)) für dynamische Rotation
Speichern Sie Anmeldeinformationen in Umgebungsvariablen, nicht im Code
Fügen Sie eine Retry-Logik hinzu – Proxys sind nicht zu 100% zuverlässig
Ändern Sie den User-Agent zusammen mit dem Proxy für maximale Effizienz

Wenn Sie einen Parser für Marktplätze wie Wildberries oder Ozon schreiben, empfehlen wir die Verwendung von residential Proxys – sie haben echte IPs von Heimnutzern und werden deutlich seltener von Anti-Bot-Systemen blockiert. Für hochbelastete Szenarien mit Tausenden von Anfragen pro Minute sind Rechenzentrums-Proxys die optimale Wahl – sie bieten maximale Geschwindigkeit und Stabilität der Verbindung.