Comment faire tourner les proxys résidentiels IPRoyal avec Playwright sous Linux pour le scraping web

Aperçu

Playwright est un framework d'automatisation de navigateur qui peut piloter Chromium, Firefox et WebKit. Pour le scraping web, l'automatisation de navigateur est utile lorsqu'un site cible dépend de JavaScript, des cookies ou du rendu dynamique. Les proxys résidentiels IPRoyal vous fournissent des IP rotatives à partir d'un large pool, et IPRoyal propose également des proxys datacenter et ISP pour différents compromis. Ce tutoriel montre comment connecter Playwright sous Linux aux proxys résidentiels IPRoyal via HTTP ou SOCKS5, faire tourner les sessions, utiliser des sessions sticky, appliquer le géociblage et vérifier l'IP de sortie. Il est destiné à un travail avancé d'automatisation de navigateur où vous comprenez déjà Python, le code asynchrone et l'authentification proxy de base.

Prérequis

• Une machine Linux ou un serveur Linux avec un environnement de bureau ou headless.
• Python 3.10 ou version ultérieure.
• Un compte IPRoyal avec des identifiants de proxy résidentiel depuis le tableau de bord IPRoyal.
• L'hôte, le port, le nom d'utilisateur et le mot de passe de votre endpoint proxy IPRoyal.
• Une familiarité de base avec Python, async/await et Playwright.
• L'autorisation de scraper le site cible, et un examen de ses conditions et de son robots.txt.

Comment Playwright utilise les proxys IPRoyal

Playwright peut envoyer le trafic via un proxy au niveau du lancement du navigateur ou au niveau du contexte de navigateur. Les proxys résidentiels IPRoyal utilisent une authentification nom d'utilisateur/mot de passe. Les paramètres exacts d'hôte, de port et de nom d'utilisateur proviennent de votre tableau de bord IPRoyal.

Utilisez le tableau suivant pour choisir la valeur server dans Playwright :

IPRoyal liste HTTP, SOCKS5 et Shadowsocks parmi ses protocoles pris en charge, vous pouvez donc combiner l'automatisation de navigateur avec d'autres outils plus tard.

Étapes

1. Installer Playwright et Chromium sous Linux

Créez un environnement Python isolé et installez Playwright avec Chromium.

python3 -m venv .venv
source .venv/bin/activate
pip install --upgrade pip
pip install playwright python-dotenv
python -m playwright install --with-deps chromium

L'option --with-deps installe les bibliothèques système dont Chromium a besoin sur Debian et Ubuntu. Sur d'autres distributions, installez les dépendances Chromium équivalentes ou utilisez l'image Docker Playwright.

2. Stocker les identifiants proxy IPRoyal en toute sécurité

Créez un fichier .env dans le répertoire de votre projet. Ne le committez pas dans le contrôle de version.

IPROYAL_PROXY_HOST=your-iproyal-host
IPROYAL_PROXY_PORT=your-iproyal-port
IPROYAL_PROXY_USER=your-iproyal-username
IPROYAL_PROXY_PASS=your-iproyal-password
IPROYAL_PROXY_SCHEME=http

Utilisez les valeurs exactes de votre tableau de bord IPRoyal. Définissez IPROYAL_PROXY_SCHEME sur http pour les endpoints HTTP/HTTPS ou socks5 pour les endpoints SOCKS5.

3. Créer un assistant proxy réutilisable

Créez proxy_config.py. Cet assistant lit vos identifiants et construit le dictionnaire attendu par Playwright.

import os
from dataclasses import dataclass
from dotenv import load_dotenv

load_dotenv()

@dataclass(frozen=True)
class ProxyConfig:
    server: str
    username: str
    password: str

def iproyal_proxy(
    session_id: str | None = None,
    country: str | None = None,
) -> ProxyConfig:
    '''
    Construit un dictionnaire proxy Playwright pour IPRoyal.

    La syntaxe de session et de pays doit correspondre à votre tableau de bord IPRoyal.
    Les exemples ci-dessous ne montrent que des modèles courants. Remplacez les f-strings
    par le format exact fourni par IPRoyal.
    '''
    host = os.environ['IPROYAL_PROXY_HOST']
    port = os.environ['IPROYAL_PROXY_PORT']
    scheme = os.environ.get('IPROYAL_PROXY_SCHEME', 'http')
    username = os.environ['IPROYAL_PROXY_USER']
    password = os.environ['IPROYAL_PROXY_PASS']

    if country:
        # Exemple de modèle uniquement. Vérifiez votre tableau de bord IPRoyal pour la syntaxe exacte.
        username = f'{username}-country-{country}'
    if session_id:
        # Exemple de modèle uniquement. Les sessions sticky attachent généralement un jeton de session.
        username = f'{username}-session-{session_id}'

    return ProxyConfig(
        server=f'{scheme}://{host}:{port}',
        username=username,
        password=password,
    )

Si votre nom d'utilisateur IPRoyal contient déjà des paramètres de ciblage, ne les dupliquez pas. Utilisez le format indiqué dans le tableau de bord et adaptez l'assistant.

4. Lancer Playwright avec un proxy IPRoyal rotatif

Créez browser_check.py. Lancez Chromium avec le proxy et vérifiez l'IP de sortie.

import asyncio
from playwright.async_api import async_playwright
from proxy_config import iproyal_proxy

async def main() -> None:
    proxy = iproyal_proxy()
    async with async_playwright() as p:
        browser = await p.chromium.launch(
            headless=True,
            proxy={
                'server': proxy.server,
                'username': proxy.username,
                'password': proxy.password,
            },
        )
        context = await browser.new_context()
        page = await context.new_page()
        await page.goto('https://httpbin.org/ip', wait_until='domcontentloaded')
        print(await page.locator('body').inner_text())
        await browser.close()

if __name__ == '__main__':
    asyncio.run(main())

Exécutez-le avec :

python browser_check.py

Si la réponse JSON affiche une IP qui n'est pas la vôtre, le proxy fonctionne. Si vous omettez un ID de session, un endpoint résidentiel rotatif devrait retourner différentes IP à travers de nouvelles requêtes ou de nouvelles sessions.

5. Ajouter des sessions sticky pour les flux multi-étapes

Certains workflows, comme remplir un panier ou compléter un formulaire multi-étapes, nécessitent la même IP de sortie pour plusieurs requêtes. Utilisez un jeton de session sticky depuis votre tableau de bord IPRoyal.

async def sticky_session_example() -> None:
    proxy = iproyal_proxy(session_id='checkout-001')
    async with async_playwright() as p:
        browser = await p.chromium.launch(
            headless=True,
            proxy={
                'server': proxy.server,
                'username': proxy.username,
                'password': proxy.password,
            },
        )
        context = await browser.new_context()
        page = await context.new_page()
        await page.goto('https://httpbin.org/ip', wait_until='domcontentloaded')
        print(await page.locator('body').inner_text())
        await browser.close()

Conservez le même session_id pour tout le workflow. Utilisez un nouvel ID de session lorsque vous voulez une nouvelle IP de sortie. La durée de vie et la disponibilité des sessions sticky dépendent de votre offre IPRoyal et des paramètres de votre tableau de bord.

6. Appliquer le ciblage par pays et par ville

Le ciblage par pays est généralement transmis via le nom d'utilisateur du proxy. Utilisez le code pays et le format de paramètre exacts de votre tableau de bord IPRoyal.

proxy = iproyal_proxy(country='us')

Si IPRoyal propose un ciblage au niveau de la ville pour votre offre, ajoutez-le au même endroit que le paramètre de pays. Ne devinez pas le format ; copiez-le depuis le tableau de bord. Vérifiez le résultat en contrôlant l'IP de sortie avec un service de géolocalisation IP.

7. Effectuer la rotation sur des contextes de navigateur concurrents

Pour le scraping parallèle, réutilisez une instance de navigateur et créez un nouveau contexte par configuration de proxy. C'est plus léger que de lancer un nouveau navigateur à chaque requête.

import asyncio
from playwright.async_api import async_playwright
from proxy_config import iproyal_proxy

async def scrape_with_contexts(urls: list[str]) -> list[str]:
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)

        async def one(url: str, idx: int) -> str:
            proxy = iproyal_proxy(session_id=f'job-{idx}')
            context = await browser.new_context(
                proxy={
                    'server': proxy.server,
                    'username': proxy.username,
                    'password': proxy.password,
                }
            )
            page = await context.new_page()
            await page.goto(url, wait_until='domcontentloaded', timeout=60000)
            title = await page.title()
            await context.close()
            return title

        results = await asyncio.gather(*(one(url, i) for i, url in enumerate(urls)))
        await browser.close()
        return results

Commencez avec une faible concurrence, surveillez les taux de blocage et augmentez progressivement. Trop de sessions parallèles vers la même cible peuvent déclencher une limitation de débit même lorsque vous faites tourner les IP.

8. Vérifier l'IP de sortie avant chaque tâche importante

Ajoutez une petite étape de vérification à votre scraper. Vérifiez l'IP de sortie au début d'une tâche et comparez-la au pays ou au comportement de session attendu.

async def verify_exit_ip(page) -> str:
    await page.goto('https://httpbin.org/ip', wait_until='domcontentloaded')
    body = await page.locator('body').inner_text()
    print(body)
    return body

Si l'IP est incorrecte, corrigez le nom d'utilisateur du proxy ou les paramètres de session avant de lancer l'exploration complète.

Dépannage

Une vérification rapide en ligne de commande peut isoler les problèmes de proxy des problèmes Playwright :

curl -x 'http://USERNAME:PASSWORD@HOST:PORT' https://httpbin.org/ip

Si le mot de passe contient des caractères spéciaux, encodez-le en URL ou utilisez l'option --proxy-user de curl.

Résumé

Vous pouvez utiliser les proxys résidentiels IPRoyal avec Playwright sous Linux en stockant les identifiants dans .env, en créant un assistant proxy réutilisable, en lançant Chromium ou un contexte de navigateur avec le dictionnaire proxy, et en faisant tourner les sessions ou en utilisant des sessions sticky selon vos besoins. Utilisez HTTP pour la simplicité, SOCKS5 quand vous en avez besoin, et un client Shadowsocks local uniquement lorsque votre workflow nécessite un tunnel de type Shadowsocks. Vérifiez l'IP de sortie avant les tâches importantes, commencez avec une faible concurrence et ajustez la rotation et le géociblage en utilisant la syntaxe exacte de votre tableau de bord IPRoyal. IPRoyal est un fournisseur suggéré pour les proxys résidentiels, datacenter et ISP, mais comparez toujours la taille du pool, les prix et la compatibilité des cibles avant de vous engager dans une stack de scraping.