Comment utiliser Gospider pour le crawling et le scraping sur le web ?

Dans ce guide, vous apprendrez :

Qu’est-ce que Gospider et comment fonctionne-t-il ?
Quelles sont les fonctionnalités offertes ?
Comment l’utiliser pour l’exploration du web
Comment l’intégrer à Colly pour le scraping web
Ses principales limites et comment les contourner

Plongeons dans l’aventure !

Qu’est-ce que Gospider ?

Gospider est un outil CLI de crawling rapide et efficace écrit en Go. Il est conçu pour scanner des sites web et extraire des URL en parallèle, en gérant plusieurs requêtes et domaines en même temps. De plus, il respecte les robots.txt et peut découvrir des liens même dans des fichiers JavaScript.

Gospider offre plusieurs options de personnalisation pour contrôler la profondeur de l’exploration, les délais des requêtes, etc. Il prend également en charge l’intégration de proxy, ainsi que diverses autres options permettant de mieux contrôler le processus d’exploration.

Qu’est-ce qui rend Gospider unique pour l’exploration du Web ?

Pour mieux comprendre pourquoi Gospider est spécial pour l’exploration du web, explorons ses caractéristiques en détail et examinons les drapeaux pris en charge.

Caractéristiques

Voici les principales fonctionnalités offertes par Gospider en matière d’exploration du web :

Exploration rapide des sites web: Parcourez efficacement des sites web individuels à grande vitesse.
Exploration parallèle: L’exploration simultanée de plusieurs sites permet d’accélérer la collecte des données.
analyse dufichier sitemap.xml: Traite automatiquement les fichiers sitemap pour améliorer l’exploration.
analyserobots.txt: Conforme aux directivesrobots.txt pour l’exploration éthique.
Analyse des liens JavaScript: Extrait les liens des fichiers JavaScript.
Options d’exploration personnalisables: Ajustez la profondeur de l’exploration, la simultanéité, le délai, les délais, et plus encore avec des drapeaux flexibles.
Randomisation de l’agent utilisateur: Randomise entre les User-Agents mobiles et web pour des demandes plus réalistes. Découvrez le meilleur User-Agent pour l’exploration du web.
Personnalisation des cookies et des en-têtes: Permet de personnaliser les cookies et les en-têtes HTTP.
Recherche de liens: Identifie les URL et les autres ressources d’un site.
Trouver des buckets AWS S3: Détecte les buckets AWS S3 à partir des sources de réponse.
Trouver des sous-domaines: Découvre les sous-domaines à partir des sources de réponse.
Sources tierces: Extrait les URL de services tels que Wayback Machine, Common Crawl, VirusTotal et Alien Vault.
Formatage facile des résultats: Les résultats sont présentés dans des formats faciles à extraire et à analyser.
Prise en charge de Burp Suite: Intégration avec Burp Suite pour faciliter les tests et l’exploration.
Filtrage avancé: Liste noire et liste blanche d’URL, y compris filtrage au niveau du domaine.
Prise en charge des sous-domaines: Inclut les sous-domaines dans les recherches effectuées à partir du site cible et de sources tierces.
Modes débogage et verbeux: Active le débogage et la journalisation détaillée pour faciliter le dépannage.

Options de la ligne de commande

Voici à quoi ressemble une commande générique de Gospider :

gospider [flags]

En particulier, les drapeaux pris en charge sont les suivants:

-s, --site: Site à explorer.
-S, --sites: Liste des sites à explorer.
-p, --proxy: URL proxy.
-o, --output: dossier de sortie.
-u, --user-agent: Agent utilisateur à utiliser (par exemple, web, mobi, ou un agent utilisateur personnalisé).
--cookie: Cookie à utiliser (par exemple, testA=a ; testB=b).
-H, --header: En-tête(s) à utiliser (vous pouvez répéter le drapeau plusieurs fois pour plusieurs en-têtes).
--burp string: Charge les en-têtes et les cookies d’une requête HTTP brute de Burp Suite.
--blacklist: Liste noire d’URL Regex.
--whitelist: Liste blanche d’URL Regex.
--whitelist-domain: Domaine de liste blanche.
-t, --threads: Nombre de threads à exécuter en parallèle (par défaut : 1).
-c, --concurrent: Nombre maximal de requêtes simultanées pour les domaines correspondants (par défaut : 5).
-d, --depth: profondeur maximale de récursion pour les URL ( 0 pour une récursion infinie, 1 par défaut).
-k, --delay int: délai entre les demandes (en secondes).
-K, --random-delay int: Délai aléatoire supplémentaire avant de faire des requêtes (en secondes).
-m, --timeout int: Délai d’attente de la demande (en secondes, par défaut : 10).
-B, --base: Désactive tout et n’utilise que le contenu HTML.
--js: Active la recherche de liens dans les fichiers JavaScript (par défaut : true).
--subs: inclut les sous-domaines.
--sitemap: explorer le fichier sitemap.xml.
--robots: Effectue l’exploration du fichier robots.txt (par défaut : true).
-a, --other-source: recherche des URL à partir de sources tierces telles que Archive.org, CommonCrawl, VirusTotal, AlienVault.
-w, --include-subs: Inclut les sous-domaines explorés à partir de sources tierces (par défaut : seulement le domaine principal).
-r, --include-other-source: Inclure les URLs provenant de sources tierces tout en continuant à les crawler.
--debug: activer le mode de débogage.
--json: Activer la sortie JSON.
-v, --verbose: activer la sortie verbale.
-l, --length: affiche la longueur de l’URL.
-L, --filter-length: filtre les URL en fonction de leur longueur.
-R, --raw: affiche la sortie brute.
-q, --quiet: Supprime toutes les sorties et n’affiche que les URL.
--no-redirect: Désactive les redirections.
--version: Vérifier la version.
-h, --help: afficher l’aide.

L’exploration du Web avec Gospider : Guide étape par étape

Dans cette section, vous apprendrez à utiliser Gospider pour crawler les liens d’un site multipage. Plus précisément, le site cible sera Books to Scrape:

Le site contient une liste de produits répartis sur 50 pages. Chaque entrée de produit sur ces pages de liste a également sa propre page de produit dédiée. Les étapes ci-dessous vous guideront dans le processus d’utilisation de Gospider pour récupérer toutes les URL de ces pages de produits !

Conditions préalables et configuration du projet

Avant de commencer, assurez-vous que vous disposez des éléments suivants :

Go est installé sur votre ordinateur: Si vous n’avez pas encore installé Go, téléchargez-le à partir du site officiel et suivez les instructions d’installation.
Un IDE Go: Visual Studio Code avec l’extension Go est recommandé.

Pour vérifier que Go est installé, exécutez :

go version

Si Go est installé correctement, vous devriez obtenir un résultat similaire à celui-ci (sous Windows) :

go version go1.24.1 windows/amd64

Le plus beau ! Go est installé et prêt à fonctionner.

Créez un nouveau dossier de projet et accédez-y dans le terminal :

mkdir gospider-project  
cd gospider-project

Vous êtes maintenant prêt à installer Gospider et à l’utiliser pour l’exploration du Web !

Étape 1 : Installer Gospider

Exécutez la commande go install suivante pour compiler et installer Gospider globalement :

go install github.com/jaeles-project/gospider@latest

Après l’installation, vérifiez que Gospider est installé en exécutant :

gospider -h

Les instructions d’utilisation de Gospider devraient s’afficher comme suit :

Fast web spider written in Go - v1.1.6 by @thebl4ckturtle & @j3ssiejjj

Usage:
  gospider [flags]

Flags:
  -s, --site string               Site to crawl
  -S, --sites string              Site list to crawl
  -p, --proxy string              Proxy (Ex: http://127.0.0.1:8080)
  -o, --output string             Output folder
  -u, --user-agent string         User Agent to use
                                        web: random web user-agent
                                        mobi: random mobile user-agent
                                        or you can set your special user-agent (default "web")
      --cookie string             Cookie to use (testA=a; testB=b)
  -H, --header stringArray        Header to use (Use multiple flag to set multiple header)
      --burp string               Load headers and cookie from burp raw http request
      --blacklist string          Blacklist URL Regex
      --whitelist string          Whitelist URL Regex
      --whitelist-domain string   Whitelist Domain
  -L, --filter-length string      Turn on length filter
  -t, --threads int               Number of threads (Run sites in parallel) (default 1)
  -c, --concurrent int            The number of the maximum allowed concurrent requests of the matching domains (default 5)
  -d, --depth int                 MaxDepth limits the recursion depth of visited URLs. (Set it to 0 for infinite recursion) (default 1)
  -k, --delay int                 Delay is the duration to wait before creating a new request to the matching domains (second)
  -K, --random-delay int          RandomDelay is the extra randomized duration to wait added to Delay before creating a new request (second)
  -m, --timeout int               Request timeout (second) (default 10)
  -B, --base                      Disable all and only use HTML content
      --js                        Enable linkfinder in javascript file (default true)
      --sitemap                   Try to crawl sitemap.xml
      --robots                    Try to crawl robots.txt (default true)
  -a, --other-source              Find URLs from 3rd party (Archive.org, CommonCrawl.org, VirusTotal.com, AlienVault.com)
  -w, --include-subs              Include subdomains crawled from 3rd party. Default is main domain
  -r, --include-other-source      Also include other-source's urls (still crawl and request)
      --subs                      Include subdomains
      --debug                     Turn on debug mode
      --json                      Enable JSON output
  -v, --verbose                   Turn on verbose
  -q, --quiet                     Suppress all the output and only show URL
      --no-redirect               Disable redirect
      --version                   Check version
  -l, --length                    Turn on length
  -R, --raw                       Enable raw output
  -h, --help                      help for gospider

Génial ! Gospider a été installé et vous pouvez maintenant l’utiliser pour explorer un ou plusieurs sites web.

Étape 2 : Explorer les URL de la page cible

Pour explorer tous les liens de la page cible, exécutez la commande suivante :

gospider -s "https://books.toscrape.com/" -o output -d 1

Voici une ventilation des drapeaux Gospider utilisés :

-s "https://books.toscrape.com/": Spécifie l’URL cible.
-o output: Enregistre les résultats de l’exploration dans le dossier de sortie.
-d 1: définit la profondeur d’exploration à 1, ce qui signifie que Gospider ne détectera que les URL de la page actuelle. En d’autres termes, il ne suivra pas les URL trouvées pour découvrir des liens plus profonds.

La commande ci-dessus produira la structure suivante :

gospider-project/
  └── output/
        └── books_toscrape_com

Ouvrez le fichier books_toscrape_com dans le dossier output, et vous obtiendrez un résultat similaire à celui-ci :

[url] - [code-200] - https://books.toscrape.com/
[href] - https://books.toscrape.com/static/oscar/favicon.ico
# omitted for brevity...
[href] - https://books.toscrape.com/catalogue/page-2.html
[javascript] - http://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js
# omitted for brevity...
[javascript] - https://books.toscrape.com/static/oscar/js/bootstrap-datetimepicker/locales/bootstrap-datetimepicker.all.js
[url] - [code-200] - http://ajax.googleapis.com/ajax/libs/jquery/1.9.1/jquery.min.js
# omitted for brevity...
[linkfinder] - [from: https://books.toscrape.com/static/oscar/js/bootstrap-datetimepicker/locales/bootstrap-datetimepicker.all.js] - dd/mm/yyyy
# omitted for brevity...
[url] - [code-200] - https://books.toscrape.com/static/oscar/js/bootstrap-datetimepicker/bootstrap-datetimepicker.js

Le fichier généré contient différents types de liens détectés :

[url]: Les pages/ressources explorées.
[href]: Tous les liens <a href> trouvés sur la page.
[javascript]: URL des fichiers JavaScript.
[linkfinder]: Extraction des liens intégrés dans le code JavaScript.

Étape 3 : Explorer l’ensemble du site

Le résultat ci-dessus montre que Gospider s’est arrêté à la première page de pagination. Il a détecté le lien vers la deuxième page, mais ne l’a pas consulté.

Vous pouvez le vérifier car le fichier books_toscrape_com contient :

[href] - https://books.toscrape.com/catalogue/page-2.html

La balise [href] indique que le lien a été découvert. Cependant, comme il n’y a pas d’entrée [url] correspondante avec la même URL, le lien a été trouvé mais n’a jamais été visité.

Si vous inspectez la page cible, vous verrez que l’URL ci-dessus correspond à la deuxième page de pagination :

Inspection de l'élément "next" sur la première page de pagination

Pour explorer l’ensemble du site web, vous devez suivre tous les liens de pagination. Comme le montre l’image ci-dessus, le site cible contient 50 pages de produits (notez le texte “Page 1 sur 50”). Réglez la profondeur de Gospider sur 50 pour vous assurer qu’il atteindra toutes les pages.

Comme il s’agit d’explorer un grand nombre de pages, il est également conseillé d’augmenter le taux de concurrence (c’est-à-dire le nombre de requêtes simultanées). Par défaut, Gospider utilise un niveau de concurrence de 5, mais l’augmenter à 10 accélérera l’exécution.

La commande finale pour parcourir toutes les pages de produits est la suivante :

gospider -s "https://books.toscrape.com/" -o output -d 50 -c 10

Cette fois, Gospider prendra plus de temps à s’exécuter et produira des milliers d’URL. La sortie contiendra désormais des entrées telles que :

[url] - [code-200] - https://books.toscrape.com/
[href] - https://books.toscrape.com/static/oscar/favicon.ico
[href] - https://books.toscrape.com/static/oscar/css/styles.css
# omitted for brevity...
[href] - https://books.toscrape.com/catalogue/page-50.html
[url] - [code-200] - https://books.toscrape.com/catalogue/page-50.html

Le détail essentiel à vérifier dans le résultat est la présence de l’URL de la dernière page de pagination :

[url] - [code-200] - https://books.toscrape.com/catalogue/page-50.html

Merveilleux ! Cela confirme que Gospider a suivi avec succès tous les liens de pagination et a exploré l’ensemble du catalogue de produits comme prévu.

Étape 4 : Obtenir uniquement la page du produit

En quelques secondes, Gospider a collecté toutes les URL d’un site entier. Ce tutoriel pourrait s’arrêter là, mais allons plus loin.

Que se passe-t-il si vous souhaitez uniquement extraire les URL des pages de produits ? Pour comprendre comment ces URL sont structurées, inspectez un élément de produit sur la page cible :

Cette inspection permet de constater que les URL des pages de produits suivent ce format :

https://books.toscrape.com/catalogue/<product_slug>/index.html

Pour filtrer uniquement les pages de produits à partir des URL brutes, vous pouvez utiliser un script Go personnalisé.

Tout d’abord, créez un module Go dans le répertoire de votre projet Gospider :

go mod init crawler

Ensuite, créez un dossier crawler dans le répertoire du projet et ajoutez-y un fichier crawler.go. Ensuite, ouvrez le dossier du projet dans votre IDE. La structure de votre dossier devrait maintenant ressembler à ceci :

gospider-project/
├── crawler/
│   └── crawler.go
└── output/
    └── books_toscrape_com

Le script crawler.go doit :

Exécutez la commande Gospider à partir d’un état propre.
Lire toutes les URL du fichier de sortie.
Filtrer uniquement les URL des pages de produits à l’aide d’une expression rationnelle.
Exporter les URL de produits filtrés dans un fichier .txt.

Vous trouverez ci-dessous le code Go permettant d’atteindre cet objectif :

package main

import (
        "bufio"
        "fmt"
        "os"
        "os/exec"
        "regexp"
        "slices"
        "path/filepath"
)

func main() {
        // Delete the output folder if it exists to start with a clean run
        outputDir := "output"
        os.RemoveAll(outputDir)

        // Create the Gospider CLI command to crawl the "books.toscrape.com" site
        fmt.Println("Running Gospider...")
        cmd := exec.Command("gospider", "-s", "https://books.toscrape.com/", "-o", outputDir, "-d", "50", "-c", "10")
        cmd.Stdout = os.Stdout
        cmd.Stderr = os.Stderr

        // Run the Gospider command and wait for it to finish
        cmd.Run()
        fmt.Println("Gospider finished")

        // Open the generated output file that contains the crawled URLs
        fmt.Println("\nReading the Gospider output file...")
        inputFile := filepath.Join(outputDir, "books_toscrape_com")
        file, _ := os.Open(inputFile)
        defer file.Close()

        // Extract product page URLs from the file using a regular expression
        // to filter out the URLs that point to individual product pages
        urlRegex := regexp.MustCompile(`(https://books\.toscrape\.com/catalogue/[^/]+/index\.html)`)
        var productURLs []string

        // Read each line of the file and check for matching URLs
        scanner := bufio.NewScanner(file)
        for scanner.Scan() {
                line := scanner.Text()
                // Extract all URLs from the line
                matches := urlRegex.FindAllString(line, -1)
                for _, url := range matches {
                        // Ensure that the URL has not been added already to avoid duplicates
                        if !slices.Contains(productURLs, url) {
                                productURLs = append(productURLs, url)
                        }
                }
        }
        fmt.Printf("%d product page URLs found\n", len(productURLs))

        // Export the product page URLs to a new file
        fmt.Println("\nExporting filtered product page URLs...")
        outputFile := "product_urls.txt"
        out, _ := os.Create(outputFile)
        defer out.Close()

        writer := bufio.NewWriter(out)
        for _, url := range productURLs {
                _, _ = writer.WriteString(url + "\n")
        }
        writer.Flush()
        fmt.Printf("Product page URLs saved to %s\n", outputFile)
}

Le programme Go automatise l’exploration du web en utilisant :

os.RemoveAll() pour supprimer le répertoire de sortie(output/) – s’il existe déjà – afin de garantir un démarrage propre.
exec.Command() et cmd.Run() pour construire et exécuter un processus de ligne de commande Gospider afin d’explorer le site web cible.
os.Open() et bufio.NewScanner() pour ouvrir le fichier de sortie généré par Gospider(books_toscrape_com) et le lire ligne par ligne.
regexp.MustCompile() et FindAllString() pour utiliser une expression rationnelle afin d’extraire les URL des pages de produits de chaque ligne, en utilisant slices.Contains() pour éviter les doublons.
os.Create() et bufio.NewWriter() pour écrire les URLs des pages produits filtrées dans un fichier product_urls.txt. Étape 5 : Exécution du script de crawling Lancez le script crawler.go à l’aide de la commande suivante :

go run crawler/crawler.go

Le script enregistrera les données suivantes dans le terminal :

Running Gospider...
# Gospider output omitted for brevity...
Gospider finished

Reading the Gospider output file...
1000 product page URLs found

Exporting filtered product page URLs...
Product page URLs saved to product_urls.txt

Le script d’exploration Gospider a trouvé avec succès 1 000 URL de pages de produits. Comme vous pouvez facilement le vérifier sur le site cible, c’est exactement le nombre de pages de produits disponibles :

Le compteur de produits sur le site cible

Ces URL seront stockées dans un fichier product_urls.txt généré dans le dossier de votre projet. Ouvrez ce fichier, et vous verrez :

https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html
# omitted for brevity...
https://books.toscrape.com/catalogue/frankenstein_20/index.html

Félicitations ! Vous venez de construire un script Gospider pour effectuer du crawling web en Go.

[Extra] Ajouter la logique de scraping au crawler Gospider

L’exploration du web n’est généralement qu’une étape d’un projet plus vaste de web scraping. Pour en savoir plus sur la différence entre ces deux pratiques, lisez notre guide sur l’exploration du web et le web scraping.

Pour rendre ce tutoriel plus complet, nous montrerons également comment utiliser les liens explorés pour le web scraping. Le script Go scraping que nous sommes sur le point de construire :

Lire les URL des pages de produits dans le fichier product_urls.txt, qui a été généré précédemment à l’aide de Gospider et d’une logique personnalisée.
Visitez chaque page de produit et récupérez les données relatives au produit.
Exporter les données sur les produits scannés dans un fichier CSV.

Il est temps d’ajouter la logique du web scraping à votre installation Gospider !

Étape 1 : Installer Colly

La bibliothèque utilisée pour le web scraping est Colly, un élégant scraper et crawler framework pour Golang. Si vous n’êtes pas familier avec son API, consultez notre tutoriel sur le web scraping avec Go.

Exécutez la commande suivante pour installer Colly :

go get -u github.com/gocolly/colly/...

Ensuite, créez un fichier scraper.go dans le dossier scraper de votre répertoire de projet. La structure de votre projet devrait maintenant ressembler à ceci :

gospider-project/
├── crawler/
│   └── crawler.go
├── output/
│   └── books_toscrape_com
└── scraper/
    └── scraper.go

Ouvrez scraper.go et importez Colly :

import (
        "bufio"
        "encoding/csv"
        "os"
        "strings"

        "github.com/gocolly/colly"
)

Fantastique ! Suivez les étapes ci-dessous pour utiliser Colly afin d’extraire des données des pages de produits explorées.

Étape 2 : Lire les URL à gratter

Utilisez le code suivant pour récupérer les URL des pages de produits à extraire du fichier filtered_urls.txt, qui a été généré par crawler.go :

// Open the input file with the crawled URLs
file, _ := os.Open("product_urls.txt")
defer file.Close()

// Read page URLs from the input file
var urls []string
scanner := bufio.NewScanner(file)
for scanner.Scan() {
        urls = append(urls, scanner.Text())
}

Pour que l’extrait ci-dessus fonctionne, incluez ces importations au début de votre fichier :

import (
        "bufio"
        "os"
)

Génial ! La tranche urls contiendra toutes les URL des pages de produits prêtes à être scannées.

Étape 3 : Mise en œuvre de la logique d’extraction des données

Avant de mettre en œuvre la logique d’extraction des données, vous devez comprendre la structure du code HTML de la page produit.

Pour ce faire, visitez la page d’un produit dans votre navigateur en mode incognito – afin de garantir une nouvelle session. Ouvrez DevTools et inspectez les éléments de la page, en commençant par le nœud HTML de l’image du produit :

Inspection de l'élément d'image du produit

Examinez ensuite la section relative aux informations sur le produit :

Les éléments d'information sur le produit

Les éléments inspectés peuvent être extraits :

Le titre du produit de la balise <h1>.
Le prix du produit à partir du premier nœud .price_color de la page.
L’évaluation du produit (étoiles) de la classe .star-rating.
L’URL de l’image du produit provenant de l’élément img de #product_gallery.

Compte tenu de ces attributs, définissez la structure Go suivante pour représenter les données extraites :

type Product struct {
        Title    string
        Price    string
        Stars    string
        ImageURL string
}

Étant donné que plusieurs pages de produits seront extraites, définissez une tranche pour stocker les produits extraits :

var products []Product

Pour récupérer les données, commencez par initialiser un collecteur Colly :

c := colly.NewCollector()

Utilisez le rappel OnHTML() dans Colly pour définir la logique de scraping :

c.OnHTML("html", func(e *colly.HTMLElement) {
        // Scraping logic
        title := e.ChildText("h1")
        price := e.DOM.Find(".price_color").First().Text()

        stars := ""
        e.ForEach(".star-rating", func(_ int, el *colly.HTMLElement) {
                class := el.Attr("class")
                if strings.Contains(class, "One") {
                        stars = "1"
                } else if strings.Contains(class, "Two") {
                        stars = "2"
                } else if strings.Contains(class, "Three") {
                        stars = "3"
                } else if strings.Contains(class, "Four") {
                        stars = "4"
                } else if strings.Contains(class, "Five") {
                        stars = "5"
                }
        })

        imageURL := e.ChildAttr("#product_gallery img", "src")
        // Adjust the relative image path
        imageURL = strings.Replace(imageURL, "../../", "https://books.toscrape.com/", 1)

        // Create a new product object with the scraped data
        product := Product{
                Title:    title,
                Price:    price,
                Stars:    stars,
                ImageURL: imageURL,
        }

        // Append the product to the products slice
        products = append(products, product)
})

Notez la structure else if utilisée pour obtenir l’évaluation des étoiles en fonction de l’attribut class de .star-rating. Voyez également comment l’URL relative de l’image est convertie en URL absolue à l’aide de strings.Replace().

Ajouter l’importation obligatoire suivante :

import (
        "strings"
)

Votre Go scraper est maintenant configuré pour extraire les données des produits comme vous le souhaitez !

Étape 4 : Connexion aux pages cibles

Colly est un framework de web scraping basé sur des callbacks avec un cycle de vie spécifique pour les callbacks. Cela signifie que vous pouvez définir la logique de scraping avant de récupérer le HTML, ce qui est une approche inhabituelle mais puissante.

Maintenant que la logique d’extraction des données est en place, demandez à Colly de visiter chaque page de produit :

pageLimit := 50
for _, url := range urls[:pageLimit] {
        c.Visit(url)
}

Remarque: le nombre d’URL a été limité à 50 pour éviter de submerger le site web cible avec un trop grand nombre de requêtes. Dans un script de production, vous pouvez supprimer ou ajuster cette limitation en fonction de vos besoins.

Colly le fera maintenant :

Visitez chaque URL de la liste.
Appliquer le rappel OnHTML() pour extraire les données relatives au produit.
Stocker les données extraites dans la tranche de produits.

C’est incroyable ! Il ne reste plus qu’à exporter les données recueillies dans un format lisible par l’homme, tel que le format CSV.

Étape 5 : Exporter les données extraites

Exportez la tranche de produits vers un fichier CSV en suivant la logique suivante :

outputFile := "products.csv"
csvFile, _ := os.Create(outputFile)
defer csvFile.Close()

// Initialize a new CSV writer
writer := csv.NewWriter(csvFile)
defer writer.Flush()

// Write CSV header
writer.Write([]string{"Title", "Price", "Stars", "Image URL"})

// Write each product's data to the CSV
for _, product := range products {
        writer.Write([]string{product.Title, product.Price, product.Stars, product.ImageURL})
}

L’extrait ci-dessus crée un fichier products.csv et le remplit avec les données extraites.

N’oubliez pas d’importer le paquet CSV de la bibliothèque standard de Go :

import (
       "encoding/csv"
)

Nous y sommes ! Votre projet de crawling et de scraping Gospider est maintenant entièrement mis en œuvre.

Étape n° 6 : Assembler le tout

scraper.go devrait maintenant contenir :

package main

import (
        "bufio"
        "encoding/csv"
        "os"
        "strings"

        "github.com/gocolly/colly"
)

// Define a data type for the data to scrape
type Product struct {
        Title    string
        Price    string
        Stars    string
        ImageURL string
}

func main() {
        // Open the input file with the crawled URLs
        file, _ := os.Open("product_urls.txt")
        defer file.Close()

        // Read page URLs from the input file
        var urls []string
        scanner := bufio.NewScanner(file)
        for scanner.Scan() {
                urls = append(urls, scanner.Text())
        }

        // Create an array where to store the scraped data
        var products []Product

        // Set up Colly collector
        c := colly.NewCollector()

        c.OnHTML("html", func(e *colly.HTMLElement) {
                // Scraping logic
                title := e.ChildText("h1")
                price := e.DOM.Find(".price_color").First().Text()

                stars := ""
                e.ForEach(".star-rating", func(_ int, el *colly.HTMLElement) {
                        class := el.Attr("class")
                        if strings.Contains(class, "One") {
                                stars = "1"
                        } else if strings.Contains(class, "Two") {
                                stars = "2"
                        } else if strings.Contains(class, "Three") {
                                stars = "3"
                        } else if strings.Contains(class, "Four") {
                                stars = "4"
                        } else if strings.Contains(class, "Five") {
                                stars = "5"
                        }
                })

                imageURL := e.ChildAttr("#product_gallery img", "src")
                // Adjust the relative image path
                imageURL = strings.Replace(imageURL, "../../", "https://books.toscrape.com/", 1)

                // Create a new product object with the scraped data
                product := Product{
                        Title:    title,
                        Price:    price,
                        Stars:    stars,
                        ImageURL: imageURL,
                }

                // Append the product to the products slice
                products = append(products, product)
        })

        // Iterate over the first 50 URLs to scrape them all
        pageLimit := 50 // To avoid overwhelming the target server with too many requests
        for _, url := range urls[:pageLimit] {
                c.Visit(url)
        }

        // Export the scraped products to CSV
        outputFile := "products.csv"
        csvFile, _ := os.Create(outputFile)
        defer csvFile.Close()

        // Initialize a new CSV writer
        writer := csv.NewWriter(csvFile)
        defer writer.Flush()

        // Write CSV header
        writer.Write([]string{"Title", "Price", "Stars", "Image URL"})

        // Write each product's data to the CSV
        for _, product := range products {
                writer.Write([]string{product.Title, product.Price, product.Stars, product.ImageURL})
        }
}

Lancez le scraper avec la commande ci-dessous :

go run scraper/scraper.go

L’exécution peut prendre un certain temps, soyez patient. Une fois l’opération terminée, un fichier products.csv apparaîtra dans le dossier du projet. Ouvrez-le et vous verrez les données extraites proprement structurées dans un format tabulaire :

Et voilà ! Gospider pour ramper + Colly pour gratter, c’est un duo gagnant.

Limites de l’approche de Gospider en matière d’exploration du Web

Les principales limites de l’approche de Gospider sont les suivantes :

Interdiction d’IP en raison d’un trop grand nombre de demandes.
Technologies anti-crawling utilisées par les sites web pour bloquer les robots d’indexation.

Voyons comment aborder les deux !

Éviter les interdictions d’IP

La conséquence d’un trop grand nombre de requêtes provenant de la même machine est que votre adresse IP peut être bannie par le serveur cible. Il s’agit d’un problème courant dans l’exploration du web, en particulier lorsqu’elle n’est pas bien configurée ou planifiée de manière éthique.

Par défaut, Gospider respecte le fichier robots.txt pour minimiser ce risque. Cependant, tous les sites web ne disposent pas d’un fichier robots.txt. De plus, même lorsqu’ils en ont un, il se peut qu’il ne spécifie pas de règles de limitation de vitesse valables pour les robots d’indexation.

Pour limiter les bannissements d’IP, vous pouvez essayer d’utiliser les options intégrées --delay, --random-delay, --timeout de Gospider pour ralentir les requêtes. Cependant, trouver la bonne combinaison peut prendre du temps et n’est pas toujours efficace.

Une solution plus efficace consiste à utiliser un proxy tournant, qui garantit que chaque requête de Gospider provient d’une adresse IP différente. Cela empêche le site cible de détecter et de bloquer vos tentatives d’exploration.

Pour utiliser un proxy rotatif avec Gospider, passez l’URL du proxy avec l’option -p (ou --proxy) :

gospider -s "https://example.com" -o output -p "<PROXY_URL>"

Si vous n’avez pas d’URL de proxy rotatif, récupérez-en un gratuitement !

Contourner la technologie anti-crawling

Même avec un proxy rotatif, certains sites web mettent en œuvre des mesures strictes contre le scraping et le crawling. Par exemple, l’exécution de cette commande Gospider sur un site web protégé par Cloudflare :

gospider -s "https://community.cloudflare.com/" -o output

Le résultat sera le suivant :

[url] - [code-403] - https://community.cloudflare.com/

Comme vous pouvez le voir, le serveur cible a répondu par une réponse 403 Forbidden. Cela signifie que le serveur a détecté et bloqué la requête de Gospider, l’empêchant ainsi d’explorer les URL de la page.

Pour éviter ces blocages, vous avez besoin d’une API de déverrouillage web tout-en-un. Ce service peut contourner les systèmes anti-bots et anti-scraping et vous donner accès au code HTML non bloqué de n’importe quelle page web.

Remarque: le Web Unlocker de Bright Data ne se contente pas de relever ces défis, il peut également fonctionner comme un proxy. Ainsi, une fois configuré, vous pouvez l’utiliser comme un proxy classique avec Gospider en utilisant la syntaxe indiquée précédemment.

Conclusion

Dans ce billet, vous avez appris ce qu’est Gospider, ce qu’il offre, et comment l’utiliser pour crawler le web en Go. Vous avez également vu comment le combiner avec Colly pour un tutoriel complet sur le crawling et le scraping.

L’un des plus grands défis du web scraping est le risque d’être bloqué, que ce soit en raison d’interdictions d’IP ou de solutions anti-scraping. Les meilleurs moyens de surmonter ces difficultés consistent à utiliser des proxys web ou une API de scraping telle que Web Unlocker.

L’intégration avec Gospider n’est qu’un des nombreux scénarios pris en charge par les produits et services de Bright Data. Découvrez nos autres outils de scraping web :

API de grattage Web: Points d’extrémité dédiés à l’extraction de données web fraîches et structurées à partir de plus de 100 domaines populaires.
API SERP: API permettant de gérer l’ensemble des opérations de déverrouillage des SERP et d’extraire une page.
Fonctions de scraping: Une interface de scraping complète qui vous permet d’exécuter vos scrapers en tant que fonctions sans serveur.
Navigateur de scraping: Navigateur compatible avec Puppeteer, Selenium et Playwright avec activités de déverrouillage intégrées.

Inscrivez-vous dès maintenant à Bright Data et testez gratuitement nos services de proxy et nos produits de scraping !

Essai gratuit

S’inscrire avec Google

Aucune carte de crédit requise

Comment effectuer du crawling web avec Gospider en 2025