Web scraping proxy setup by language - Go, Kotlin, Scala, Perl and Elixir - DataImpulse

Dies ist eine Referenzseite statt eines Tutorials: die funktionierende Proxy-Konfiguration für Scraping in fünf Sprachen, deren Zielgruppe klein genug ist, dass ein eigener Leitfaden pro Sprache fünfmal dasselbe sagen würde. Go, Kotlin, Scala, Perl und Elixir, mit dem Code, der Bibliothekswahl und der einen Falle, die in jeder Sprache am meisten Zeit kostet.

Die Regel, die für alle gilt, ist dieselbe. Die Proxy-Einrichtung für Web Scraping gehört auf das Client-Objekt, wird einmal konfiguriert und wiederverwendet, denn dieser Client führt den Verbindungspool, den Cookie-Speicher und bei einer Sticky Session die Exit-Adresse. Alles, was für jede Anfrage einen neuen Client erstellt, verwirft alle drei.


Wichtige Fakten

  • Eine Regel gilt für jede Sprache hier: Konfiguriere den Proxy einmal auf dem Client-Objekt und verwende diesen Client wieder, denn der Client führt den Verbindungspool, die Cookies und die Exit-Identität.
  • Go: http.Transport mit http.ProxyURL, colly für die Crawler-Anforderungen. Die Falle: http.Client hat kein Standard-Timeout.
  • Kotlin: OkHttp mit einem proxyAuthenticator. Die Falle ist ein Authenticator, der nie null zurückgibt und bei einem falschen Passwort in einer Schleife läuft.
  • Scala: sttp mit Backend-Optionen. Die Falle: Das JDK deaktiviert Basic-Proxy-Authentifizierung bei HTTPS-Tunneln.
  • Perl und Elixir: LWP berücksichtigt HTTPS_PROXY aus der Umgebung und kann deinen Code überschreiben; in Elixir gehören Proxy-Optionen zum Adapter, nicht zu Req.

Die Regel aus 3 Teilen, die für jede Sprache hier gilt

Halte Transport, Parsing und Planung in getrennten Schichten, dann zeigt dir ein fehlerhaftes Scraping, wo es fehlgeschlagen ist.

Teil Verantwortet Symptom bei Fehler
1. Transport Verbindung, Proxy, Timeouts, Wiederholungen, TLS Status ungleich 200, Timeouts, TLS-Fehler
2. Parsing Bytes zu Feldern und deutliche Fehler, wenn sich das Markup verschiebt 200 mit leeren Feldern
3. Planung Gleichzeitigkeit pro Host, Taktung, Backoff Erfolg, der über Minuten nachlässt

Jede Sprache unten implementiert dieselben drei Teile mit unterschiedlichen Namen. Im Transport-Abschnitt liegt der Proxy in allen fünf Fällen.


Go: Proxy-Einrichtung, Bibliotheken und die zu vermeidende Falle

Stack: net/http mit einem eigenen http.Transport zum Abrufen, goquery oder colly für einen vollständigen Crawler zum Parsing, chromedp, wenn eine Seite JavaScript benötigt.

proxyURL, _ := url.Parse("http://USER:[email protected]:823")
client := &http.Client{
    Transport: &http.Transport{Proxy: http.ProxyURL(proxyURL)},
    Timeout:   30 * time.Second,
}
resp, err := client.Get("https://example.com")

Kein Standard-Timeout. Ein http.Client ohne Timeout wartet unbegrenzt. Ein hängender Host blockiert einen Worker-Pool, der in jeder dir verfügbaren Metrik gesund aussieht.

Nicht geschlossene Bodys. Jeder Response-Body muss geschlossen werden, sonst kehrt die Verbindung nie in den Pool zurück und der Durchsatz bricht nach einigen Tausend Anfragen unbemerkt ein.

colly übernimmt die Crawler-Anforderungen für dich: Es hat einen Proxy-Switcher für die Rotation, Rate Limits pro Domain und eine integrierte Queue. Greife daher darauf zurück, bevor du deinen eigenen Scheduler schreibst.

Nutze Go, wenn Go bereits dein Stack ist, du hohe Gleichzeitigkeit mit vorhersehbarem Speicherbedarf brauchst und auf der Crawler-Maschine eine einzelne statische Binärdatei willst. Vermeide es, wenn das Ziel für die meisten Seiten einen echten Browser benötigt, denn die Python- und Node-Ökosysteme haben dafür ausgereiftere Tools.


Kotlin: Proxy-Einrichtung, Bibliotheken und die zu vermeidende Falle

Stack: OkHttp oder Ktor Client, wenn du für das Abrufen bereits Ktor nutzt, jsoup zum Parsing, Playwright oder Selenium auf der JVM, wenn Rendering erforderlich ist.

val proxy = Proxy(Proxy.Type.HTTP, InetSocketAddress("gw.dataimpulse.com", 823))
val client = OkHttpClient.Builder()
    .proxy(proxy)
    .proxyAuthenticator { _, response ->
        response.request.newBuilder()
            .header("Proxy-Authorization", Credentials.basic("USER", "PASS"))
            .build()
    }
    .callTimeout(Duration.ofSeconds(30))
    .build()

Authenticator läuft bei einem falschen Passwort endlos in einer Schleife. OkHttp versucht den Authenticator erneut, bis es aufgibt. Gib nach dem ersten fehlgeschlagenen Versuch null zurück, sonst wird ein falsches Credential zum Anfragesturm.

Ein Client, viele Sessions. OkHttp teilt seinen Verbindungspool und Cookie-Speicher zwischen Aufrufen. Erstelle für eine Identität pro Session einen Client pro Session oder installiere einen Cookie-Speicher, den du kontrollierst.

Die JDK-Tunneling-Regel, die Java betrifft, gilt auch hier, falls du auf den JDK-Client zurückfällst: Basic-Proxy-Authentifizierung über HTTPS erfordert, dass die Eigenschaft für deaktivierte Schemes gelöscht wird. Der eigene Authenticator von OkHttp umgeht das.

Nutze Kotlin, wenn du auf der JVM bist und Coroutines sowie eine moderne API ohne den Ballast von Java möchtest. Vermeide es, wenn das Team keine JVM-Erfahrung hat, da die Bereitstellung den Code überwiegt.


Scala: Proxy-Einrichtung, Bibliotheken und die zu vermeidende Falle

Stack: sttp mit dem Backend deiner Wahl zum Abrufen, jsoup aus Scala oder scala-scraper zum Parsing, Playwright auf der JVM, falls Seiten clientseitig rendern.

import sttp.client3._

val backend = HttpClientSyncBackend(
  options = SttpBackendOptions.httpProxy(
    "gw.dataimpulse.com", 823, "USER", "PASS")
)

val response = basicRequest
  .get(uri"https://example.com")
  .readTimeout(30.seconds)
  .send(backend)

Das Backend entscheidet alles. sttp ist eine Schnittstelle; Proxy-Unterstützung, Timeouts und Streaming stammen vom Backend, das du auswählst. Lies die Dokumentation dieses Backends statt die von sttp, wenn sich etwas seltsam verhält.

JDK-Tunneling erneut. Wenn das Backend den JDK-Client umschließt, ist Basic-Proxy-Authentifizierung über HTTPS standardmäßig deaktiviert und erfordert, dass die Eigenschaft jdk.http.auth.tunneling.disabledSchemes gelöscht wird.

scala-scraper umschließt jsoup mit einer Scala-API und lohnt sich, wenn dein Parsing mehr als eine Handvoll Selektoren umfasst.

Nutze Scala, wenn der Crawler eine bereits in Scala geschriebene Spark- oder Streaming-Pipeline speist und Backpressure wichtig ist. Vermeide es, wenn die Aufgabe ein einfaches Abruf-und-Parsing ohne nachgelagerte Pipeline ist.


Perl: Proxy-Einrichtung, Bibliotheken und die zu vermeidende Falle

Stack: LWP::UserAgent oder Mojo::UserAgent für eine moderne API zum Abrufen, HTML::TreeBuilder oder Mojo::DOM zum Parsing, nichts im Prozess; rufe ein externes Tool auf, wenn Rendering benötigt wird.

use LWP::UserAgent;
my $ua = LWP::UserAgent->new(timeout => 30);
$ua->proxy(['http','https'] => 'http://USER:[email protected]:823');
my $res = $ua->get('https://example.com');
die $res->status_line unless $res->is_success;

# Mojo equivalent
my $mojo = Mojo::UserAgent->new;
$mojo->proxy->http('http://USER:[email protected]:823')
           ->https('http://USER:[email protected]:823');

HTTPS über einen Proxy benötigt die richtigen Module. LWP braucht LWP::Protocol::https und ein funktionierendes IO::Socket::SSL. Außerdem berücksichtigt es die Umgebungsvariable HTTPS_PROXY, die deine im Code gesetzte Einstellung stillschweigend überschreibt.

Umgebungsvariablen gewinnen unauffällig. env_proxy übernimmt Systemeinstellungen, die du vergessen hast. Setze Proxys ausdrücklich und leere bei geplanten Jobs die Umgebung, damit eine Einstellung auf Host-Ebene deinen Traffic nicht umleiten kann.

Mojo::UserAgent bietet dir nicht blockierende Anfragen und eine jQuery-ähnliche DOM-API in einer Abhängigkeit, was ihn zum besseren Ausgangspunkt für neue Perl-Scraper macht.

Nutze Perl, wenn Perl die Sprache des umgebenden Systems ist, typischerweise bei langlebigen Ops- und Daten-Tools. Vermeide es, wenn du ohne Perl im Stack neu startest.


Elixir: Proxy-Einrichtung, Bibliotheken und die zu vermeidende Falle

Stack: Req auf Finch zum Abrufen, Floki zum Parsing, Wallaby oder ein externer Browser-Service, wenn Rendering erforderlich ist.

Req.get!("https://example.com",
  connect_options: [
    proxy: {:http, "gw.dataimpulse.com", 823, []},
    proxy_headers: [
      {"proxy-authorization",
       "Basic " <> Base.encode64("USER:PASS")}
    ]
  ],
  receive_timeout: 30_000
)
|> Map.get(:body)
|> Floki.parse_document!()

Proxy-Optionen gehören zum Adapter. Req reicht connect_options an Finch und Mint weiter. Wenn du einen älteren HTTPoison- oder hackney-Stack nutzt, hat die Option eine andere Form, weshalb kopierte Snippets oft stillschweigend fehlschlagen.

Ein Prozess pro URL ist kein Plan. Ein Task pro Link zu starten, startet jede Anfrage sofort. Task.async_stream mit max_concurrency, pro Host bemessen, ist die idiomatische Begrenzung.

Floki mit CSS-Selektoren hält das Parsing deklarativ, und die integrierte Wiederholungs- und Redirect-Behandlung von Req entfernt den Großteil des Boilerplates, den Menschen von Hand schreiben.

Nutze Elixir, wenn der Crawler in einem bestehenden Elixir- oder Phoenix-System läuft und du Supervision sowie Gleichzeitigkeit kostenlos möchtest. Vermeide es, wenn du eine Browser-lastige Pipeline benötigst, denn das Ökosystem ist dünner als bei Node oder Python.


Welche Sprache solltest du tatsächlich nutzen?

Der entscheidende Faktor ist Wartung statt Fähigkeit. Ein Crawler in der Sprache, die dein Team täglich schreibt, übersteht die nächste Markup-Änderung; ein cleverer Crawler in einer unbekannten Sprache wird beim ersten Bruch aufgegeben.

Sprache Beste Eignung Schwächster Punkt
Go Hohe Gleichzeitigkeit mit vorhersehbarem Speicherbedarf, einzelne statische Binärdatei Tools für Browser-Rendering sind dünner als bei Python oder Node
Kotlin JVM-Teams, die Coroutines und eine moderne API möchten Gewichtige Bereitstellung für einen kleinen Job
Scala Crawler, die Spark- oder Streaming-Pipelines speisen Backend-abhängiges Verhalten und aufwendige Einrichtung
Perl Bestehende Ops- und Daten-Tools bereits in Perl Kein praktikabler Browser im Prozess
Elixir Phoenix-Systeme, die Supervision und Gleichzeitigkeit kostenlos möchten Dünnes Ökosystem für Browser-Automatisierung

Falls deine Sprache hier nicht dabei ist, gilt dieselbe Regel aus drei Teilen: Unsere separaten Leitfäden behandeln Java, C#, PHP, R, C++, VBA und Excel und JavaScript.


Was ist überall gleich, und wo liegen die Grenzen?

Drei Dinge ändern sich nicht mit der Sprache. Sessions verwalten Exits, daher behält ein Weg über Seiten hinweg für seine gesamte Dauer eine feste Adresse: Die Regeln stehen in Best Practices für Proxy-Rotation. Eine Ablehnung ist eine Entscheidung zur Diagnose statt zur Wiederholung, die unser Leitfaden zu 403 Forbidden beim Scraping der Reihe nach erläutert. Und ein Proxy ändert nur die Exit-Adresse: Er führt kein JavaScript aus, repariert keinen inkonsistenten Client und macht eine aggressive Rate nicht akzeptabel.

Zu den Regeln: Beachte robots.txt und die Website-Bedingungen, bevorzuge offizielle APIs, bleibe bei allem hinter einem Login außen vor und behandle personenbezogene Daten als Frage der Rechtsgrundlage statt des Parsings. Wir behandeln weder CAPTCHA-Lösung noch das Umgehen von Zugangskontrollen. Allgemeine Informationen, keine Rechtsberatung: siehe ist Web Scraping legal.


Häufig gestellte Fragen

Wie setze ich einen Proxy in Go?

Parse die Proxy-URL mit Credentials, setze http.ProxyURL auf einen http.Transport und gib dem http.Client ein explizites Timeout, da er standardmäßig keines hat. Verwende diesen Client wieder, damit Verbindungspool und jede Sticky Session erhalten bleiben.

Warum läuft mein Kotlin-OkHttp-Proxy-Authenticator in einer Schleife?

Weil OkHttp den Authenticator weiter aufruft, bis es erfolgreich ist oder aufgibt. Gib nach dem ersten fehlgeschlagenen Versuch null zurück, damit ein falsches Credential schnell fehlschlägt, statt zu einem Anfragesturm gegen das Gateway zu werden.

Warum schlägt Basic-Proxy-Authentifizierung über HTTPS auf der JVM fehl?

Das JDK deaktiviert Basic-Authentifizierung auf CONNECT-Tunneln standardmäßig, daher funktioniert ein authentifizierter Proxy für HTTP und schlägt für HTTPS fehl. Lösche die Eigenschaft jdk.http.auth.tunneling.disabledSchemes oder nutze einen Client wie OkHttp, der den Header Proxy-Authorization selbst sendet.

Warum ignoriert mein Perl-Skript den gesetzten Proxy?

LWP berücksichtigt die Umgebungsvariablen HTTPS_PROXY und HTTP_PROXY, und env_proxy übernimmt Einstellungen auf Host-Ebene, von denen du möglicherweise nichts weißt. Setze Proxys im Code ausdrücklich und leere bei geplanten Jobs die Umgebung, damit eine Maschineneinstellung deinen Traffic nicht umleiten kann.

Wohin gehören Proxy-Optionen in Elixir?

Zum Adapter statt zu Req selbst: connect_options werden an Finch und Mint weitergereicht, weshalb Snippets für ältere hackney-basierte Stacks stillschweigend nichts tun. Passe die Optionsform an den Adapter an, den du tatsächlich verwendest.


Ein Credential, jede Sprache oben

Jedes Snippet auf dieser Seite funktioniert mit einem DataImpulse-Gateway-Credential: Residential Exits zu $1 pro GB in 195 Ländern, rotierende oder Sticky Sessions, HTTP, HTTPS und SOCKS5, inklusive Länder-Targeting. Erstelle ein Konto und teste ein Ziel mit deinem eigenen Client, bevor du skalierst.

Verwandt: Proxys für Web Scraping · Crawl4AI-Proxy-Einrichtung · Web-Scraping-Anwendungsfall.

Zuletzt aktualisiert: 17. September 2026.


Share article: