In diesem Leitfaden erfahren Sie mehr:
- Was Gospider ist und wie es funktioniert
- Welche Funktionen bietet es?
- Wie man es für das Web-Crawling verwendet
- Integration mit Colly für Web Scraping
- Die wichtigsten Einschränkungen und wie sie umgangen werden können
Lasst uns eintauchen!
Was ist Gospider?
Gospider ist ein schnelles und effizientes Web-Crawling-CLI-Tool, das in Go geschrieben wurde. Es wurde entwickelt, um Websites zu scannen und URLs parallel zu extrahieren, wobei es mehrere Anfragen und Domänen gleichzeitig verarbeitet. Außerdem respektiert es robots.txt und kann sogar Links in JavaScript-Dateien entdecken.
Gospider bietet mehrere Anpassungsflags zur Steuerung von Crawling-Tiefe, Anfrageverzögerungen und mehr. Es unterstützt auch Proxy-Integration, zusammen mit verschiedenen anderen Optionen für mehr Kontrolle über den Crawling-Prozess.
Was macht Gospider für das Web Crawling so einzigartig?
Um besser zu verstehen, warum Gospider für das Web-Crawling besonders geeignet ist, wollen wir seine Funktionen im Detail erkunden und die unterstützten Flaggen untersuchen.
Eigenschaften
Im Folgenden finden Sie die wichtigsten Funktionen von Gospider, wenn es um Web-Crawling geht:
- Schnelles Web-Crawling: Effizientes Crawlen einzelner Websites mit hoher Geschwindigkeit.
- Paralleles Crawling: Durchsucht mehrere Websites gleichzeitig, um die Datenerfassung zu beschleunigen.
sitemap.xml-Parsing: Automatische Verarbeitung von Sitemap-Dateien für verbessertes Crawling.robots.txt-Analyse: Entspricht denrobots.txt-Richtlinienfür ethisches Crawling.- JavaScript-Link-Parsing: Extrahiert Links aus JavaScript-Dateien.
- Anpassbare Crawl-Optionen: Passen Sie Crawl-Tiefe, Gleichzeitigkeit, Verzögerung, Timeouts und mehr mit flexiblen Flags an.
- Randomisierung der
Benutzer-Agenten: Randomisiert zwischen mobilen und Web-Benutzer-Agenten für realistischere Anfragen. Entdecken Sie den bestenUser-Agentfür Web-Crawling. - Anpassung von Cookies und Headern: Erlaubt benutzerdefinierte Cookies und HTTP-Header.
- Link-Finder: Identifiziert URLs und andere Ressourcen auf einer Website.
- Findet AWS S3-Buckets: Erkennt AWS S3-Buckets aus Antwortquellen.
- Subdomains finden: Entdeckt Subdomains aus Antwortquellen.
- Quellen von Drittanbietern: Extrahiert URLs aus Diensten wie der Wayback Machine, Common Crawl, VirusTotal und Alien Vault.
- Einfache Formatierung der Ausgabe: Die Ergebnisse werden in Formaten ausgegeben, die leicht zu
durchsuchenund zu analysieren sind. - Unterstützung der Burp Suite: Integriert mit Burp Suite für einfachere Tests und Crawling.
- Erweiterte Filterung: Blacklists und Whitelists für URLs, einschließlich Filterung auf Domänenebene.
- Unterstützung von Subdomains: Bezieht Subdomains in Crawls sowohl von der Zielseite als auch von Drittquellen ein.
- Debug- und Verbose-Modus: Ermöglicht Debugging und detaillierte Protokollierung zur einfacheren Fehlersuche.
Kommandozeilen-Optionen
So sieht ein allgemeiner Gospider-Befehl aus:
gospider [flags]Insbesondere werden folgende Flaggen unterstützt:
-s, --site: Zu crawlende Seite.-S, --Seiten: Liste der zu crawlenden Websites.-p, --proxy: Proxy-URL.-o, --output: Ausgabeordner.-u, -- Benutzer-Agent: Zu verwendender Benutzer-Agent (z. B.Web,Mobioder ein benutzerdefinierter Benutzer-Agent).--cookie: Zu verwendendes Cookie (z. B.testA=a; testB=b).-H, --header: Zu verwendende Kopfzeile(n) (für mehrere Kopfzeilen wiederholen Sie das Flag mehrmals).--Burp-Zeichenfolge: Lädt Header und Cookies aus einer rohen HTTP-Anfrage der Burp Suite.--Schwarzliste: Schwarze Liste URL Regex.--Whitelist: Whitelist URL Regex.--whitelist-domain: Whitelist-Domäne.-t, --threads: Anzahl der parallel zu verarbeitenden Threads (Standard:1).-c, --concurrent: Maximale Anzahl gleichzeitiger Anfragen für übereinstimmende Domänen (Standard:5).-d, --depth: Maximale Rekursionstiefe für URLs (auf0gesetzt für unendliche Rekursion, Standard:1).-k, --delay int: Verzögerung zwischen Anfragen (in Sekunden).-K, --random-delay int: Zusätzliche zufällige Verzögerung vor der Ausführung von Anfragen (in Sekunden).-m, --timeout int: Anfrage-Timeout (in Sekunden, Standard:10).-B, --base: Alles deaktivieren und nur HTML-Inhalte verwenden.--js: Aktiviert den Link-Finder in JavaScript-Dateien (Standard:true).--subs: Subdomänen einbeziehen.--sitemap: Crawlsitemap.xml.--robots: Crawlen derrobots.txt(Standard:true).-a, --other-source: Findet URLs von Drittanbieter-Quellen wie Archive.org, CommonCrawl, VirusTotal, AlienVault.-w, --include-subs: Schließt Subdomains ein, die von Drittquellen gecrawlt wurden (Standard: nur Hauptdomain).-r, --include-other-source: URLs von Drittanbieter-Quellen einbeziehen und trotzdem crawlen--debug: Aktiviert den Debug-Modus.--json: Aktiviert die JSON-Ausgabe.-v, --verbose: Aktiviert die ausführliche Ausgabe.-l, --length: Anzeige der URL-Länge.-L, --filter-length: URLs nach Länge filtern.-R, --raw: Anzeige der Rohausgabe.-q, --quiet: Alle Ausgaben unterdrücken und nur URLs anzeigen.--no-redirect: Deaktiviert Umleitungen.--version: Version prüfen.-h, --help: Hilfe anzeigen.
Web Crawling mit Gospider: Schritt-für-Schritt-Anleitung
In diesem Abschnitt lernen Sie, wie Sie Gospider verwenden, um Links von einer mehrseitigen Website zu crawlen. Die Zielsite wird Books to Scrape sein:
Die Website enthält ein Produktverzeichnis, das sich über 50 Seiten erstreckt. Jeder Produkteintrag auf diesen Listenseiten hat auch eine eigene Produktseite. Die folgenden Schritte führen Sie durch den Prozess der Verwendung von Gospider, um all diese Produktseiten-URLs abzurufen!
Voraussetzungen und Projekteinrichtung
Bevor Sie beginnen, vergewissern Sie sich, dass Sie die folgenden Informationen haben:
- Go auf Ihrem Computer installiert: Wenn Sie Go noch nicht installiert haben, laden Sie es von der offiziellen Website herunter und folgen Sie den Installationsanweisungen.
- Eine Go-IDE: Visual Studio Code mit der Go-Erweiterung wird empfohlen.
Um zu überprüfen, ob Go installiert ist, führen Sie aus:
go versionWenn Go korrekt installiert ist, sollten Sie eine ähnliche Ausgabe wie diese sehen (unter Windows):
go version go1.24.1 windows/amd64Super! Go ist eingerichtet und einsatzbereit.
Erstellen Sie einen neuen Projektordner und navigieren Sie im Terminal zu diesem Ordner:
mkdir gospider-project
cd gospider-project Jetzt sind Sie bereit, Gospider zu installieren und für das Web-Crawling zu verwenden!
Schritt #1: Gospider installieren
Führen Sie den folgenden go install-Befehl aus, um Gospider zu kompilieren und global zu installieren:
go install github.com/jaeles-project/gospider@latestÜberprüfen Sie nach der Installation, ob Gospider installiert ist, indem Sie es ausführen:
gospider -hDies sollte die Gospider-Benutzungsanweisungen wie unten angegeben ausdrucken:
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 gospiderErstaunlich! Gospider wurde installiert, und Sie können nun eine oder mehrere Websites crawlen.
Schritt #2: Crawlen von URLs auf der Zielseite
Um alle Links auf der Zielseite zu crawlen, führen Sie den folgenden Befehl aus:
gospider -s "https://books.toscrape.com/" -o output -d 1Dies ist eine Aufschlüsselung der verwendeten Gospider-Flags:
-s "https://books.toscrape.com/": Gibt die Ziel-URL an.-o Ausgabe: Speichert die Crawl-Ergebnisse imAusgabeordner.-d 1: Setzt die Crawling-Tiefe auf1, was bedeutet, dass Gospider nur URLs auf der aktuellen Seite findet. Mit anderen Worten, es wird den gefundenen URLs nicht folgen, um tiefere Links zu entdecken.
Der obige Befehl erzeugt die folgende Struktur:
gospider-project/
└── output/
└── books_toscrape_comÖffnen Sie die Datei books_toscrape_com im Ausgabeordner, und Sie werden eine Ausgabe ähnlich der folgenden sehen:
[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.jsDie erzeugte Datei enthält verschiedene Arten von erkannten Links:
[url]: Die gecrawlten Seiten/Ressourcen.[href]: Alle<a href>-Links, die auf der Seite gefunden werden.[javascript]: URLs zu JavaScript-Dateien.[linkfinder]: Extrahierte Links, die in JavaScript-Code eingebettet sind.
Schritt #3: Crawlen der gesamten Website
Aus der obigen Ausgabe können Sie ersehen, dass Gospider bei der ersten Paginierungsseite angehalten hat. Der Link zur zweiten Seite wurde zwar erkannt, aber nicht aufgerufen.
Sie können dies überprüfen, weil die Datei books_toscrape_com enthält:
[href] - https://books.toscrape.com/catalogue/page-2.htmlDer [href] -Tag zeigt an, dass der Link gefunden wurde. Da es jedoch keinen entsprechenden [url]-Eintrag mit der gleichen URL gibt, wurde der Link zwar gefunden, aber nie besucht.
Wenn Sie sich die Zielseite ansehen, werden Sie feststellen, dass die obige URL der zweiten Paginierungsseite entspricht:
Um die gesamte Website zu crawlen, müssen Sie allen Seitenverknüpfungen folgen. Wie in der Abbildung oben zu sehen ist, enthält die Zielsite 50 Produktseiten (beachten Sie den Text “Seite 1 von 50”). Stellen Sie die Tiefe von Gospider auf 50 ein, um sicherzustellen, dass er jede Seite erreicht.
Da dabei eine große Anzahl von Seiten gecrawlt wird, ist es auch eine gute Idee, die Gleichzeitigkeitsrate (d.h. die Anzahl der gleichzeitigen Anfragen) zu erhöhen. Standardmäßig verwendet Gospider einen Gleichzeitigkeitsgrad von 5, aber eine Erhöhung auf 10 beschleunigt die Ausführung.
Der letzte Befehl zum Durchsuchen aller Produktseiten lautet:
gospider -s "https://books.toscrape.com/" -o output -d 50 -c 10Diesmal braucht Gospider länger für die Ausführung und produziert Tausende von URLs. Die Ausgabe enthält nun Einträge wie:
[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.htmlDas wichtigste Detail, das in der Ausgabe zu überprüfen ist, ist das Vorhandensein der URL der letzten Paginierungsseite:
[url] - [code-200] - https://books.toscrape.com/catalogue/page-50.htmlWunderbar! Dies bestätigt, dass Gospider erfolgreich allen Paginierungslinks gefolgt ist und den gesamten Produktkatalog wie vorgesehen gecrawlt hat.
Schritt #4: Erhalten Sie nur die Produktseite
In nur wenigen Sekunden hat Gospider alle URLs einer ganzen Website gesammelt. Das könnte das Ende dieses Tutorials sein, aber lassen Sie uns noch einen Schritt weiter gehen.
Was ist, wenn Sie nur die URLs von Produktseiten extrahieren möchten? Um zu verstehen, wie diese URLs strukturiert sind, untersuchen Sie ein Produktelement auf der Zielseite:
Bei dieser Prüfung können Sie feststellen, dass die URLs der Produktseiten diesem Format folgen:
https://books.toscrape.com/catalogue/<product_slug>/index.htmlUm nur Produktseiten aus den gecrawlten Roh-URLs herauszufiltern, können Sie ein benutzerdefiniertes Go-Skript verwenden.
Erstellen Sie zunächst ein Go-Modul in Ihrem Gospider-Projektverzeichnis:
go mod init crawlerAls Nächstes erstellen Sie einen Crawler-Ordner innerhalb des Projektverzeichnisses und fügen diesem eine crawler.go-Datei hinzu. Öffnen Sie dann den Projektordner in Ihrer IDE. Ihre Ordnerstruktur sollte nun wie folgt aussehen:
gospider-project/
├── crawler/
│ └── crawler.go
└── output/
└── books_toscrape_comDas Skript crawler.go sollte:
- Führen Sie den Befehl Gospider in einem sauberen Zustand aus.
- Liest alle URLs aus der Ausgabedatei.
- Filtern Sie nur URLs von Produktseiten anhand eines Regex-Musters.
- Exportieren Sie die gefilterten Produkt-URLs in eine .txt-Datei.
Nachfolgend finden Sie den Go-Code zum Erreichen dieses Ziels:
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)
}Das Go-Programm automatisiert das Crawling von Webseiten durch den Einsatz von:
os.RemoveAll(), um das Ausgabeverzeichnis(output/) zu löschen, falls es bereits existiert, um einen sauberen Start zu gewährleisten.exec.Command()undcmd.Run(), um einen Gospider-Befehlszeilenprozess zu erstellen und auszuführen, um die Zielwebsite zu crawlen.os.Open()undbufio.NewScanner(), um die von Gospider erzeugte Ausgabedatei(books_toscrape_com) zu öffnen und Zeile für Zeile zu lesen.regexp.MustCompile()undFindAllString(), um einen Regex zu verwenden, um die URLs der Produktseiten aus jeder Zeile zu extrahieren – mitslices.Contains(), um Duplikate zu verhindern.os.Create()undbufio.NewWriter(), um die gefilterten Produktseiten-URLs in eine Dateiproduct_urls.txtzu schreiben. Schritt #5: Ausführung des Crawling-Skripts Starten Sie das Skriptcrawler.gomit dem folgenden Befehl:
go run crawler/crawler.goDas Skript protokolliert folgendes im 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.txtDas Crawling-Skript von Gospider hat erfolgreich 1.000 Produktseiten-URLs gefunden. Wie Sie auf der Zielseite leicht überprüfen können, ist das genau die Anzahl der verfügbaren Produktseiten:
Diese URLs werden in einer Datei product_urls.txt gespeichert, die in Ihrem Projektordner erstellt wird. Öffnen Sie diese Datei, und Sie werden sehen:
https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html
# omitted for brevity...
https://books.toscrape.com/catalogue/frankenstein_20/index.htmlHerzlichen Glückwunsch! Sie haben soeben ein Gospider-Skript erstellt, um Web-Crawling in Go durchzuführen.
[Extra] Hinzufügen der Scraping-Logik zum Gospider Crawler
Web Crawling ist in der Regel nur ein Schritt in einem größeren Web Scraping-Projekt. Erfahren Sie mehr über den Unterschied zwischen diesen beiden Praktiken, indem Sie unseren Leitfaden zu Web Crawling vs. Web Scraping lesen.
Um dieses Tutorial zu vervollständigen, werden wir auch zeigen, wie man die gecrawlten Links für Web Scraping verwendet. Das Go-Scraping-Skript, das wir erstellen werden, wird:
- Lesen Sie die URLs der Produktseiten aus der Datei
product_urls.txt, die zuvor mit Gospider und benutzerdefinierter Logik erstellt wurde. - Besuchen Sie jede Produktseite und scrapen Sie Produktdaten.
- Exportieren Sie die gescrapten Produktdaten in eine CSV-Datei.
Es ist an der Zeit, Ihr Gospider-Setup um eine Web-Scraping-Logik zu erweitern!
Schritt 1: Colly installieren
Die für das Web Scraping verwendete Bibliothek ist Colly, ein elegantes Scraper- und Crawler-Framework für Golang. Wenn Sie mit seiner API nicht vertraut sind, lesen Sie unser Tutorial über Web Scraping mit Go.
Führen Sie den folgenden Befehl aus, um Colly zu installieren:
go get -u github.com/gocolly/colly/...Als nächstes erstellen Sie eine scraper.go-Datei im scraper-Ordner in Ihrem Projektverzeichnis. Ihre Projektstruktur sollte nun wie folgt aussehen:
gospider-project/
├── crawler/
│ └── crawler.go
├── output/
│ └── books_toscrape_com
└── scraper/
└── scraper.goÖffnen Sie scraper.go und importieren Sie Colly:
import (
"bufio"
"encoding/csv"
"os"
"strings"
"github.com/gocolly/colly"
)Fantastisch! Führen Sie die folgenden Schritte aus, um Colly für das Scraping von Daten aus den gecrawlten Produktseiten zu verwenden.
Schritt #2: Lesen Sie die URLs zum Scrapen
Verwenden Sie den folgenden Code, um die URLs der zu scrappenden Produktseiten aus der Datei filtered_urls.txt abzurufen, die von crawler.go erzeugt wurde:
// 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())
}Damit das obige Snippet funktioniert, fügen Sie diese Importe am Anfang Ihrer Datei ein:
import (
"bufio"
"os"
)Großartig! Das URL-Slice enthält alle URLs der Produktseiten, die zum Scrapen bereit sind.
Schritt Nr. 3: Implementierung der Datenextraktionslogik
Bevor Sie die Datenextraktionslogik implementieren, müssen Sie die Struktur des HTML der Produktseite verstehen.
Besuchen Sie dazu eine Produktseite in Ihrem Browser im Inkognito-Modus, um eine neue Sitzung zu gewährleisten. Öffnen Sie DevTools und untersuchen Sie die Seitenelemente, beginnend mit dem HTML-Knoten für das Produktbild:
Als Nächstes sollten Sie sich die Produktinformation ansehen:
Aus den untersuchten Elementen können Sie einen Auszug erstellen:
- Der Produkttitel aus dem
<h1>-Tag. - Der Produktpreis aus dem ersten
.price_color-Knotenauf der Seite. - Die Produktbewertung (Sterne) aus der Klasse
.star-rating. - Die URL des Produktbildes aus dem Element
#product_gallery img.
Definieren Sie angesichts dieser Attribute die folgende Go-Struktur, um die ausgewerteten Daten darzustellen:
type Product struct {
Title string
Price string
Stars string
ImageURL string
}Da mehrere Produktseiten abgefragt werden, definieren Sie ein Slice, um die extrahierten Produkte zu speichern:
var products []ProductUm die Daten abzurufen, beginnen Sie mit der Initialisierung eines Colly Collectors:
c := colly.NewCollector()Verwenden Sie den OnHTML() -Callback in Colly, um die Scraping-Logik zu definieren:
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)
})Beachten Sie die if-Struktur, die verwendet wird, um die Sternebewertung auf der Grundlage des Attributs class von .star-rating zu erhalten. Sehen Sie auch, wie die relative Bild-URL mit strings.Replace() in eine absolute URL umgewandelt wird.
Fügen Sie den folgenden erforderlichen Import hinzu:
import (
"strings"
)Jetzt ist Ihr Go Scraper so eingerichtet, dass er Produktdaten wie gewünscht extrahieren kann!
Schritt #4: Verbinden Sie sich mit den Zielseiten
Colly ist ein Callback-basiertes Web Scraping Framework mit einem spezifischen Callback-Lebenszyklus. Das bedeutet, dass Sie die Scraping-Logik definieren können, bevor Sie das HTML abrufen, was ein ungewöhnlicher, aber leistungsstarker Ansatz ist.
Nachdem die Datenextraktionslogik nun steht, weisen Sie Colly an, jede Produktseite zu besuchen:
pageLimit := 50
for _, url := range urls[:pageLimit] {
c.Visit(url)
}Hinweis: Die Anzahl der URLs wurde auf 50 begrenzt, um die Ziel-Website nicht mit zu vielen Anfragen zu überlasten. In einem Produktionsskript können Sie diese Begrenzung je nach Bedarf aufheben oder anpassen.
Colly wird jetzt:
- Besuchen Sie jede URL in der Liste.
- Wenden Sie den
OnHTML()-Callback an, um Produktdaten zu extrahieren. - Speichern Sie die extrahierten Daten in der
Produkte-Slice.
Erstaunlich! Jetzt müssen die gesammelten Daten nur noch in ein für Menschen lesbares Format wie CSV exportiert werden.
Schritt #5: Exportieren Sie die gescrapten Daten
Exportieren Sie die Produktscheibe nach der folgenden Logik in eine CSV-Datei:
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})
}Das obige Snippet erstellt eine Datei products.csv und füllt sie mit den ausgewerteten Daten.
Vergessen Sie nicht, das CSV-Paket aus der Standardbibliothek von Go zu importieren:
import (
"encoding/csv"
)Das war’s! Ihr Gospider Crawling- und Scraping-Projekt ist nun vollständig implementiert.
Schritt #6: Alles zusammenfügen
scraper.go sollte nun enthalten:
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})
}
}Starten Sie den Scraper mit dem unten stehenden Befehl:
go run scraper/scraper.goDie Ausführung kann einige Zeit dauern, haben Sie also etwas Geduld. Sobald der Vorgang abgeschlossen ist, wird im Projektordner eine Datei products.csv angezeigt. Wenn Sie sie öffnen, sehen Sie die gescrapten Daten übersichtlich in einem Tabellenformat:
Et voilà! Gospider für das Krabbeln und Colly für das Kratzen sind ein Erfolgsduo.
Grenzen des Gospider-Ansatzes beim Web Crawling
Die größten Einschränkungen des Crawling-Ansatzes von Gospider sind:
- IP-Sperren aufgrund von zu vielen Anfragen.
- Anti-Crawling-Technologien, die von Websites verwendet werden, um Crawling-Bots zu blockieren.
Mal sehen, wie man beides in Angriff nimmt!
IP-Sperren vermeiden
Zu viele Anfragen vom selben Rechner haben zur Folge, dass Ihre IP-Adresse vom Zielserver gesperrt werden kann. Dies ist ein häufiges Problem beim Web-Crawling, insbesondere wenn es nicht gut konfiguriert oder ethisch geplant ist.
Standardmäßig respektiert Gospider die Datei robots.txt, um dieses Risiko zu minimieren. Allerdings haben nicht alle Websites eine robots.txt-Datei. Und selbst wenn sie eine haben, kann es sein, dass sie keine gültigen Regeln zur Ratenbegrenzung für Crawler enthält.
Um IP-Sperren einzuschränken, können Sie versuchen, die in Gospider eingebauten Flags --delay, --random-delay, --timeout zu verwenden, um Anfragen zu verlangsamen. Die richtige Kombination zu finden, kann jedoch zeitaufwändig sein und ist nicht immer effektiv.
Eine effektivere Lösung ist die Verwendung eines rotierenden Proxys, der garantiert, dass jede Anfrage von Gospider von einer anderen IP-Adresse ausgeht. Dadurch wird verhindert, dass die Zielseite Ihre Crawling-Versuche erkennt und blockiert.
Um einen rotierenden Proxy mit Gospider zu verwenden, übergeben Sie die Proxy-URL mit dem Flag -p (oder --proxy):
gospider -s "https://example.com" -o output -p "<PROXY_URL>"Wenn Sie keine rotierende Proxy-URL haben, können Sie kostenlos eine abrufen!
Umgehung der Anti-Crawling-Technik
Selbst mit einem rotierenden Proxy setzen einige Websites strenge Anti-Scraping- und Anti-Crawling-Maßnahmen ein. Führen Sie zum Beispiel diesen Gospider-Befehl gegen eine Cloudflare-geschützte Website aus:
gospider -s "https://community.cloudflare.com/" -o outputDas Ergebnis wird sein:
[url] - [code-403] - https://community.cloudflare.com/Wie Sie sehen können, hat der Zielserver mit einer 403 Forbidden-Antwort geantwortet. Das bedeutet, dass der Server die Anfrage von Gospider erfolgreich erkannt und blockiert hat, so dass er keine URLs auf der Seite crawlen kann.
Um solche Sperren zu vermeiden, benötigen Sie eine All-in-One-API zur Freigabe von Webseiten. Dieser Dienst kann Anti-Bot- und Anti-Scraping-Systeme umgehen und gibt Ihnen Zugriff auf den nicht gesperrten HTML-Code einer beliebigen Webseite.
Hinweis: Der Web Unlocker von Bright Data bewältigt nicht nur diese Herausforderungen, sondern kann auch als Proxy fungieren. Sobald er konfiguriert ist, können Sie ihn wie einen normalen Proxy mit Gospider verwenden, indem Sie die oben gezeigte Syntax verwenden.
Schlussfolgerung
In diesem Blog-Beitrag haben Sie gelernt, was Gospider ist, was es bietet und wie man es für das Web-Crawling in Go verwendet. Sie haben auch gesehen, wie Sie es mit Colly kombinieren können, um ein komplettes Crawling- und Scraping-Tutorial zu erhalten.
Eine der größten Herausforderungen beim Web-Scraping ist das Risiko, blockiert zu werden – sei es aufgrund von IP-Sperren oder Anti-Scraping-Lösungen. Die besten Möglichkeiten zur Überwindung dieser Herausforderungen sind die Verwendung von Web-Proxys oder einer Scraping-API wie Web Unlocker.
Die Integration mit Gospider ist nur eines der vielen Szenarien, die die Produkte und Services von Bright Data unterstützen. Entdecken Sie unsere anderen Web-Scraping-Tools:
- Web Scraper APIs: Spezielle Endpunkte zum Extrahieren von frischen, strukturierten Webdaten aus über 100 beliebten Domains.
- SERP-API: API für die Verwaltung aller laufenden Freischaltungen für SERP und Extraktion einer Seite.
- Scraping-Funktionen: Eine vollständige Scraping-Schnittstelle, mit der Sie Ihre Scraper als serverlose Funktionen ausführen können.
- Scraping-Browser: Puppeteer-, Selenium- und Playwright-kompatibler Browser mit integrierten Freischaltaktivitäten
Melden Sie sich jetzt bei Bright Data an und testen Sie unsere Proxy-Dienste und Scraping-Produkte kostenlos!
Keine Kreditkarte erforderlich
