Proxies verwenden in Go (Golang)

Die Verwendung von Proxys in Go beinhaltet die Konfiguration des http.Transport eines http.Client mit einer Proxy-Funktion, typischerweise http.ProxyURL für statische Proxys oder einer benutzerdefinierten Funktion für die dynamische Proxy-Auswahl.

Warum Proxys in Go verwenden?

Proxys dienen verschiedenen Zwecken in der Netzwerkkommunikation, insbesondere beim Senden von HTTP-Anfragen aus Go-Anwendungen:

• Anonymität: Maskierung der ursprünglichen IP-Adresse des Clients.
• Geo-Targeting: Zugriff auf Inhalte oder Dienste, die auf bestimmte geografische Regionen beschränkt sind, indem Anfragen über Proxys in diesen Regionen geleitet werden.
• Ratenbegrenzung: Verteilung von Anfragen auf mehrere IP-Adressen, um Ratenbegrenzungen von Zielservern zu vermeiden.
• Web Scraping: Erleichterung der groß angelegten Datenerfassung durch Rotation von IP-Adressen, Umgehung von Erkennung und Verwaltung des Anfragevolumens.
• Sicherheit & Filterung: Weiterleitung des Datenverkehrs durch Unternehmensproxys zur Sicherheitsüberprüfung, Inhaltsfilterung oder Zugriffssteuerung.
• Debugging: Abfangen und Überprüfen des Datenverkehrs.

Konfigurieren eines HTTP-Clients mit einem Proxy

Die Standardbibliothek net/http von Go bietet robuste Unterstützung für Proxy-Konfigurationen. Der primäre Mechanismus beinhaltet die Modifikation des http.Transport, der einem http.Client zugeordnet ist.

Verwenden von http.ProxyFromEnvironment

Die einfachste Methode, einen Proxy zu verwenden, ist die Nutzung von Umgebungsvariablen. Die Funktion http.ProxyFromEnvironment von Go prüft die Umgebungsvariablen HTTP_PROXY, HTTPS_PROXY und NO_PROXY.

• HTTP_PROXY: Wird für http://-Anfragen verwendet.
• HTTPS_PROXY: Wird für https://-Anfragen verwendet.
• NO_PROXY: Eine durch Kommas getrennte Liste von Hostnamen, die den Proxy umgehen sollen.

package main

import (
    "fmt"
    "io"
    "net/http"
    "os"
    "time"
)

func main() {
    // Umgebungsvariablen setzen (zu Demonstrationszwecken)
    os.Setenv("HTTP_PROXY", "http://your_proxy_ip:port")
    os.Setenv("HTTPS_PROXY", "http://your_proxy_ip:port") // Hinweis: HTTPS_PROXY kann ein HTTP-Proxy sein
    // os.Setenv("NO_PROXY", "localhost,127.0.0.1")

    client := &http.Client{
        Transport: &http.Transport{
            Proxy: http.ProxyFromEnvironment,
        },
        Timeout: 10 * time.Second,
    }

    resp, err := client.Get("http://httpbin.org/ip")
    if err != nil {
        fmt.Printf("Fehler beim Senden der Anfrage: %v\n", err)
        return
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        fmt.Printf("Fehler beim Lesen des Antwortkörpers: %v\n", err)
        return
    }
    fmt.Printf("Antwort von httpbin.org/ip:\n%s\n", body)

    os.Unsetenv("HTTP_PROXY")
    os.Unsetenv("HTTPS_PROXY")
}

Verwenden von http.ProxyURL für statische Proxys

Für eine explizite Proxy-Konfiguration wird http.ProxyURL verwendet. Diese Funktion nimmt eine *url.URL entgegen, die die Proxy-Adresse darstellt.

package main

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

func main() {
    proxyStr := "http://your_proxy_ip:port" // Ersetzen Sie dies durch Ihre Proxy-Adresse
    proxyURL, err := url.Parse(proxyStr)
    if err != nil {
        fmt.Printf("Fehler beim Parsen der Proxy-URL: %v\n", err)
        return
    }

    client := &http.Client{
        Transport: &http.Transport{
            Proxy: http.ProxyURL(proxyURL),
        },
        Timeout: 10 * time.Second,
    }

    resp, err := client.Get("http://httpbin.org/ip")
    if err != nil {
        fmt.Printf("Fehler beim Senden der Anfrage: %v\n", err)
        return
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        fmt.Printf("Fehler beim Lesen des Antwortkörpers: %v\n", err)
        return
    }
    fmt.Printf("Antwort von httpbin.org/ip:\n%s\n", body)
}

Proxy-Authentifizierung

Viele Proxys erfordern eine Authentifizierung. Für HTTP/HTTPS-Proxys, die Basic Authentication verwenden, können die Anmeldeinformationen direkt in die Proxy-URL eingebettet werden:

package main

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

func main() {
    // Format: "http://username:password@proxy_ip:port"
    proxyStr := "http://user:password@your_auth_proxy_ip:port" // Ersetzen Sie dies durch Ihren authentifizierten Proxy
    proxyURL, err := url.Parse(proxyStr)
    if err != nil {
        fmt.Printf("Fehler beim Parsen der Proxy-URL: %v\n", err)
        return
    }

    client := &http.Client{
        Transport: &http.Transport{
            Proxy: http.ProxyURL(proxyURL),
        },
        Timeout: 10 * time.Second,
    }

    resp, err := client.Get("http://httpbin.org/ip")
    if err != nil {
        fmt.Printf("Fehler beim Senden der Anfrage mit authentifiziertem Proxy: %v\n", err)
        return
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        fmt.Printf("Fehler beim Lesen des Antwortkörpers: %v\n", err)
        return
    }
    fmt.Printf("Antwort von httpbin.org/ip über authentifizierten Proxy:\n%s\n", body)
}

Verwenden von SOCKS5-Proxys

Während net/http HTTP/HTTPS-Proxys direkt unterstützt, erfordern SOCKS5-Proxys ein zusätzliches Paket: golang.org/x/net/proxy. SOCKS5 arbeitet auf einer niedrigeren Ebene als HTTP-Proxys und unterstützt verschiedene Protokolle.

Um einen SOCKS5-Proxy zu verwenden, müssen Sie einen Dialer mit dem proxy-Paket erstellen und diesen dann dem DialContext-Feld von http.Transport zuweisen.

package main

import (
    "context"
    "fmt"
    "io"
    "net"
    "net/http"
    "time"

    "golang.org/x/net/proxy" // Stellen Sie sicher, dass Sie 'go get golang.org/x/net/proxy' ausgeführt haben
)

func main() {
    socks5Proxy := "socks5://user:password@your_socks5_proxy_ip:port" // Ersetzen Sie dies durch Ihren SOCKS5-Proxy

    dialer, err := proxy.SOCKS5("tcp", socks5Proxy[len("socks5://"):], nil, proxy.Direct) // Basic Auth wird vom Dialer gehandhabt
    if err != nil {
        fmt.Printf("Fehler beim Erstellen des SOCKS5-Dialers: %v\n", err)
        return
    }

    // Für authentifizierte SOCKS5-Proxys handhabt die Funktion proxy.SOCKS5 dies, wenn die URL Anmeldeinformationen enthält.
    // Wenn die Funktion proxy.SOCKS5 Anmeldeinformationen nicht direkt parst, müssen Sie diese möglicherweise
    // extrahieren und eine proxy.Auth-Struktur übergeben. Beispiel:
    // auth := &proxy.Auth{User: "user", Password: "password"}
    // dialer, err := proxy.SOCKS5("tcp", "your_socks5_proxy_ip:port", auth, proxy.Direct)

    client := &http.Client{
        Transport: &http.Transport{
            DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
                return dialer.Dial(network, addr)
            },
            // Optional: TLSClientConfig für HTTPS über SOCKS5 setzen
            // TLSClientConfig: &tls.Config{InsecureSkipVerify: true}, // Mit Vorsicht verwenden
        },
        Timeout: 10 * time.Second,
    }

    resp, err := client.Get("http://httpbin.org/ip")
    if err != nil {
        fmt.Printf("Fehler beim Senden der Anfrage mit SOCKS5-Proxy: %v\n", err)
        return
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        fmt.Printf("Fehler beim Lesen des Antwortkörpers: %v\n", err)
        return
    }
    fmt.Printf("Antwort von httpbin.org/ip über SOCKS5-Proxy:\n%s\n", body)
}

Dynamische Proxy-Auswahl und Rotation

Für Anwendungen wie Web Scraping oder groß angelegte Datenerfassung ist die Proxy-Rotation unerlässlich, um IP-Sperren zu vermeiden und das Anfragevolumen zu verwalten. Dies erfordert eine benutzerdefinierte Proxy-Funktion für http.Transport.

Das Proxy-Feld von http.Transport erwartet eine Funktion mit der Signatur func(*http.Request) (*url.URL, error). Diese Funktion wird vor jeder Anfrage aufgerufen und ermöglicht eine dynamische Proxy-Auswahl basierend auf Anfrageeigenschaften oder einer Rotationsstrategie.

package main

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

// ProxyRotator verwaltet eine Liste von Proxys und bietet eine Round-Robin-Auswahl.
type ProxyRotator struct {
    proxies []*url.URL
    current int
    mu      sync.Mutex
}

// NewProxyRotator erstellt einen neuen ProxyRotator aus einem Slice von Proxy-URLs.
func NewProxyRotator(proxyStrings []string) (*ProxyRotator, error) {
    proxies := make([]*url.URL, len(proxyStrings))
    for i, s := range proxyStrings {
        u, err := url.Parse(s)
        if err != nil {
            return nil, fmt.Errorf("ungültige Proxy-URL '%s': %w", s, err)
        }
        proxies[i] = u
    }
    return &ProxyRotator{
        proxies: proxies,
        current: 0,
    }, nil
}

// GetProxy gibt den nächsten Proxy im Round-Robin-Verfahren zurück.
func (pr *ProxyRotator) GetProxy(_ *http.Request) (*url.URL, error) {
    if len(pr.proxies) == 0 {
        return nil, nil // Kein Proxy
    }

    pr.mu.Lock()
    defer pr.mu.Unlock()

    proxy := pr.proxies[pr.current]
    pr.current = (pr.current + 1) % len(pr.proxies)
    return proxy, nil
}

func main() {
    proxyList := []string{
        "http://user1:pass1@proxy1.example.com:8080",
        "http://user2:pass2@proxy2.example.com:8080",
        "http://user3:pass3@proxy3.example.com:8080",
    }

    rotator, err := NewProxyRotator(proxyList)
    if err != nil {
        fmt.Printf("Fehler beim Erstellen des Proxy-Rotators: %v\n", err)
        return
    }

    client := &http.Client{
        Transport: &http.Transport{
            Proxy: rotator.GetProxy, // Die GetProxy-Methode des Rotators zuweisen
        },
        Timeout: 15 * time.Second,
    }

    for i := 0; i < 5; i++ {
        resp, err := client.Get("http://httpbin.org/ip")
        if err != nil {
            fmt.Printf("Anfrage %d Fehler: %v\n", i+1, err)
            continue
        }
        defer resp.Body.Close()

        body, err := io.ReadAll(resp.Body)
        if err != nil {
            fmt.Printf("Anfrage %d Fehler beim Lesen des Körpers: %v\n", i+1, err)
            continue
        }
        fmt.Printf("Anfrage %d IP: %s\n", i+1, body)
        time.Sleep(1 * time.Second) // Eine Arbeitslast simulieren
    }
}

Dieses Beispiel implementiert einen einfachen Round-Robin-Rotator. Fortgeschrittenere Rotatoren könnten:
* Die Proxy-Integrität verfolgen und fehlerhafte Proxys entfernen.
* Verschiedene Rotationsstrategien implementieren (z.B. gewichtet, zufällig).
* Mit externen Proxy-Verwaltungsdiensten integrieren.

HTTPS-Verkehr über Proxys

Wenn ein http.Client eine https://-Anfrage über einen HTTP-Proxy sendet, führt der http.Transport einen CONNECT-Methoden-Handshake mit dem Proxy durch. Der Client fordert den Proxy auf, einen TCP-Tunnel zum Zielhost und -port (typischerweise 443) herzustellen. Sobald der Tunnel hergestellt ist, führt der Client den TLS-Handshake direkt mit dem Zielserver durch den Proxy-Tunnel durch. Der Proxy selbst entschlüsselt den HTTPS-Verkehr nicht (es sei denn, es handelt sich um einen "Man-in-the-Middle"-Proxy, was ein anderes Szenario ist, das spezifische Vertrauenskonfigurationen erfordert).

Für https://-Anfragen sollte die Proxy-Funktion die Proxy-URL wie gewohnt zurückgeben. Go's net/http handhabt die CONNECT-Methode automatisch.

TLS/SSL-Verifizierung

Standardmäßig führen Go-Clients eine strenge TLS-Zertifikatsprüfung durch. Wenn das Zertifikat des Zielservers nicht überprüft werden kann (z.B. selbstsigniert, abgelaufen oder nicht vertrauenswürdige CA), schlägt die Anfrage fehl.

In spezifischen Szenarien (z.B. Tests mit bekannten selbstsignierten Zertifikaten in einer kontrollierten Umgebung) können Sie die Zertifikatsprüfung mit InsecureSkipVerify in tls.Config deaktivieren.

package main

import (
    "crypto/tls"
    "fmt"
    "io"
    "net"
    "net/http"
    "net/url"
    "time"
)

func main() {
    proxyStr := "http://your_proxy_ip:port"
    proxyURL, err := url.Parse(proxyStr)
    if err != nil {
        fmt.Printf("Fehler beim Parsen der Proxy-URL: %v\n", err)
        return
    }

    // Einen benutzerdefinierten Transport für TLS-Einstellungen konfigurieren
    tr := &http.Transport{
        Proxy: http.ProxyURL(proxyURL),
        TLSClientConfig: &tls.Config{
            // WARNUNG: InsecureSkipVerify sollte in Produktionsumgebungen nicht verwendet werden.
            // Es deaktiviert die Überprüfung der Zertifikatskette und des Hostnamens.
            InsecureSkipVerify: true,
        },
        DialContext: (&net.Dialer{
            Timeout:   30 * time.Second,
            KeepAlive: 30 * time.Second,
        }).DialContext,
        MaxIdleConns:        100,
        IdleConnTimeout:     90 * time.Second,
        TLSHandshakeTimeout: 10 * time.Second,
        ExpectContinueTimeout: 1 * time.Second,
    }

    client := &http.Client{
        Transport: tr,
        Timeout: 15 * time.Second, // Gesamtes Anfrage-Timeout
    }

    // Beispielziel für HTTPS
    resp, err := client.Get("https://example.com")
    if err != nil {
        fmt.Printf("Fehler beim Senden der HTTPS-Anfrage mit Proxy: %v\n", err)
        return
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        fmt.Printf("Fehler beim Lesen des Antwortkörpers: %v\n", err)
        return
    }
    fmt.Printf("Antwortstatus von https://example.com: %s\n", resp.Status)
    // fmt.Printf("Antwortkörper: %s\n", body) // Aus Gründen der Kürze weggelassen
    _ = body
}

Vergleich: HTTP/HTTPS- vs. SOCKS5-Proxys

Best Practices

• Timeouts setzen: Konfigurieren Sie immer Timeouts für http.Client und http.Transport (z.B. DialContext, TLSHandshakeTimeout), um zu verhindern, dass Anfragen unbegrenzt hängen bleiben, insbesondere bei unzuverlässigen Proxys.
• Robuste Fehlerbehandlung: Proxy-bezogene Fehler können variieren (z.B. net.OpError für Verbindungsprobleme, io.EOF für unerwartete Trennungen). Implementieren Sie eine umfassende Fehlerbehandlung und Wiederholungslogik.
• Proxy-Verwaltung: Implementieren Sie für dynamische Szenarien ein robustes Proxy-Verwaltungssystem, das die Proxy-Integrität überwacht, Proxys effektiv rotiert und Fehler elegant behandelt.
• Ressourcenverwaltung: Stellen Sie sicher, dass resp.Body.Close() mit defer aufgerufen wird, um Netzwerkressourcen freizugeben.
• Kontext für Abbruch: Verwenden Sie context.Context mit http.Request, um die Anforderungsabbruch- und Timeout-Verwaltung über Funktionen hinweg zu ermöglichen.
• Vermeiden Sie InsecureSkipVerify: Verwenden Sie InsecureSkipVerify = true nicht in Produktionsumgebungen, es sei denn, Sie verstehen die Sicherheitsauswirkungen vollständig und verfügen über kompensierende Kontrollen.