Project Oxygen & Ideo-LabIDEO LAB Dashboard 2026

đŸ•·ïž Senior Web Scraping (Architecture & Evasion)

Guide expert : Contournement WAF (Cloudflare/Akamai), Fingerprinting (TLS/Canvas), Reverse Engineering d'API, Architecture distribuée et Proxy Management.

1.1

Fundamentals & Strategy

DiffĂ©rence Junior vs Senior. Éthique, Legal (CMA/GDPR) et Analyse de cible.

Strategy Legal
1.2

Proxies & Network

Datacenter vs Residential vs 4G/5G. Rotation intelligente, Sticky IP, ASN Trust score.

Residential IP ISP
1.3

TLS & Fingerprinting

JA3/JA4 Signatures, HTTP/2 frames, cURL-impersonate, TLS Handshake mimicry.

JA3 Cypher Suites
1.4

Headless Browsers

Playwright vs Puppeteer. Patching CDP (Chrome DevTools Protocol). Stealth plugins.

Playwright CDP

Anti-Bot Evasion

Contourner Cloudflare Turnstile, Akamai, Datadome, PerimeterX. Behavioral analysis.

WAF Bypass
2.2

Reverse Engineering

Interception App Mobile (Frida, Cert pinning), APIs cachées, Protobuf/gRPC decoding.

MITM Protobuf
2.3

Captcha Solving

OCR local, AI Solvers (YOLO/CNN), API Services (2Captcha, CapSolver), Human farms.

ReCaptcha Computer Vision
2.4

Parsing & Cleaning

Robust Xpath/CSS selectors, Schema validation (Pydantic), Deduplication.

lxml JSON-LD
3.1

Scaling & Architecture

Scraping distribué (Celery/Kafka/Redis). Gestion des queues, Rate limiting global.

Scrapy Cluster Redis
3.2

DevOps for Scrapers

Monitoring (Grafana/Prometheus), Logging, CI/CD, Containerisation, Ban management.

Observability
3.3

Toolbox & Languages

Python (Scrapy) vs Node (Puppeteer) vs Go (Colly/Rod). Outils GUI.

Stack
4.0

Cheatsheet

Commandes cURL, Snippets Python, Headers essentiels, Liste de User-Agents.

Memo
1.1 Fundamentals – The Senior Scraper Maturity Model
L'Échelle de CompĂ©tence (The Scraping Ladder)
  • Level 1 (Script Kiddie) :
    • Stack : Python requests, BeautifulSoup.
    • Limite : BloquĂ© instantanĂ©ment par Cloudflare/Akamai (403). Ne gĂšre pas le JS.
    • DĂ©tection : User-Agent par dĂ©faut, pas de cookies, IP datacenter.
  • Level 2 (Browser User) :
    • Stack : Selenium, Puppeteer (Vanilla).
    • Limite : Lent, gourmand en RAM. DĂ©tectĂ© par navigator.webdriver = true.
    • Avantage : Rend le JS, passe les sites basiques.
  • Level 3 (Browser Expert) :
    • Stack : Playwright + Stealth Plugins + CDP Patching.
    • Technique : Masquage des fingerprints (Canvas, WebGL, Fonts).
    • Infra : Rotation de proxies rĂ©sidentiels basique.
  • Level 4 (Protocol Engineer) :
    • Stack : TLS Spoofing (cURL-impersonate, Go, Rust).
    • Technique : Imite le handshake TLS et l'ordre des frames HTTP/2 de Chrome au bit prĂšs.
    • Avantage : Performance extrĂȘme (pas de GUI), passe les WAFs silencieusement.
  • Level 5 (Architect) :
    • Stack : DistribuĂ© (Kafka/Redis), Reverse Engineering d'APIs Mobiles (gRPC/Protobuf), AI Solvers.
    • Vision : CapacitĂ© Ă  extraire 100M+ pages/jour sans trigger les alarmes.
Le Paradigme "Senior"

Un senior ne cherche pas à "contourner" un blocage, il cherche à se fondre dans la masse. L'objectif est l'indiscernabilité statistique entre votre bot et un utilisateur humain légitime sur une connexion résidentielle (FAI).

// RÚgle d'Or : "Don't break the door, find the key." // PlutÎt que de parser du HTML lourd et changeant, le senior passera 4h à reverser // l'API privée de l'application mobile Android pour obtenir du JSON propre et stable.
Identifier l'Adversaire (WAF Fingerprinting)

Avant d'écrire une ligne de code, inspectez les Headers HTTP et les Cookies de la cible.

WAF / Bot ProtectionIndicateurs (Headers/Cookies)Difficulté
CloudflareHeader server: cloudflare, cf-ray. Cookie __cf_bm.Moyen (TLS Spoofing requis)
AkamaiHeader server: AkamaiGHost. Cookie _abck, bm_sz. Sensor data payload.Difficile (Behavioral analysis)
DatadomeCookie datadome. Réponse 403 avec Captcha spécifique.TrÚs Difficile (AI detection)
PerimeterX (Human)Script _px.js, Cookie _px3.Moyen
Shape (F5)Headers commençant par X-. Obfuscation JS lourde.ExtrĂȘme (Target Banking/Airline)
Surface d'Attaque (Data Sources)
  • API CachĂ©es : Filtrer DevTools par XHR ou Fetch. Rechercher des endpoints /api/v1, /graphql.
  • SSR Data (Hydration) : Sur les sites Next.js/Nuxt, chercher la balise <script id="__NEXT_DATA__" type="application/json">. Elle contient tout l'Ă©tat de la page en JSON pur (plus besoin de parser le HTML !).
  • Mobile App Endpoints : Installer l'app, configurer un Proxy MITM (Charles/HTTP Toolkit) + SSL Pinning Bypass (Frida). Les APIs mobiles sont souvent moins protĂ©gĂ©es que le Web (pas de Captcha, rate limit plus souple).
  • Sitemaps & Feeds : Toujours vĂ©rifier /sitemap.xml ou /robots.txt pour dĂ©couvrir l'arborescence complĂšte sans crawler.
L'Économie du Scraping (ROI)

Le scraping coûte cher. Il faut optimiser le coût par page réussie (Cost Per Success - CPS).

RessourceCoût Est.Impact
Dev Time$$$$Maintenance des sélecteurs et bypass WAF constants.
Proxies DC$Pas cher, mais taux d'échec élevé sur cibles premium.
Proxies Resi$$$~$10/GB. À utiliser uniquement pour les requĂȘtes finales (HTML). Ne jamais tĂ©lĂ©charger d'images via Resi !
Captcha Solving$$~$0.5 - $2 / 1000 résolutions. Peut vite exploser.
Stratégie d'Optimisation des Coûts
  • Bandwidth Saving : Bloquer le chargement des images, fonts, CSS et trackers publicitaires dans le navigateur Headless (page.route('**/*.{png,jpg,woff}', route => route.abort())).
  • Tiered Proxying :
    • Tenter d'abord avec une IP Datacenter (Cheap).
    • Si Ă©chec (403/Captcha), retry avec IP RĂ©sidentielle (Premium).
  • Headless vs HTTP : Une requĂȘte HTTP (TLS spoofed) coĂ»te 100x moins de CPU/RAM qu'une instance Chrome Headless. Toujours privilĂ©gier le protocole pur.
1.3 TLS & Browser Fingerprinting – The Invisible Identity
Le Handshake TLS (Client Hello)

Avant mĂȘme d'envoyer un header HTTP, votre client nĂ©gocie le chiffrement. Les WAFs (Cloudflare, Akamai) analysent ce paquet binaire pour identifier le client.

  • JA3 Hash : ConcatĂ©nation hachĂ©e de : SSLVersion,Ciphers,Extensions,EllipticCurves,EllipticCurvePointFormats.
  • Le piĂšge Python : requests utilise OpenSSL par dĂ©faut. Chrome utilise BoringSSL. Leurs listes de Ciphers et l'ordre des Extensions sont radicalement diffĂ©rents.
  • JA4 : Nouvelle norme plus granulaire qui inclut le protocole (QUIC/TCP) et le ALPN.
Analyse Différentielle
# Signature "Requests" (Python) Ciphers: [AES256-GCM-SHA384, AES128-GCM-SHA256, ...] (Ordre OpenSSL) Extensions: [renegotiation_info, ...] (Manque les extensions GREASE) # Signature "Chrome" (Réelle) Ciphers: [GREASE, AES128-GCM-SHA256, AES256-GCM-SHA384, ChaCha20...] Extensions: [GREASE, padding, session_ticket, ...] (Ordre spécifique)

Si vous envoyez un User-Agent "Chrome" avec un TLS "Python", c'est un flag immédiat (403 Forbidden).

HTTP/2 Frames Analysis (Akamai)

Contrairement à HTTP/1.1 (texte), HTTP/2 est binaire. L'implémentation du protocole trahit la librairie sous-jacente.

VecteurDétail Technique
SETTINGS FrameChrome envoie des paramÚtres spécifiques (`HEADER_TABLE_SIZE`, `MAX_CONCURRENT_STREAMS`). Golang/Node en envoient d'autres.
WINDOW_UPDATELa taille de fenĂȘtre initiale et les incrĂ©ments sont uniques Ă  chaque navigateur.
Pseudo-HeadersL'ordre est strict : :method, :authority, :scheme, :path (m,a,s,p). Modifier cet ordre = Bot.
Passive Fingerprinting
  • Les WAFs Ă©coutent passivement.
  • Si votre scraper utilise `http2` en Python sans configurer finement les frames SETTINGS et PRIORITY, il sera dĂ©tectĂ© comme "nghttp2" ou "hyper", pas comme Chrome.
Canvas & WebGL
  • Canvas Fingerprint : Le navigateur dessine une image cachĂ©e. Le rendu dĂ©pend du GPU, des drivers et de l'OS.
    • Risque : Si vous utilisez Docker (Linux) et spoofez un User-Agent Windows, le rendu de police (Anti-aliasing) ne correspondra pas.
  • WebGL : `renderer` et `vendor` strings. (Ex: "Mesa Intel Graphics" vs "Apple M1").
JS Runtime Consistency

Incohérences fatales :

  • navigator.platform = "Linux x86_64" alors que UA = "Windows".
  • navigator.hardwareConcurrency incompatible avec le profil.
Picasso / CreepJS Score
// Testez votre bot sur https://abrahamjuliot.github.io/creepjs/ // Score < 100% ? -> Vous ĂȘtes dĂ©tectable. // "Lies Detected" : Playwright modifie navigator.webdriver mais oublie les prototypes.
HTTP Clients (Niveau 4)

Outils capables de modifier le handshake TLS et les frames HTTP/2 pour imiter Chrome/Safari.

  • curl-impersonate : Build custom de cURL compilĂ© avec les librairies BoringSSL de Chrome.
  • curl_cffi (Python) : Binding Python pour curl-impersonate. Le standard actuel.
  • tls-client (Go/Python) : Librairie trĂšs utilisĂ©e, basĂ©e sur utls (Go).
Code Snippet (curl_cffi)
                            from curl_cffi import requests

                            # Imitation parfaite de Chrome 110 (TLS + HTTP/2 + Headers Order)
                            r = requests.get(
                            "https://tls.peet.ws/api/all",
                            impersonate="chrome110",
                            headers={
                            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)..."
                            }
                            )
                            # Le serveur voit : JA3 de Chrome, HTTP/2 frames de Chrome.
                            print(r.json())
                        
2.1 Anti-Bot & WAF Evasion Strategies
Comment ils vous détectent ?
VecteurDétail
IP ReputationDatacenter IPs (AWS, GCP) sont flaggées. Usage de proxy résidentiel obligatoire.
Browser ConsistencyUser-Agent dit "Mac" mais `navigator.platform` dit "Win32". Incohérence = Bot.
Automation Flags`navigator.webdriver = true`. Attributs Selenium ($cdc_...).
BehavioralMouvement souris linéaire parfait. Clics instantanés (0ms). Pas de scroll.
Les "Big Boss" WAF
  • Cloudflare : Challenges JS (Turnstile), analyse TLS, IP rep.
  • Datadome : TrĂšs agressif. Analyse les Ă©vĂ©nements souris/clavier cĂŽtĂ© client + Fingerprint serveur.
  • Akamai : Analyse comportementale avancĂ©e et senseurs mobiles.
  • PerimeterX (Human) : DĂ©tection d'automatisation lourde.
Patching du Navigateur (Playwright/Puppeteer)

Par défaut, un navigateur automatisé "fuit" son identité de bot via des variables JS spécifiques.

  • Stealth Plugin : puppeteer-extra-plugin-stealth. Masque `navigator.webdriver`, mock les plugins, override les langues.
  • Arguments de lancement :
                                        args: [
                                        '--disable-blink-features=AutomationControlled',
                                        '--no-sandbox'
                                        ]
                                    
CDP (Chrome DevTools Protocol)

Utiliser CDP pour modifier le navigateur Ă  un niveau bas.

                            # Playwright (Python) : Changer le User-Agent et la Géoloc au niveau CDP
                            context = browser.new_context(
                            user_agent='Mozilla/5.0 ...',
                            locale='fr-FR',
                            timezone_id='Europe/Paris'
                            )
                            await context.add_init_script("Object.defineProperty(navigator, 'webdriver', {get: () => undefined})")
                        
2.2 Reverse Engineering (APIs & Mobile)
Hidden APIs discovery

Le Web Scraping moderne n'est pas parser du HTML, c'est taper les APIs JSON non documentées.

  • Intercept XHR/Fetch : Utiliser l'onglet Network. Filtrer par "XHR".
  • GraphQL : Chercher les endpoints `/graphql`. Introspection souvent dĂ©sactivĂ©e, mais les queries sont visibles.
  • Mobile APIs : Souvent plus lĂ©gĂšres et moins protĂ©gĂ©es que le Web.
    • Utiliser un Ă©mulateur (Android Studio / Genymotion).
    • Proxy via HTTP Toolkit ou Charles Proxy.
    • SSL Pinning Bypass : Utiliser Frida et des scripts comme `Universal Android SSL Pinning Bypass`.
Binary Data (Protobuf / gRPC)

Certains sites (Google Maps, Play Store) utilisent Protobuf pour réduire la bande passante. Illisible en brut.

# Exemple de décodage Protobuf (Blackbox) 1. Copier la réponse hexadécimale. 2. Utiliser `protoc --decode_raw` pour voir la structure. 3. Reconstruire le fichier .proto. 4. Générer le code Python correspondant.
De-obfuscation JS
  • Les sites calculent souvent des tokens de signature en JS (ex: `X-Signature`).
  • Il faut extraire l'algo JS, le nettoyer (AST de-obfuscation) et l'exĂ©cuter via un moteur JS (Node VM2) ou le réécrire en Python.
3.1 Distributed Architecture & Scaling
Pattern Producer-Consumer
  • Producer (Seeder) : Script lĂ©ger qui trouve les URLs Ă  scraper (pagination, catĂ©gories) et les pousse dans une Queue.
  • Queue (Broker) : Redis ou Kafka. Stocke les URLs, gĂšre la prioritĂ© (FIFO/LIFO), dĂ©doublonne.
  • Consumers (Workers) : N instances de scrapers (stateless). Ils prennent une URL, scrapent, et poussent la donnĂ©e.
Infrastructure
                            [ Cron Job ] --> [ Redis Queue ] --> [ Worker Pool (K8s/Docker) ]
                            |
                            v
                            [ Proxy Rotator ]
                            |
                            v
                            [ Target Website ]
                            |
                            v
                            [ Data Lake S3 ] <---- [ Validation ] <---- [ Raw HTML ]
                            
Redis as a Queue

Utilisation de Redis Sets pour la dĂ©duplication (ne pas scraper 2x la mĂȘme URL) et Redis Lists pour la queue.

  • Sadd : `visited_urls`. VĂ©rifier existence avant push.
  • Lpush/Rpop : Gestion de la file d'attente.
  • Scrapy-Redis : Librairie standard pour connecter Scrapy Ă  Redis directement.
Proxy Rotation Architecture
  • Ne jamais gĂ©rer la rotation dans le code du scraper si possible.
  • Utiliser un Proxy Gateway (ex: ProxyRack, Smartproxy endpoint) ou un middleware local (ProxyChains, HAProxy) qui round-robin sur une liste.
  • Sticky Session : Garder la mĂȘme IP pour une session de login, changer d'IP pour le scraping de catalogue public.
4.0 Senior Scraper Cheatsheet
Common Headers (To mimic real browser)
                        {
                        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) ...",
                        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9...",
                        "Accept-Language": "en-US,en;q=0.9",
                        "Accept-Encoding": "gzip, deflate, br",
                        "Connection": "keep-alive",
                        "Upgrade-Insecure-Requests": "1",
                        "Sec-Fetch-Dest": "document",
                        "Sec-Fetch-Mode": "navigate",
                        "Sec-Fetch-Site": "none",
                        "Sec-Fetch-User": "?1"
                        }
                    

Note : L'ordre des headers est important pour certains WAF (Akamai).

Useful Snippets
                        # Xpath : Sélectionner texte excluant enfants
                        //div[@class='content']/text()

                        # Xpath : Contient classe
                        //div[contains(@class, 'product')]

                        # Pandas : Nettoyage rapide
                        df.drop_duplicates(subset=['id'], keep='last')
                        df['price'] = df['price'].replace('[$,]', '', regex=True).astype(float)

                        # Docker : Lancer un headless chrome
                        docker run -d -p 9222:9222 --cap-add=SYS_ADMIN zenika/alpine-chrome
                    
1.2 Network Mastery – Proxies, IP Reputation & Infrastructure
La Hiérarchie des IPs
TypePerformanceTrust ScoreUsage Idéal
Datacenter (DC)ExtrĂȘme (< 50ms)Nul (ASN AWS/GCP)Sites sans protection, APIs publiques, Mass crawling.
ISP (Static Resi)Haute (Fibre)ÉlevĂ©Le Graal. IP hĂ©bergĂ©e en DC mais annoncĂ©e comme RĂ©sidentielle (Verizon, Orange). Account Management.
Residential (P2P)Variable (Latence)MaximumContournement WAF strict. IP de vrais utilisateurs (botnets éthiques).
Mobile (4G/5G)MoyenneIntouchableCréation de comptes (Gmail/IG). CGNAT rend le ban impossible sans dommage collatéral.
IPv4 vs IPv6
  • IPv4 : Cher ($$), rare. Subnet banning frĂ©quent (si 1.2.3.4 est ban, tout le /24 risque de l'ĂȘtre).
  • IPv6 : Quasi gratuit, quantitĂ© infinie.
    • ProblĂšme : Beaucoup de cibles (sites vieux ou mal configurĂ©s) ne supportent pas l'IPv6.
    • StratĂ©gie : Utiliser IPv6 pour scraper les GAFAM (Google/FB/LinkedIn) qui le supportent nativement.
Comment les WAF jugent votre IP ?

Ce n'est pas juste "IP bannie ou non". C'est un score de fraude probabiliste.

  • ASN (Autonomous System Number) : Si ASN = "DigitalOcean" ou "Hetzner" -> Score de risque +50. Si ASN = "Comcast Cable" -> Score +0.
  • Usage Type : Bases de donnĂ©es comme MaxMind ou IP2Location classifient les IPs (DCH=Data Center, ISP=Fixed Line, MOB=Mobile).
  • Open Ports : Les WAF scannent votre IP. Ports 22/80/443/8080 ouverts ? -> C'est un proxy -> Ban.
  • Neighbor Noise : Si vos voisins de subnet ("noisy neighbors") spammennt, vous coulez avec eux.
Passive OS Fingerprinting (p0f)
// ATTENTION: Un proxy masque l'IP, mais pas la stack TCP/IP ! // Si vous sortez via un proxy Linux mais que votre User-Agent dit "Windows", // l'analyse des paquets TCP (TTL, Window Size) révélera la supercherie.
  • Solution : Utiliser des proxies SOCKS5 avec réécriture de header TCP, ou s'assurer que l'OS du scraper matche l'OS simulĂ©.
Architecture de Rotation (HAProxy)

Ne configurez jamais 1000 proxies dans votre code. Utilisez un Load Balancer local.

                            # haproxy.cfg (Rotation Round-Robin)
                            listen scraping_gateway
                            bind 127.0.0.1:8000
                            mode http
                            balance roundrobin
                            option http_proxy
                            server proxy1 1.2.3.4:8000 check
                            server proxy2 1.2.3.5:8000 check
                            ...
                        

Votre code tape uniquement localhost:8000. HAProxy gĂšre la distribution et le health-check.

Gestion des Sessions (Sticky vs Rotating)
  • Rotating (Stateless) : Chaque requĂȘte HTTP = Nouvelle IP.
      Usage : Scraper des pages produits (PDP), Search Results (SERP).
  • Sticky (Stateful) : L'IP reste la mĂȘme pour X minutes ou via un ID de session.
      Usage : Tunnel de commande, Login, Scenarios multi-étapes.
DIY 4G Proxy Farm

Construire sa propre infra mobile pour un coût dérisoire vs BrightData.

  • Hardware : Hub USB alimentĂ© + Dongles 4G Huawei (E3372) + Raspberry Pi / Mini PC.
  • SIM Cards : Forfaits Data illimitĂ©s grand public (Free Mobile, etc.).
  • Rotation : Script Python qui interagit avec l'API du dongle pour rebooter la radio (Mode avion ON/OFF) -> Nouvelle IP assignĂ©e par l'opĂ©rateur.
Avantages du CGNAT (Carrier-Grade NAT)

Sur mobile, une IP publique est partagĂ©e par des milliers d'utilisateurs simultanĂ©ment. Si Cloudflare bannit cette IP, il bloque 5000 clients lĂ©gitimes de SFR/Orange dans la mĂȘme ville. Ils ne le feront pas.

# Rotation IP via API Dongle (Exemple) import requests def rotate_dongle(ip): requests.post(f"http://{ip}/api/control/reboot") # L'IP change en 15-20 secondes.
1.4 Headless Browsers Automation
Playwright vs Puppeteer vs Selenium
  • Selenium : Legacy. Lent, dĂ©tectable facilement (WebDriver flags), synchrone. À Ă©viter pour du scraping moderne.
  • Puppeteer : Node.js uniquement. ContrĂŽle Chrome via CDP. Excellent mais limitĂ© Ă  l'Ă©cosystĂšme JS.
  • Playwright : Le standard moderne (Microsoft). Supporte Python/Node/Go. Moteur patchĂ© pour le stealth. Contextes isolĂ©s trĂšs rapides.
Anti-Detect Browsers (ADB)

Pour les cas extrĂȘmes oĂč Playwright Stealth ne suffit pas.

  • Outils comme GoLogin, Dolphin{anty}, AdsPower.
  • Ils modifient le binaire Chrome pour falsifier le Canvas, WebGL, AudioContext, Font enumeration au niveau natif.
  • Pilotables via API locale (Selenium/Puppeteer se connecte dessus via CDP).
2.3 Captcha Solving Strategies
Services de Résolution (API)
  • 2Captcha / Anti-Captcha : Fermes humaines. Lent (10-30s) mais rĂ©sout tout. CoĂ»t Ă©levĂ©.
  • CapSolver / CapMonster : RĂ©solution par IA. TrĂšs rapide (<2s), moins cher. IdĂ©al pour ReCaptcha v2/v3, hCaptcha.
  • MĂ©thode : On envoie la sitekey Ă  l'API, on reçoit un token, on l'injecte dans le HTML (textarea g-recaptcha-response) et on submit le form.
Computer Vision (Local Solving)

Pour les captchas simples (texte, sliders), inutile de payer une API.

  • OCR : Tesseract ou modĂšles CNN simples pour lire du texte dĂ©formĂ©.
  • Sliders (Puzzle) : Utiliser OpenCV pour dĂ©tecter les bords (`Canny edge detection`) et calculer l'offset de glissement.
  • YOLO : ModĂšles Object Detection pour cliquer sur "tous les feux rouges".
2.4 Data Parsing & Quality Assurance
Selectors Robustness
  • Éviter les Xpath absolus fragiles : /html/body/div[2]/div[3]/span.
  • PrivilĂ©gier les attributs data : //div[@data-testid='price'].
  • Utiliser la recherche de texte : //*[contains(text(), 'Total:')].
  • JSON-LD : Toujours vĂ©rifier si la page contient du JSON structurĂ© (Schema.org) dans une balise <script type="application/ld+json">. C'est de la donnĂ©e structurĂ©e offerte !
Validation (Pydantic)
                        from pydantic import BaseModel, HttpUrl, validator

                        class Product(BaseModel):
                        title: str
                        price: float
                        url: HttpUrl

                        @validator('price')
                        def check_positive(cls, v):
                        if v < 0: raise ValueError('Prix négatif')
                        return v
                    
3.2 DevOps for Scrapers
Monitoring Metrics

Un scraper en prod doit ĂȘtre monitorĂ© comme une usine.

  • Success Rate : Ratio 200 OK vs (403 Forbidden + 503 Service Unavailable). Si < 90%, alerte.
  • Item Coverage : "J'ai scrapĂ© 100 pages mais obtenu 0 items". Signe de changement de DOM.
  • Ban Rate per Proxy : Identifier les plages IP grillĂ©es.
Stack Technique
  • Docker : Indispensable. Utiliser des images de base lĂ©gĂšres (Alpine) mais attention aux dĂ©pendances Chromium pour Playwright.
  • CI/CD : Tests d'intĂ©gration quotidiens sur une URL tĂ©moin pour dĂ©tecter les changements de layout.
  • Logging : ELK ou Loki. Loguer le HTML des pages en erreur (sur S3) pour debug post-mortem.
3.3 The Scraper's Toolbox
LangageLibUsage
PythonScrapyLe framework industriel. Pipeline, middlewares, concurrence asynchrone (Twisted).
Pythoncurl_cffiRequĂȘtes HTTP rapides avec impersonation TLS (Chrome/Safari).
Node.jsCrawleeFramework moderne par Apify. Gestion auto des proxies et fingerprinting.
GoCollyPerformance extrĂȘme, binaire unique, concurrence native.
GUI Tools
  • ScrapeOps : Dashboard de monitoring spĂ©cialisĂ© scraping.
  • Postman : Pour tester les APIs et gĂ©nĂ©rer les code snippets.