Lorsque vous mettez à l'échelle vos processus de scraping Web, vous devez envisager d'utiliser une solution fiable, efficace et gérable, quel que soit le volume de données que vous scrapez.

La plupart des développeurs trouvent difficile de gérer un scraping important en raison de la grande quantité de données impliquées. Votre code, qui fonctionnait parfaitement pour les petits projets, commence soudainement à se casser, à se bloquer ou à devenir impossible à maintenir.

C'est là que Crawlbase Notre solution est spécialement conçue pour faciliter une transition en douceur. Plus besoin de tout réécrire de zéro ni de modifier complètement votre flux de travail. Comment ? Nous vous l'expliquons en détail.

Table des Matières

  1. Pourquoi la mise à l'échelle est importante dans le Web Scraping

  2. Comment choisir entre le scraping Web synchronisé et asynchrone

  1. Comment configurer votre évolutivité Crawler
  1. Comment gérer le traitement de données à grande échelle
  1. Crawler Entretien et surveillance

  1. Faites évoluer votre Web Scraping avec Crawlbase

  2. Foire aux questions (FAQ)

Pourquoi la mise à l'échelle est importante dans le Web Scraping

À petite échelle, le processus de scraping web est simple. Vous écrivez le script, envoyez la requête à quelques pages web, et votre scraper effectue le travail séquentiellement. Cependant, dès que vous essayez d'augmenter l'échelle de votre projet pour scraper des milliers, voire des millions de pages, les choses commencent à se gâter.

La mise à l'échelle ne consiste pas seulement à faire la même chose, mais à en faire plus. Il s'agit de la faire intelligemment. Il est important de garder à l'esprit les problèmes courants de mise à l'échelle, comme :

  • Limitation de débit
  • Problèmes de concurrence
  • Relancer les défis
  • Problèmes d'efficacité du code
  • Limitations de stockage

Si vous ignorez ces problèmes, votre scraper peut fonctionner aujourd'hui, mais il plantera demain lorsque vos besoins en données augmenteront ou lorsque le site cible changera.

L'une des premières décisions à prendre est de choisir entre le scraping synchrone ou asynchrone. Ce choix peut à lui seul résoudre considérablement la plupart des problèmes de mise à l'échelle et affecter la rapidité et l'efficacité de votre mise à l'échelle.

Comment choisir entre le scraping Web synchronisé et asynchrone

Lors de la création d'un scraper évolutif, la manière dont vous envoyez et traitez les requêtes est importante. Pour les petits projets, un scraping synchrone peut convenir. Cependant, à mesure que vous évoluez, choisir la bonne approche peut faire la différence entre un scraper rapide et efficace et un scraper qui s'enlise ou se bloque.

Scraping Web synchrone

Le scraping synchrone est un processus très simple. Vous envoyez une requête, attendez la réponse, traitez les données, puis passez à la suivante. Tout se déroule étape par étape, comme faire la queue et attendre son tour.

Cette approche est facile à mettre en œuvre et idéale pour les tâches ou les tests à petite échelle car :

  • Le code est simple à lire et à déboguer
  • Il est plus facile de gérer les erreurs puisque les requêtes se produisent dans l'ordre
  • Vous n’avez pas à vous soucier de la concurrence ou de la coordination des tâches.

Crawlbase's Crawling API est un excellent exemple de crawler synchrone performant. Mais à mesure que vous évoluez, le crawling synchrone peut devenir un goulot d'étranglement. Votre scraper passe beaucoup de temps à attendre la réponse des serveurs, les timeouts et les nouvelles tentatives. Et tout ce temps d'attente s'accumule.

Scraping Web asynchrone

Le scraping asynchrone permet d'envoyer plusieurs requêtes, et le système les traite ou les exécute simultanément, sans attendre la fin de chaque requête pour exécuter la suivante. Cette approche est essentielle à la scalabilité, car elle supprime le temps d'inactivité lié à l'attente des réponses réseau.

En termes pratiques, cela signifie un débit plus élevé, une meilleure utilisation des ressources et la capacité d’extraire de gros volumes de données plus rapidement.

Crawlbase fournit un système d'exploration et de scraping asynchrone spécialement conçu, connu simplement sous le nom de The CrawlerIl est conçu pour gérer le scraping à haut volume en vous permettant de pousser plusieurs URL à explorer simultanément sans avoir à gérer une infrastructure complexe.

Voici comment cela fonctionne:

  • Crawler est un système push basé sur des rappels.
  • Vous envoyez des URL à récupérer vers le Crawler en utilisant la fonction Crawling API.
  • À chaque demande est attribué un RID (ID de demande) pour vous aider à la suivre tout au long du processus.
  • Toute demande ayant échoué sera automatiquement relancée jusqu'à ce qu'une réponse valide soit reçue.
  • Crawler publiera les résultats sur une URL de webhook sur votre serveur.

Crawler Vous offre un moyen puissant de mettre en œuvre le scraping asynchrone. Il traite plusieurs pages en parallèle et relance automatiquement les requêtes échouées. Cela permet de résoudre simultanément les problèmes de limitation de débit, de concurrence et de relance.

Que devez-vous faire pour faire évoluer le Web Scraping ?

Crawlbase's Crawling API est un excellent outil qui gère des millions de requêtes de manière fiable. Conçu pour le scraping à grande échelle, il est idéal si vous avez besoin de réponses directes et immédiates à chaque requête. Simple à mettre en œuvre, il est idéal pour les tâches de petite et moyenne envergure, les scripts rapides et les intégrations où des résultats en temps réel sont essentiels.

Cependant, lorsque vous avez affaire à du scraping au niveau de l'entreprise, à des millions d'URL, à des exigences de concurrence strictes et à la nécessité d'une mise en file d'attente robuste, l'utilisation de Crawler Cela a beaucoup plus de sens.

Crawler est conçu pour le scraping de données volumineuses. Évolutif par conception, il prend en charge le traitement simultané et les tentatives automatiques, et s'adapte à vos besoins.

Voici donc comment vous devez évoluer :

Créez un scraper évolutif en utilisant le Crawling API quand vous:

  • Besoin de résultats en temps réel
  • Exécutez-vous des petits travaux
  • Préférez un modèle de demande-réponse plus simple

Ensuite, passez à la Crawler quand vous:

  • Besoin de traiter des milliers ou des millions d'URL
  • Vous souhaitez gérer plusieurs demandes simultanément
  • Vous souhaitez décharger le processus de nouvelle tentative de votre côté
  • Construisez-vous un pipeline de données évolutif et de qualité production ?

En bref, si votre objectif est une véritable évolutivité, passez du scraping synchrone au scraping asynchrone avec le Crawler est le meilleur choix.

Comment configurer votre évolutivité Crawler

Dans cette section, nous vous proposons un guide étape par étape, incluant les meilleures pratiques pour créer un scraper web évolutif. Notez que nous avons choisi d'utiliser Python pour illustrer ce processus. Flacon et Serveuse, car cette méthode est à la fois légère et plus facile à mettre en œuvre.

Commençons.

Exigences Python

  • Configurer un environnement Python de base. Installez Python 3 sur votre système.
  • Installez les dépendances requises. Vous pouvez télécharger ce fichier et exécuter la commande ci-dessous dans votre terminal :
1
python -m pip install requests flask serveuse

Intégration Webhook

Étape 1 : Créez un fichier et nommez-le webhook_http_server.py, puis copiez et collez le code ci-dessous :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
à partir de ballon importer Flacon
à partir de ballon importer demandez
à partir de cheminlib importer Chemin
importer gzip
importer json
importer os
importer filetage

DEMANDE_ID_SÉCURITÉ = '8e1c3efb29fcc59d3c61f86960ccc9f5'

application = Flacon("webhook_http_server")

def handle_webhook_request(contenu de la demande):
    # Mise en œuvre à discuter ultérieurement
    pass

@app.route("/webhook", méthodes=["PUBLIER"])
def Webhook†
    if 'débarrasser' pas in en-têtes de demande or « Statut d'origine » pas in en-têtes de demande or « Statut PC » pas in en-têtes de requête :
        retourner ("", 404)

    crawlbase_rid = requête.en-têtes.get("débarrasser")

    if crawlbase_rid == « demande fictive »:
        impression("- Demande fictive reçue de Crawlbase.")
        retourner ("", 204)

    if request.headers.get(« Mon-Id ») != DEMANDE_ID_SÉCURITÉ :
        retourner ("", 404)

    contenu_de_la_requête = (
        crawlbase_rid,
        request.headers.get("url"),
        request.headers.get(« Statut d'origine »),
        request.headers.get(« Statut PC »),
        request.headers.get(« Encodage de contenu »),
        demande.données
    )

    thread = threading.Thread(cible=handle_webhook_request, args=(request_content,))
    thread.start ()

    retourner ("", 204)

En regardant le code ci-dessus, voici quelques bonnes pratiques que nous suivons pour un webhook :

  • Nous acceptons seulement HTTP POST requêtes, qui est la norme pour les webhooks.
  • Nous vérifions les en-têtes importants comme rid, Original-Statuset PC-Status à partir de Crawlbase à un besoin identifié pour s'assurer que la demande contient les bonnes informations.
  • Nous ignorons demandes fictives à partir de CrawlbaseCe sont simplement des messages de « pulsation » envoyés pour vérifier si votre webhook est opérationnel.
  • Nous recherchons également un en-tête personnalisé My-Id avec une valeur constante REQUEST_SECURITY_IDCette valeur est simplement une chaîne ; vous pouvez la modifier pour plus de sécurité. L'utilisation de cet en-tête est une bonne pratique. protéger votre webhook, car il vérifie si les réponses entrantes sont authentiques et vous sont destinées.
  • Enfin, les tâches réelles sont traitées dans un thread séparé, ce qui nous permet de répondre rapidement en moins de 200 ms. Cette configuration devrait permettre de traiter environ 200 requêtes par seconde sans problème.

Étape 2 : Ajoutez le reste du code ci-dessous. C'est ici que se trouvent les données réelles. Crawlbase sont traitées et enregistrées. Pour plus de simplicité, nous utilisons le système de fichiers pour suivre les requêtes explorées. Vous pouvez également utiliser base de données ou Redis.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
def handle_webhook_request(contenu de la demande):
    crawlbase_rid = contenu_de_la_requête[0]
    requested_url = request_content[1]
    original_status = contenu_de_la_requête[2]
    crawlbase_status = contenu_de_la_requête[3]
    content_encoding = request_content[4]
    corps = contenu_de_la_requête[5]

    if encodage_de_contenu == "gzip":
        Essai:
            corps = gzip.decompress(corps)
        sauf Exception:
            pass

    Essai:
        data_dir = os.path.join(Path.cwd(), "Les données")
        if pas os.path.isdir(data_dir) :
            Chemin(data_dir).mkdir(parents=Vrai, exist_ok=Vrai)

        rid_dir = os.path.join(data_dir, crawlbase_rid)
        if pas os.path.isdir(rid_dir) :
            Chemin(rid_dir).mkdir(parents=Vrai, exist_ok=Vrai)

        méta = {"débarrasser": crawlbase_rid, "url_demandée": url_demandée, "état_original": statut_original, « crawlbase_status »: crawlbase_status}
        meta_file = os.path.join(rid_dir, f"{crawlbase_rid}.meta.json")
        avec ouvert(méta_fichier, "w") as f:
            pretty_json = json.dumps(meta, indent=2)
            f.write(pretty_json)

        body_file = os.path.join(rid_dir, crawlbase_rid)
        avec ouvert(fichier_corps, "wb") as f:
            f.write(corps)

        impression(f"- RID traité avec succès {crawlbase_rid}. Sortie enregistrée dans '{rid_dir}'.")
    sauf Exception as e:
        impression(f"- Erreur rencontrée lors du traitement {crawlbase_rid}:\n{e}")

Cette partie du code décompresse soigneusement une tâche d'exploration terminée à partir de Crawlbase, organise les fichiers dans leur propre dossier, enregistre à la fois les notes et les données réelles du site Web et vous avertit en cas de problème.

Étape 3 : Complétez le code en configurant forfait serveuse pour exécuter le serveur. Ici, nous utilisons le port 5768 pour écouter les requêtes entrantes, mais vous pouvez modifier cette valeur selon votre préférence.

1
2
3
4
5
6
if __nom__ == "__principale__":
    à partir de serveuse importer besoin
    hôte = "0.0.0.0"
    port = 5768
    impression(f"\n\n- Le serveur HTTP Webhook est en cours d'exécution à {hôte}:{port}.\n\n")
    servir(application, hôte=hôte, port=port)

Voici le script complet de notre webhook_http_server.py ressemble à:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
à partir de ballon importer Flacon
à partir de ballon importer demandez
à partir de cheminlib importer Chemin
importer gzip
importer json
importer os
importer filetage

DEMANDE_ID_SÉCURITÉ = '8e1c3efb29fcc59d3c61f86960ccc9f5'

application = Flacon("webhook_http_server")

def handle_webhook_request(contenu de la demande):
    crawlbase_rid = contenu_de_la_requête[0]
    requested_url = request_content[1]
    original_status = contenu_de_la_requête[2]
    crawlbase_status = contenu_de_la_requête[3]
    content_encoding = request_content[4]
    corps = contenu_de_la_requête[5]

    if encodage_de_contenu == "gzip":
        Essai:
            corps = gzip.decompress(corps)
        sauf Exception:
            pass

    Essai:
        data_dir = os.path.join(Path.cwd(), "Les données")
        if pas os.path.isdir(data_dir) :
            Chemin(data_dir).mkdir(parents=Vrai, exist_ok=Vrai)

        rid_dir = os.path.join(data_dir, crawlbase_rid)
        if pas os.path.isdir(rid_dir) :
            Chemin(rid_dir).mkdir(parents=Vrai, exist_ok=Vrai)

        méta = {"débarrasser": crawlbase_rid, "url_demandée": url_demandée, "état_original": statut_original, « crawlbase_status »: crawlbase_status}
        meta_file = os.path.join(rid_dir, f"{crawlbase_rid}.meta.json")
        avec ouvert(méta_fichier, "w") as f:
            pretty_json = json.dumps(meta, indent=2)
            f.write(pretty_json)

        body_file = os.path.join(rid_dir, crawlbase_rid)
        avec ouvert(fichier_corps, "wb") as f:
            f.write(corps)

        impression(f"- RID traité avec succès {crawlbase_rid}. Sortie enregistrée dans '{rid_dir}'.")
    sauf Exception as e:
        impression(f"- Erreur rencontrée lors du traitement {crawlbase_rid}:\n{e}")

@app.route("/webhook", méthodes=["PUBLIER"])
def Webhook†
    if « Statut d'origine » pas in en-têtes de demande or « Statut PC » pas in en-têtes de demande or 'débarrasser' pas in en-têtes de requête :
        retourner ("", 404)

    crawlbase_rid = requête.en-têtes.get("débarrasser")

    if crawlbase_rid == « demande fictive »:
        impression("- Demande fictive reçue de Crawlbase.")
        retourner ("", 204)

    if request.headers.get(« Mon-Id ») != DEMANDE_ID_SÉCURITÉ :
        retourner ("", 404)

    contenu_de_la_requête = (
        crawlbase_rid,
        request.headers.get("url"),
        request.headers.get(« Statut d'origine »),
        request.headers.get(« Statut PC »),
        request.headers.get(« Encodage de contenu »),
        demande.données
    )

    thread = threading.Thread(cible=handle_webhook_request, args=(request_content,))
    thread.start ()

    retourner ("", 204)


if __nom__ == "__principale__":

    à partir de serveuse importer besoin
    hôte = "0.0.0.0"
    port = 5768
    impression(f"\n\n- Le serveur HTTP Webhook est en cours d'exécution à {hôte}:{port}.\n\n")
    servir(application, hôte=hôte, port=port)

Étape 4 : utilisez la commande ci-dessous pour exécuter notre serveur public temporaire.

1
ngrok http 5768

ngrok vous donnera un lien ou un « URL de transfert » vous pouvez partager avec Crawlbase il sait donc où envoyer les résultats.

Capture d'écran de la sortie de ngrok

Astuce: Lorsque vous souhaitez l'utiliser en production (pas seulement pour les tests), il est préférable d'exécuter votre webhook sur un serveur public et d'utiliser un outil comme nginx pour la sécurité et la fiabilité.

Étape 5 : exécutez le serveur HTTP Webhook.

1
webhook_http_server.py python

Cela va maintenant lancer notre Serveur HTTP Webhook, prêt à recevoir des données de Crawlbase.

Capture d'écran de la sortie du serveur HTTP Webhook

Étape 6: Configurez votre Crawlbase Compte.

  • Inscrivez-vous | Crawlbase compte et ajoutez vos informations de facturation activer le Crawler.
  • Créer un nouveau Crawler ici. Copiez l’URL de transfert fournie par ngrok plus tôt à l’étape 4 et collez-la dans le champ URL de rappel.
  • Choisir Requêtes normales (TCP) aux fins de ce guide.
Capture d'écran pour créer un nouveau Crawler

Comment gérer le traitement de données à grande échelle

Maintenant que notre webhook est en ligne, nous sommes prêts à explorer le Web à grande échelle. Nous allons créer un script pour vous permettre d'envoyer rapidement une liste de sites web à CrawlbaseIl réessaiera également automatiquement les demandes en cas de problème temporaire.

Étape 1 : Demande d'exploration de base

Créez un nouveau fichier Python et nommez-le comme crawl.py

Copiez et collez ce code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
à partir de cheminlib importer Chemin
importer json
importer os
importer demandes
importer urllib.parse

def ramper(url):
    url = url.strip()
    encoded_url = urllib.parse.quote(url, safe="")
    encoded_crawlbase_crawler_name = urllib.parse.quote(CRAWLBASE_CRAWLER_NAME, safe="")
    encoded_callback_headers = urllib.parse.quote(f"MON-ID:{REQUEST_SECURITY_ID}", sûr="")

    api_url = URL_API_D'EXPLORATION_BASE_D'EXPLORATION.le format(CRAWLBASE_TOKEN, encodé_url, encodé_crawlbase_crawler_name, encodé_callback_headers)

    Essai:
        réponse = requêtes.get(api_url)
        réponse.raise_for_status()
        json_response = json.loads(réponse.texte)
        crawlbase_rid = json_response["débarrasser"]

        data_dir = os.path.join(Path.cwd(), "Les données")
        Chemin(data_dir).mkdir(parents=Vrai, exist_ok=Vrai)

        rid_dir = os.path.join(data_dir, crawlbase_rid)
        Chemin(rid_dir).mkdir(parents=Vrai, exist_ok=Vrai)

        impression(f"- Demande d'exploration pour '{URL}" a été envoyé avec succès.")

    sauf Exception as e:
        impression(f"- Erreur rencontrée lors du traitement de '{URL}':\n{e}")

Que se passe-t-il dans cette partie du script ?

Après chaque demande d'exploration envoyée à Crawlbase, il crée un dossier dédié nommé d'après le ridCette approche vous permet de suivre vos demandes d'exploration, ce qui facilite la mise en correspondance ultérieure des résultats avec leurs URL d'origine.

De plus, lors de la soumission de la demande, nous ajoutons un en-tête personnalisé appelé My-Id avec une valeur de REQUEST_SECURITY_ID.

Étape 2 : Gestion des erreurs et logique de nouvelle tentative

Lors de la conception d'un scraper évolutif, assurez-vous toujours qu'il peut gérer les erreurs et inclure une logique permettant de relancer les requêtes ayant échoué. Si vous ne gérez pas ces problèmes, votre processus pourrait s'arrêter à cause d'un simple problème mineur.

Voici un exemple :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
importer Paisible

TAILLE_LOT = 100
DELAY_SECONDS = 1

def réessayer_opération(opération, max_retries=3, délai=2):
    pour tentative in gamme(1, max_retries + 1):
        Essai:
            retourner opération()
        sauf Exception as e:
            impression(f"- Erreur rencontrée lors de la nouvelle tentative '{tentative}':\n{e}")

        if tentative < max_retries :
            impression(f"- Réessayer dans {retard} secondes...")
            time.sleep(délai)

    augmenter Exception(« Nombre maximal de tentatives dépassé. »)

Enveloppez votre requête Web avec le retry_operation fonction pour garantir qu'il réessaye automatiquement jusqu'à max_retries fois en cas d'erreurs.

1
2
3
4
5
6
def perform_request†
    réponse = requêtes.get(api_url)
    réponse.raise_for_status()
    retourner à un besoin identifié

réponse = réessayer_opération(lambda: perform_request())

Étape 3 : Technique de traitement par lots

Lorsque vous envoyez des milliers d'URL, il est conseillé de les regrouper en petits groupes et de n'envoyer qu'un nombre limité de requêtes à la fois. Nous contrôlerons cela via le BATCH_SIZE valeur par seconde.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
def exploration par lots(urls):
    fils = []

    pour url in URL:
        t = threading.Thread(cible=crawl, args=(url,))
        threads.append(t)
        t.start()

    pour t in fils :
        t.join()

def crawl_urls(urls):
    pour i in gamme(0, len(urls), TAILLE_DU_LOT) :
        batched_urls = urls[i:i + BATCH_SIZE]
        impression(URL_par_lot)
        batch_crawl(URL_par_lot)
        time.sleep(DELAY_SECONDS)

Dans cette section, plusieurs requêtes d'un lot sont traitées simultanément pour accélérer le processus. Une fois le lot terminé, le script attend un court instant (DELAY_SECONDS) avant de passer au lot suivant. Il s'agit d'une méthode efficace pour gérer le scraping Web à grande échelle.

Voici le code complet. Copiez-le et écrasez-le dans votre crawl.py fichier.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
à partir de cheminlib importer Chemin
importer json
importer os
importer demandes
importer filetage
importer Paisible
importer urllib.parse

CRAWLBASE_TOKEN = " "
CRAWLBASE_CRAWLER_NAME = "<Crawler nom>"

DEMANDE_ID_SÉCURITÉ = '8e1c3efb29fcc59d3c61f86960ccc9f5'

CRAWLBASE_CRAWLING_API_URL = « https://api.crawlbase.com?token={0}&url={1}&crawler={2}&callback=true&callback_headers={3} »

TAILLE_LOT = 100
DELAY_SECONDS = 1

def réessayer_opération(opération, max_retries=3, délai=2):
    pour tentative in gamme(1, max_retries + 1):
        Essai:
            retourner opération()
        sauf Exception as e:
            impression(f"- Erreur rencontrée lors de la nouvelle tentative '{tentative}':\n{e}")

        if tentative < max_retries :
            impression(f"- Réessayer dans {retard} secondes...")
            time.sleep(délai)

    augmenter Exception(« Nombre maximal de tentatives dépassé. »)

def ramper(url):
    url = url.strip()
    encoded_url = urllib.parse.quote(url, safe="")
    encoded_crawlbase_crawler_name = urllib.parse.quote(CRAWLBASE_CRAWLER_NAME, safe="")
    encoded_callback_headers = urllib.parse.quote(f"MON-ID:{REQUEST_SECURITY_ID}", sûr="")

    api_url = URL_API_D'EXPLORATION_BASE_D'EXPLORATION.le format(CRAWLBASE_TOKEN, encodé_url, encodé_crawlbase_crawler_name, encodé_callback_headers)

    Essai:
        def perform_request†
            réponse = requêtes.get(api_url)
            réponse.raise_for_status()
            retourner à un besoin identifié

        réponse = réessayer_opération(lambda: perform_request())
        json_response = json.loads(réponse.texte)
        crawlbase_rid = json_response["débarrasser"]

        data_dir = os.path.join(Path.cwd(), "Les données")
        Chemin(data_dir).mkdir(parents=Vrai, exist_ok=Vrai)

        rid_dir = os.path.join(data_dir, crawlbase_rid)
        Chemin(rid_dir).mkdir(parents=Vrai, exist_ok=Vrai)

        impression(f"- Demande d'exploration pour '{URL}" a été envoyé avec succès.")

    sauf Exception as e:
        impression(f"- Erreur rencontrée lors du traitement de '{URL}':\n{e}")

def exploration par lots(urls):
    fils = []

    pour url in URL:
        t = threading.Thread(cible=crawl, args=(url,))
        threads.append(t)
        t.start()

    pour t in fils :
        t.join()

def crawl_urls(urls):
    pour i in gamme(0, len(urls), TAILLE_DU_LOT) :
        batched_urls = urls[i:i + BATCH_SIZE]
        impression(URL_par_lot)
        batch_crawl(URL_par_lot)
        time.sleep(DELAY_SECONDS)


if __nom__ == "__principale__":

    URL = [
        "http://httpbin.org/",
        "https://github.com/crawlbase",
        "http://httpbin.org/ip",
        "http://httpbin.org/html",
    ]
    crawl_urls(urls)

Étape 4 : exécutez votre site Web Crawler.

1
python crawl.py

Exemple de sortie:

Capture d'écran de la sortie de la console Crawl

Allez dans Serveur HTTP Webhook console du terminal, et vous devriez voir une sortie similaire ci-dessous :

Capture d'écran du serveur HTTP Webhook après l'exploration

Ce processus génère un data répertoire, qui comprend un sous-répertoire nommé <rid> pour chaque demande d'exploration :

Capture d'écran de la sortie du dossier de données

  1. <rid> le fichier contient les données récupérées.

  2. <rid>.meta.json file contient les métadonnées associées :

Exemple : 

1
2
3
4
5
6
{
  "débarrasser": " ",
  "url_demandée": "http://httpbin.org/",
  "état_original": "200",
  « crawlbase_status »: "200"
}

Obtenez les code complet sur Github.

Crawler Entretien et surveillance

Une fois votre scraper web à grande échelle opérationnel, une surveillance et une maintenance adéquates sont nécessaires pour garantir son évolutivité et son efficacité. Voici quelques points à prendre en compte :

Gérer Crawler Traffic

Crawlbase propose un ensemble complet d'API qui vous permettent d'effectuer les opérations suivantes :

  1. Mettre en pause ou réactiver un robot d'exploration
  2. Purger ou supprimer des tâches
  3. Vérifiez les tâches actives et la taille de la file d'attente

Pour plus de détails, vous pouvez explorer le Crawler Documents sur l'API.

De plus, si votre robot semble être en retard ou se bloque de manière inattendue, vous pouvez surveiller sa latence ou la différence de temps depuis que la tâche la plus ancienne a été ajoutée à la file d'attente à partir du Crawlertableau de bord. Si nécessaire, vous pouvez également redémarrer votre robot directement depuis cette page.

Outils de surveillance

Utilisez ces outils pour suivre votre Crawler activité et détecter les problèmes avant qu'ils n'impactent l'échelle.

  1. Crawler Tableau de bord - Affichez le coût actuel, le nombre de réussites et d'échecs de votre TCP ou JavaScript Crawler.
  2. Moniteur en direct - Consultez l'activité en temps réel, y compris les explorations réussies, les échecs, la taille de la file d'attente et les nouvelles tentatives en attente.
  3. Moniteur de nouvelle tentative - Afficher une description détaillée des requêtes en cours de relance.

Remarque: Les tentatives infructueuses affichées sur le tableau de bord représentent une logique de relance interne. Vous n'avez pas à vous soucier de leur gestion, car le système est conçu pour demander automatiquement une nouvelle tentative pour les tâches ayant échoué.

Crawler Limites

Voici les valeurs par défaut à garder à l’esprit lors de la mise à l’échelle :

  • Limite de taux de poussée : 30 requêtes/seconde
  • Concurrence : 10 tâches simultanées
  • Nombre de tentatives : 110 tentatives par requête
  • limite de file d'attente combinée pour tous vos Crawlers est 1 million de pagesSi cette limite est atteinte, le système suspend temporairement les demandes push et reprend automatiquement lorsque la file d'attente est vide.

N'oubliez pas que ces limites peuvent être ajustées pour répondre à vos besoins spécifiques. Contactez-nous. Crawlbase Service au client pour demander une mise à niveau.

Faites évoluer votre Web Scraping avec Crawlbase

Les projets de web scraping ont évolué au-delà de la simple rédaction de scripts robustes et de la gestion de proxys. Vous avez besoin d'une infrastructure d'entreprise, à la fois conforme à la législation et adaptable aux besoins changeants du monde des affaires moderne.

Crawlbase est conçu pour la performance, la fiabilité et l'évolutivité. Grâce à ses solutions, des entreprises et des développeurs comme le vôtre ont obtenu des informations exploitables pour leur croissance.

Inscrivez-vous maintenant gratuitement.

Foire aux questions (FAQ)

Q : Puis-je créer mon propre Crawler webhook ?

Oui, pour faire évoluer le web scraping, c'est toujours une bonne pratique de créer un webhook pour votre CrawlerNous vous recommandons de consulter notre guide complet Comment utiliser Crawlbase Crawler apprendre comment.

Q : Puis-je tester le Crawler gratuitement?

Actuellement, vous devrez ajoutez vos informations de facturation premier à utiliser le Crawler. Crawlbase ne fournit pas de crédits gratuits par défaut lorsque vous vous inscrivez au Crawler, mais vous pouvez contacter le support client pour demander un essai gratuit.

Q : Quelles sont les meilleures pratiques pour gérer le contenu dynamique dans le web scraping ?

Vous souhaitez gérer le contenu dynamique grâce au web scraping ? Voici quelques bonnes pratiques à retenir :

  1. Exploiter l'API : Jetez un œil à l'activité du réseau pour vérifier si les données proviennent d'une API interne. Cette méthode est généralement plus rapide et plus fiable pour le scraping.

  2. Attendez stratégiquement : Au lieu de vous fier à des délais d'attente codés en dur, utilisez des stratégies d'attente intelligentes telles que waitForSelector or waitForNetworkIdle pour vous assurer que tous les éléments sont entièrement chargés avant de continuer.

  3. Utiliser une API de scraping : Des outils comme Crawlbase peut vous simplifier la vie en gérant le contenu dynamique pour vous, en gérant le rendu, l'exécution JavaScript et même les mesures anti-bot.

Q : Quelles sont les meilleures pratiques pour la rotation des proxys dans le web scraping ?

Maintenant, si vous êtes curieux de connaître les meilleures pratiques en matière de rotation des proxys dans le web scraping, voici ce que vous devriez prendre en compte :

  1. Utilisez judicieusement les proxys résidentiels ou de centre de données : Choisissez le type de proxy adapté au site web que vous ciblez. Les proxys résidentiels sont plus difficiles à détecter, mais leur coût est plus élevé.

  2. Automatiser la rotation : Configurez la rotation automatique des IP après quelques requêtes ou après un certain nombre de secondes pour garder les choses à jour.

  3. Évitez de surcharger une seule adresse IP : Répartissez vos requêtes uniformément sur différents proxys pour éviter les schémas susceptibles d'alerter les systèmes anti-bot.

  4. Surveiller la santé du proxy : Gardez un œil sur les temps de réponse, les codes d’état et les taux de réussite pour repérer et remplacer les proxys défaillants.

  5. Utiliser une solution proxy gérée : Des services comme Crawlbase fournit une gestion et une rotation de proxy intégrées, vous n'aurez donc pas à gérer les configurations manuelles.

Q : Quelles sont les meilleures pratiques pour gérer de grands ensembles de données issus du web scraping ?

Pour gérer de grands volumes de données issues du web scraping, plusieurs bonnes pratiques peuvent faire toute la différence. Voici quelques conseils à retenir :

  1. Utiliser la pagination et le traitement par lots : Au lieu de tout récupérer d'un coup, divisez vos tâches en plus petites parties à l'aide de paramètres de page ou de plages de dates. Cela permet d'éviter de surcharger les serveurs ou de rencontrer des problèmes de mémoire.

  2. Stocker les données de manière incrémentielle : Transférez vos données récupérées directement vers des bases de données ou un stockage cloud au fur et à mesure. Vous éviterez ainsi une surcharge de mémoire et garderez tout organisé.

  3. Normaliser et nettoyer les données au plus tôt : Prenez le temps de nettoyer, dédupliquer et structurer vos données pendant le scraping. Cela allégera la charge de traitement ultérieure.

  4. Mettre en œuvre des systèmes de nouvelle tentative et de journalisation : Surveillez les URL qui ne parviennent pas à scraper et mettez en place un système pour les réessayer ultérieurement. L'enregistrement de vos statistiques de scraping peut également vous aider à suivre votre progression et à identifier les problèmes.

  5. Utiliser une infrastructure évolutive : Pensez à utiliser le scraping asynchrone, les files d'attente de tâches ou les fonctions sans serveur pour gérer des tâches plus importantes. Des outils comme Crawlbase peut vous aider à faire évoluer votre extraction de données sans les tracas liés à la gestion des ressources backend.