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 du
fichier sitemap.xml
: Traite automatiquement les fichiers sitemap pour améliorer l’exploration. - analyse
robots.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 meilleurUser-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 lefichier sitemap.xml
.--robots
: Effectue l’exploration dufichier 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 desortie
.-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 :
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()
etcmd.Run()
pour construire et exécuter un processus de ligne de commande Gospider afin d’explorer le site web cible.os.Open()
etbufio.NewScanner()
pour ouvrir le fichier de sortie généré par Gospider(books_toscrape_com)
et le lire ligne par ligne.regexp.MustCompile()
etFindAllString()
pour utiliser une expression rationnelle afin d’extraire les URL des pages de produits de chaque ligne, en utilisantslices.Contains()
pour éviter les doublons.os.Create()
etbufio.NewWriter()
pour écrire les URLs des pages produits filtrées dans un fichierproduct_urls.txt
. Étape 5 : Exécution du script de crawling Lancez le scriptcrawler.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 :
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 :
Examinez ensuite la section relative aux informations 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 !
Aucune carte de crédit requise