Crawler Agent Tutorial : Déploiement d'un pool d'agents Crawler + Méthodes de mise en œuvre à haute concurence

Dans le monde de l'exploration de données, l'IP proxy est comme une cape pour le crawler, nous aidant à voyager librement sur le réseau et à éviter d'être identifiés et bloqués par le site web cible. Aujourd'hui, je vais partager avec vous des conseils sur le déploiement d'un pool de proxy de crawler et sur la mise en œuvre d'une concurrence élevée.

Qu'est-ce que la réserve d'agents Crawler ?

Tout d'abord, nous devons comprendre ce qu'est le proxy pool du crawler. En termes simples, le proxy pool est un "pool" de stockage d'IP proxy, le crawler peut travailler à partir de ce pool pour retirer l'IP proxy, remplacer son IP réelle, afin d'éviter d'être banni par le site cible. Un bon ou un mauvais proxy pool affecte directement l'efficacité et la stabilité du crawler.

Déploiement d'un pool de serveurs mandataires Crawler

Le déploiement d'un pool d'agents n'est pas vraiment compliqué et se divise en plusieurs étapes :

1) Obtenir une IP proxy

L'étape la plus élémentaire consiste à obtenir une IP proxy. Il existe de nombreux fournisseurs de services IP proxy gratuits et payants sur le marché. La qualité des IP proxy gratuites varie et il peut y avoir de nombreuses IP indisponibles, tandis que les IP proxy payantes sont relativement stables. Il y a plusieurs façons d'obtenir une IP proxy, vous pouvez l'obtenir via l'interface API, ou vous pouvez l'extraire de certains sites web.

demandes d'importation

def get_proxies() : url = ''
url = 'https://api.proxyscrape.com/?request=displayproxies&proxytype=http'
response = requests.get(url)
proxies = response.text.split('n')
return proxies

2) Vérifier l'IP du proxy

Après avoir obtenu les adresses IP du proxy, nous devons les vérifier. L'objectif de la validation est de s'assurer que ces IP sont disponibles. La disponibilité et la vitesse de réponse des IP peuvent être vérifiées en envoyant une requête HTTP. D'une manière générale, les adresses IP dont le temps de réponse est rapide et stable conviennent mieux comme adresses IP de proxy.

def validate_proxy(proxy) : url = ''
url = 'http://httpbin.org/ip'
try.
response = requests.get(url, proxies={'http' : proxy, 'https' : proxy}, timeout=5)
if response.status_code == 200: : response.status_code == 200 : response.status_code == 200
return True
return True : if response.status_code == 200 : return True
return False
retour Faux

proxies = get_proxies()
valid_proxies = [proxy for proxy in proxies if validate_proxy(proxy)]

3. l'IP du proxy de stockage

Les adresses IP proxy vérifiées doivent être stockées pour que le robot d'exploration puisse les appeler à tout moment. L'IP proxy peut être stockée dans une base de données, telle que Redis ou MongoDB, qui prend en charge un accès simultané élevé et peut répondre aux besoins du robot d'exploration.

import redis

def store_proxies(proxies) :
r = redis.Redis(host='localhost', port=6379, db=0)
for proxy in proxies : r.sadd('proxies')
r.sadd('proxies', proxy)

store_proxies(valid_proxies)

Méthodes de mise en œuvre à haute concordance

Une forte concurrence est une caractéristique importante du pool d'agents du crawler, qui peut améliorer l'efficacité du crawler. Il existe de nombreuses façons d'obtenir une forte concurrence. Voici une description de plusieurs méthodes couramment utilisées.

1. le multithreading

Le multithreading est une méthode fondamentale pour atteindre un haut niveau de concurrence. En activant plusieurs threads, un crawler peut envoyer plusieurs requêtes en même temps, augmentant ainsi la vitesse du crawling. La bibliothèque `threading` de Python facilite l'implémentation du multithreading.

importer le filage

def fetch_url(url, proxy) :
try.
response = requests.get(url, proxies={'http' : proxy, 'https' : proxy})
print(response.text)
except.
pass

url = 'http://example.com'
threads = []
for proxy in valid_proxies : threading.Thread(target=fetch_url, args=(url, proxy))
t = threading.Thread(target=fetch_url, args=(url, proxy))
threads.append(t)
t.start()

pour t dans threads.
t.join()

2. l'IO asynchrone

En plus du multithreading, l'IO asynchrone est également un moyen efficace d'atteindre un haut niveau de concurrence. L'IO asynchrone permet de réaliser des opérations IO non bloquantes grâce au mécanisme de boucle d'événements, ce qui peut améliorer de manière significative les performances du crawler en matière de simultanéité.

import aiohttp
import asyncio

async def fetch_url(session, url, proxy): :
try : async with session.get(url, proxy=f'{proxy}')
async avec session.get(url, proxy=f'http://{proxy}') as response.
print(await response.text())
except : async with session.get(url, proxy=f'{proxy}')
pass

async def main() : url = ''
url = 'http://example.com'
async avec aiohttp.ClientSession() as session.
tasks = [fetch_url(session, url, proxy) for proxy in valid_proxies]
await asyncio.gather(*tasks)

asyncio.run(main())

3. les robots d'indexation distribués

Lorsque les performances d'une seule machine atteignent un goulot d'étranglement, il convient d'envisager l'utilisation d'un crawler distribué. Les crawlers distribués peuvent améliorer considérablement l'efficacité de l'exploration en répartissant les tâches sur plusieurs machines. Les crawlers distribués les plus couramment utilisés sont Scrapy-Redis et PySpider.

# Configuration de l'exemple Scrapy-Redis
# settings.py
SCHEDULER = "scrapy_redis.scheduler.Scheduler"
DUPEFILTER_CLASS = "scrapy_redis.dupefilter.RFPDupeFilter"
REDIS_URL = 'redis://localhost:6379'

# Utilisation de Redis pour stocker les IP de proxy dans le code du crawler
import redis
from scrapy_redis.spiders import RedisSpider

classe MySpider(RedisSpider).
name = 'my_spider'
redis_key = 'my_spider:start_urls'

def __init__(self, *args, **kwargs) : super(MySpider, self).
super(MySpider, self). __init__(*args, **kwargs)
self.redis = redis.Redis(host='localhost', port=6379, db=0)

def make_requests_from_url(self, url) : proxy = self.redis.
proxy = self.redis.srandmember('proxies').decode('utf-8')
return scrapy.Request(url, meta={'proxy' : f'http://{proxy}'})

Entretien de la piscine par l'agent

Une fois le pool d'agents déployé, une maintenance régulière est nécessaire. Les IP proxy peuvent tomber en panne au fil du temps et doivent être mises à jour et vérifiées régulièrement. Une tâche programmée peut être mise en place pour vérifier périodiquement la disponibilité des IP proxy et supprimer les IP défaillantes du pool de proxy.

1. mise à jour de l'IP proxy

Afin de maintenir le pool de proxy en vie, de nouvelles IP de proxy doivent être obtenues auprès du fournisseur de proxy et ajoutées au pool de proxy sur une base régulière. Cela permet de s'assurer qu'il y a toujours suffisamment d'adresses IP disponibles dans le pool de serveurs mandataires.

2. vérification de l'IP du proxy

La vérification des IP de proxy est un processus continu. Vous pouvez configurer une tâche programmée pour vérifier les IP du pool de proxy à intervalles réguliers et éliminer les IP non valides, ce qui garantira la qualité du pool de proxy.

temps d'importation

while True : proxies = get_proxies()
proxies = get_proxies()
valid_proxies = [proxy for proxy in proxies if validate_proxy(proxy)]
store_proxies(valid_proxies)
time.sleep(3600) # Mise à jour toutes les heures

résumés

Le déploiement du pool d'agents du crawler et la mise en œuvre d'une concurrence élevée constituent une partie importante de l'exploration des données. En déployant raisonnablement le pool d'agents et en implémentant une haute concurrence, vous pouvez améliorer de manière significative l'efficacité et la stabilité du crawler. J'espère que cet article pourra vous aider, je vous souhaite de continuer à progresser sur la voie de l'exploration de données !