Comment configurer un proxy avec Guzzle

Dans le cadre de l’utilisation de Guzzle, un proxy agit comme serveur intermédiaire connectant votre application cliente au serveur Web visé. Guzzle facilite le transfert de vos requêtes vers le serveur souhaité et renvoie la réponse du serveur à votre client. De plus, les proxies permettent de contourner les restrictions basées sur l’adresse IP qui peuvent bloquer vos activités de moissonnage ou limiter l’accès à certains sites Web. Ils offrent également des avantages tels que la mise en cache des réponses des serveurs, réduisant ainsi le nombre de requêtes directes adressées au serveur cible.

Cette introduction présente les éléments essentiels à l’utilisation efficace d’un proxy avec Guzzle.

Conditions de démarrage – Comment intégrer

Avant de commencer, assurez-vous que Composer et la version 7.2.5 ou ultérieure de PHP sont installés sur votre système. Une connaissance de base du moissonnage avec PHP sera également utile pour suivre ce guide. Commencez par créer un nouveau répertoire pour votre projet et utilisez Composer pour y installer Guzzle :

composer require guzzlehttp/guzzle

Créez ensuite un fichier PHP dans le répertoire nouvellement créé et incluez l’auto-chargeur de Composer pour continuer :

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

Vous êtes maintenant prêt(e) à configurer les paramètres du proxy.

Utilisation d’un proxy avec Guzzle

Ce segment montre comment émettre une requête via Guzzle à l’aide d’un proxy, puis de l’authentifier. Dans un premier temps, sourcez les proxies en vous assurant qu’ils sont actifs et qu’ils suivent le format : :://: @:.

Instructions clés : Guzzle autorise l’utilisation de proxy par le biais d’options de requête ou d’un intergiciel. Pour des configurations de proxy simples et non modifiées, les options de requête sont adaptées. À l’inverse, l’intergiciel offre une plus grande flexibilité et un meilleur contrôle, bien qu’il nécessite une configuration initiale plus poussée.

Vous étudierez les deux approches en commençant par les options de requête, ce qui implique l’importation pour la configuration des classes Client et RequestOptions de Guzzle

Méthode A : mettre en place un proxy Guzzle avec options de requête

Pour définir ce proxy, commencez par importer les classes Client et RequestOptions de Guzzle :

use GuzzleHttp\Client;
use GuzzleHttp\RequestOptions;

Définissez ensuite votre URL cible et un tableau associatif de tous les proxies que vous utiliserez :

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

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

L’URL cible spécifiée, lumtest, est conçue pour renvoyer l’adresse IP de tout client qui lui soumet une requête GET. Cette configuration permet à Guzzle de gérer le trafic HTTP et HTTPS, en l’acheminant via les proxies HTTP et HTTPS appropriés

Lancez ensuite une instance de client Guzzle et incorporez les proxies définis précédemment en les affectant à l’option proxy dans la configuration de Guzzle.

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

Étant donné que les serveurs proxy rencontrent souvent des difficultés avec la vérification SSL, cette configuration désactivera la vérification via l’option vérification. De plus, le paramètre de délai restreint la durée de chaque requête à un maximum de trente secondes. Après cette configuration, exécutez la requête et affichez la réponse qui en résulte.

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

À présent, votre script PHP devrait ressembler à ceci :

'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(); } ?>

Exécutez le script avec la commande php.php et vous obtiendrez un résultat similaire à l’exemple ci-dessous :

{"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"}}

Parfait ! La valeur de la clé IP correspond à l’adresse IP du client qui initie la requête à lumtest. Dans ce cas, elle devrait correspondre aux proxies que vous avez configurés.

Approche B : utilisation d’un intergiciel

L’utilisation d’un intergiciel pour configurer un proxy HTTP Guzzle suit un processus similaire à la première méthode. La seule différence réside dans la création et l’intégration d’un intergiciel proxy dans la pile de gestionnaires par défaut.

Pour commencer, ajustez votre importation de la manière suivante :

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

Ensuite, établissez un intergiciel proxy en insérant le code suivant (immédiatement après votre tableau $proxies). Cet intergiciel interceptera chaque requête et configurera les proxies en conséquence.

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

Maintenant, intégrez l’intergiciel dans la pile de gestionnaires par défaut et actualisez votre client Guzzle en incorporant la pile :

$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
]);

Votre script PHP devrait ressembler à ceci :

<?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();
}

?>

Exécutez le script PHP une fois de plus et vous obtiendrez des résultats similaires à ceux de l’autre méthode.

La mise en œuvre d’un proxy rotatif avec Guzzle suppose l’utilisation d’un serveur proxy qui change fréquemment d’adresse IP. Cette approche permet de contourner le blocage des adresses IP puisque chaque requête provient d’une adresse IP distincte, ce qui rend plus difficile l’identification des bots provenant d’une source unique.

Commencez maintenant par implémenter un proxy rotatif avec Guzzle, une opération relativement facile lorsque vous utilisez les services proxy de Bright Data, par exemple :

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

Maintenant, ajoutez la fonction souhaitée et appelez-la :

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;

Voici le script PHP complet :

<?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;

En conclusion

Vous avez découvert dans ce guide les étapes nécessaires pour intégrer des proxies à Guzzle. Voici ce que vous avez appris :

• Les principes fondamentaux de l’utilisation d’un proxy dans le cadre de Guzzle.
• Les stratégies de mise en œuvre d’un système de proxy rotatif.

Bright Data propose un service de proxy rotatif fiable, accessible via des appels d’API, ainsi que des fonctionnalités sophistiquées conçues pour contourner les mesures anti-bots, ce qui améliore l’efficacité de vos activités de moissonnage.