Blog / How Tos
How Tos

Wie man einen Proxy mit Guzzle einrichtet

Navigieren Sie durch die Herausforderungen des Web Scraping mit Guzzle und Proxys. Stellen Sie sicher, dass PHP 7.2.5+ und Composer eingestellt sind, und integrieren Sie dann Guzzle für die Proxy-Konfiguration.
1 min read
Man with beard smiling, wearing black shirt.
Aviv Besinsky
Setting a proxy in Guzzle blog image

Im Zusammenhang mit der Verwendung von Guzzle fungiert ein Proxy als Vermittlungsserver, der Ihre Client-Anwendung mit dem gewünschten Webserver verbindet. Es erleichtert die Weiterleitung Ihrer Anfragen an den gewünschten Server und gibt die Antwort des Servers an Ihren Client zurück. Darüber hinaus helfen Proxys bei der Umgehung von IP-basierten Beschränkungen, die Web-Scraping-Aktivitäten blockieren oder den Zugriff auf bestimmte Websites einschränken können, und bieten darüber hinaus Vorteile wie das Zwischenspeichern von Serverantworten, um die Anzahl der direkten Anfragen an den Zielserver zu reduzieren.

Diese Einführung beschreibt die Grundlagen für die effektive Nutzung eines Proxys mit Guzzle.

Anforderungen für den Einstieg – Anleitung zur Integration

Bevor Sie fortfahren, stellen Sie sicher, dass Sie PHP-Version 7.2.5 oder höher und Composer auf Ihrem System installiert haben. Ein grundlegendes Verständnis von Web Scraping mit PHP ist ebenfalls von Vorteil, um diesem Leitfaden zu folgen. Erstellen Sie zunächst ein neues Verzeichnis für Ihr Projekt und verwenden Sie Composer, um Guzzle darin zu installieren:

composer require guzzlehttp/guzzle

Erstellen Sie als Nächstes eine PHP-Datei im neu eingerichteten Verzeichnis und fügen Sie den Autoloader von Composer ein, um fortzufahren:

<?php
// Load Composer's autoloader
require 'vendor/autoload.php';

Damit sind wir bereit, die Proxy-Einstellungen zu konfigurieren.

Verwendung eines Proxys mit Guzzle

Dieses Segment zeigt, wie Sie mithilfe eines Proxys eine Anfrage über Guzzle stellen und authentifizieren. Zunächst Quell-Proxys, stellen Sie sicher, dass sie aktiv sind und dem folgenden Format folgen: ://:@:.

Wichtiger Hinweis: Guzzle ermöglicht die Verwendung von Proxys entweder über Anfrageoptionen oder Middleware. Für einfache, unveränderte Proxy-Konfigurationen sind Anfrageoptionen geeignet. Umgekehrt bietet Middleware mehr Flexibilität und Kontrolle, allerdings mit mehr Anfangskonfiguration.

Wir werden uns mit beiden Ansätzen befassen, beginnend mit den Anfrageoptionen, die den Import der Klassen Client und RequestOptions von Guzzle für die Einrichtung beinhalten.

Methode A: Einrichten eines Guzzle-Proxys mit Anfrageoptionen

Um einen Proxy mit Anfrageoptionen einzurichten, importieren Sie zunächst die Client- und RequestOptions-Klassen von Guzzle:

use GuzzleHttp\Client;
use GuzzleHttp\RequestOptions;

Definieren Sie dann Ihre Ziel-URL und ein assoziatives Array aller Proxys, die Sie verwenden werden:

# make request to
$targetUrl = 'https://lumtest.com/myip.json';

# proxies
$proxies = [
    'http'  => 'http://USERNAME:[email protected]:22225',
    'https' => 'http://USERNAME:[email protected]:22225',
];

Die angegebene Ziel-URL lumtest ist so konzipiert, dass sie die IP-Adresse eines jeden Clients zurückgibt, der eine GET-Anfrage an sie stellt. Mit dieser Einrichtung kann Guzzle sowohl den HTTP- als auch den HTTPS-Traffic verwalten und ihn entsprechend über die vorgesehenen HTTP- und HTTPS-Proxys leiten.

Als Nächstes starten wir eine Guzzle-Client-Instanz, wobei wir die zuvor definierten Proxys einbeziehen, indem wir sie der Proxy-Option in der Guzzle-Konfiguration zuweisen.

$client = new Client([
RequestOptions::PROXY => $proxies,
RequestOptions::VERIFY => false, # disable SSL certificate validation
RequestOptions::TIMEOUT => 30, # timeout of 30 seconds
]);

Da bei Proxy-Servern häufig Probleme mit der SSL-Verifizierung auftreten, wird bei dieser Einrichtung die Verifizierung über die Verifizierungsoption deaktiviert. Darüber hinaus beschränkt die Timeout-Einstellung die Dauer jeder Anfrage auf maximal dreißig Sekunden. Nach dieser Konfiguration führen wir die Anfrage aus und zeigen die resultierende Antwort an.

try {
$body = $client->get($targetUrl)->getBody();
echo $body->getContents();
} catch (\Exception $e) {
echo $e->getMessage();
}

Inzwischen sollte Ihr PHP-Skript so aussehen:

'http://USERNAME:[email protected]:22225', 'https' => 'http://USERNAME:[email protected]:22225', ]; $client = new Client([ RequestOptions::PROXY => $proxies, RequestOptions::VERIFY => false, # disable SSL certificate validation RequestOptions::TIMEOUT => 30, # timeout of 30 seconds ]); try { $body = $client->get($targetUrl)->getBody(); echo $body->getContents(); } catch (\Exception $e) { echo $e->getMessage(); } ?>

Führen Sie Ihr Skript mit dem Befehl php .php aus, und Sie erhalten eine Ausgabe wie im folgenden Beispiel:

{"ip":"212.80.220.187","country":"IE","asn":{"asnum":9009,"org_name":"M247 Europe SRL"},"geo":{"city":"Dublin","region":"L","region_name":"Leinster","postal_code":"D12","latitude":53.323,"longitude":-6.3159,"tz":"Europe/Dublin","lum_city":"dublin","lum_region":"l"}}

Hervorragend! Der Wert des IP-Schlüssels entspricht der IP-Adresse des Clients, der die Anfrage an lumtest initiiert. In diesem Fall sollte es die Proxys widerspiegeln, die Sie konfiguriert haben.

Methode B: Verwendung von Middleware

Die Verwendung von Middleware zum Einrichten eines Guzzle-HTTP-Proxys folgt einem ähnlichen Muster wie bei der ersten Methode. Der einzige Unterschied besteht in der Erstellung und Integration von Proxy-Middleware in den Standard-Handler-Stack.

Passen Sie zunächst Ihren Import wie folgt an:

# ...
use Psr\Http\Message\RequestInterface;
use GuzzleHttp\HandlerStack;
# ...

Richten Sie dann eine Proxy-Middleware ein, indem Sie den folgenden Code unmittelbar nach Ihrem $proxies-Array einfügen. Diese Middleware fängt jede Anfrage ab und konfiguriert die Proxys entsprechend.

function proxy_middleware(array $proxies) 
{
    return function (callable $handler) use ($proxies) {
        return function (RequestInterface $request, array $options) use ($handler, $proxies) {
            # add proxy to request option
            $options[RequestOptions::PROXY] = $proxies; 
            return $handler($request, $options);
        };
    };
}

Jetzt können wir die Middleware in den Standard-Handler-Stack integrieren und unseren Guzzle-Client durch Einbindung des Stacks aktualisieren:

$stack = HandlerStack::create();
$stack->push(proxy_middleware($proxies));

$client = new Client([
    'handler' => $stack,
    RequestOptions::VERIFY => false, # disable SSL certificate validation
    RequestOptions::TIMEOUT => 30, # timeout of 30 seconds
]);

Ihr PHP-Skript sollte so aussehen:

<?php
require 'vendor/autoload.php';
use GuzzleHttp\Client;
use GuzzleHttp\RequestOptions;
use Psr\Http\Message\RequestInterface;
use GuzzleHttp\HandlerStack;
# make request to
$targetUrl = 'https://lumtest.com/myip.json';

# proxies
$proxies = [
    'http'  => 'http://USERNAME:[email protected]:22225',
    'https' => 'http://USERNAME:[email protected]:22225',
];
function proxy_middleware(array $proxies) 
{
    return function (callable $handler) use ($proxies) {
        return function (RequestInterface $request, array $options) use ($handler, $proxies) {
            # add proxy to request option
            $options[RequestOptions::PROXY] = $proxies; 
            return $handler($request, $options);
        };
    };
}

$stack = HandlerStack::create();
$stack->push(proxy_middleware($proxies));

$client = new Client([
    'handler' => $stack,
    RequestOptions::VERIFY => false, # disable SSL certificate validation
    RequestOptions::TIMEOUT => 30, # timeout of 30 seconds
]);

try {
    $body = $client->get($targetUrl)->getBody();
    echo $body->getContents();
} catch (\Exception $e) {
    echo $e->getMessage();
}

?>

Führen Sie das PHP-Skript erneut aus und Sie erhalten Ergebnisse, die denen der anderen Methode ähneln.

Die Implementierung eines rotierenden Proxys mit Guzzle beinhaltet die Verwendung eines Proxy-Servers, der häufig die IP-Adresse wechselt. Dieser Methode hilft bei der Umgehung der IP-Blockierung, da jede Anfrage von einer anderen IP-Adresse ausgeht, was die Identifizierung von Bots, die von einer einzigen Quelle stammen, erschwert.

Wir beginnen mit der Implementierung eines rotierenden Proxys mit Guzzle. Dies ist ziemlich einfach, wenn Sie die Proxy-Services von Bright Data verwenden, zum Beispiel:

function get_random_proxies(): array {
    // Base proxy URL before the session identifier
    $baseProxyUrl = 'http://USERNAME-session-';

   
    $sessionSuffix = rand(1000, 9999); // Random integer between 1000 and 9999
    $proxyCredentials = ':[email protected]:22225';

    $httpProxy = $baseProxyUrl . $sessionSuffix . $proxyCredentials;
    $httpsProxy = $baseProxyUrl . $sessionSuffix . $proxyCredentials;


    $proxies = [
        'http'  => $httpProxy,
        'https' => $httpsProxy,
    ];

    return $proxies;
}

Fügen Sie nun die gewünschte Funktion hinzu und rufen Sie sie auf:

function rotating_proxy_request(string $http_method, string $targetUrl, int $max_attempts = 3): string
{
    $response = null;
    $attempts = 1;

    while ($attempts <= $max_attempts) {
        $proxies = get_random_proxies();
        echo "Using proxy: ".json_encode($proxies).PHP_EOL;
        $client = new Client([
            RequestOptions::PROXY => $proxies,
            RequestOptions::VERIFY => false, # disable SSL certificate validation
            RequestOptions::TIMEOUT => 30, # timeout of 30 seconds
        ]);
        try {
            $body = $client->request(strtoupper($http_method), $targetUrl)->getBody();
            $response = $body->getContents();
            break;
        } catch (\Exception $e) {
            echo $e->getMessage().PHP_EOL;
            echo "Attempt ".$attempts." failed!".PHP_EOL;
            if ($attempts < $max_attempts) {
                echo "Retrying with a new proxy".PHP_EOL;
            }
            $attempts += 1;
        }
    }
    return $response;
}

$response = rotating_proxy_request('get', 'https://lumtest.com/myip.json');

echo $response;

Hier ist das vollständige PHP-Skript:

<?php
# composer's autoloader
require 'vendor/autoload.php';

use GuzzleHttp\Client;
use GuzzleHttp\RequestOptions;

function get_random_proxies(): array {
    // Base proxy URL before the session identifier
    $baseProxyUrl = 'http://USERNAME-session-';

    // Session ID suffix and proxy credentials
    $sessionSuffix = rand(1000, 9999); // Random integer between 1000 and 9999
    $proxyCredentials = ':[email protected]:22225';

    // Assemble the full proxy URLs with the randomized session ID
    $httpProxy = $baseProxyUrl . $sessionSuffix . $proxyCredentials;
    $httpsProxy = $baseProxyUrl . $sessionSuffix . $proxyCredentials;

    // Package and return the proxies
    $proxies = [
        'http'  => $httpProxy,
        'https' => $httpsProxy,
    ];

    return $proxies;
}


function rotating_proxy_request(string $http_method, string $targetUrl, int $max_attempts = 3): string
{
    $response = null;
    $attempts = 1;

    while ($attempts <= $max_attempts) {
        $proxies = get_random_proxies();
        echo "Using proxy: ".json_encode($proxies).PHP_EOL;
        $client = new Client([
            RequestOptions::PROXY => $proxies,
            RequestOptions::VERIFY => false, # disable SSL certificate validation
            RequestOptions::TIMEOUT => 30, # timeout of 30 seconds
        ]);
        try {
            $body = $client->request(strtoupper($http_method), $targetUrl)->getBody();
            $response = $body->getContents();
            break;
        } catch (\Exception $e) {
            echo $e->getMessage().PHP_EOL;
            echo "Attempt ".$attempts." failed!".PHP_EOL;
            if ($attempts < $max_attempts) {
                echo "Retrying with a new proxy".PHP_EOL;
            }
            $attempts += 1;
        }
    }
    return $response;
}

$response = rotating_proxy_request('get', 'https://lumtest.com/myip.json');

echo $response;

Fazit

In diesem Leitfaden haben wir die notwendigen Schritte für die Integration von Proxys in Guzzle beschrieben. Sie haben Folgendes gelernt:

  • Die Grundlagen der Verwendung eines Proxys bei der Arbeit mit Guzzle.
  • Strategien für die Implementierung eines rotierenden Proxy-Systems.

Bright Data bietet einen zuverlässigen rotierenden Proxy-Service, der über API-Aufrufe zugänglich ist, sowie ausgefeilte Funktionen, die darauf ausgelegt sind, Anti-Bot-Maßnahmen zu umgehen und die Effizienz Ihrer Scraping-Bemühungen zu steigern.

Gratis testen

Starte mit Google

Keine Kreditkarte erforderlich

Table of Contents

    Das könnte Sie auch interessieren

    Setting Proxy in GO
    How Tos
    White number one with a flame on top.
    Rexford A. Nyarko

    Go-Proxy-Server – Leitfaden zur Einrichtung von Proxy-Servern mit Go

    In diesem Artikel erfahren Sie, wie Sie einen Proxy-Server für das Web-Scraping mit Go einrichten.
    03-Mar-2024
    26 min read
    PHP Proxy Server How to Set Up Proxies in PHP
    How Tos
    Marshall Chikari

    PHP-Proxy-Server: So richten Sie Proxys in PHP ein

    Erfahren Sie, wie Sie einen PHP-Proxy-Server einrichten, um Web Scraping zu verbessern, Sicherheit zu gewährleisten und Geoblocking zu überwinden.
    28-Feb-2024
    3 min read
    Configuring Proxy Settings in C# Code
    How Tos
    White number one with a flame on top.
    Abnoan Muniz

    So richten Sie Proxy-Server in C# ein

    Erfahren Sie, wie Sie Proxys in C# für Web Scraping implementieren, um den Datenschutz und die Effizienz von Datenerfassungsprojekten mit Visual Studio und .NET 7 zu verbessern.
    28-Feb-2024
    17 min read