Neste guia, você aprenderá:
- O que é o Gospider e como ele funciona
- Quais recursos ele oferece
- Como usá-lo para rastreamento da Web
- Como integrá-lo ao Colly para raspagem da Web
- Suas principais limitações e como contorná-las
Vamos mergulhar de cabeça!
O que é o Gospider?
O Gospider é uma ferramenta CLI de rastreamento da Web rápida e eficiente, escrita em Go. Ela foi criada para examinar sites e extrair URLs em paralelo, lidando com várias solicitações e domínios ao mesmo tempo. Além disso, ele respeita o robots.txt e pode descobrir links até mesmo em arquivos JavaScript.
O Gospider oferece vários sinalizadores de personalização para controlar a profundidade do rastreamento, os atrasos nas solicitações e muito mais. Ele também oferece suporte à integração de proxy, juntamente com várias outras opções para maior controle sobre o processo de rastreamento.
O que torna o Gospider único para rastreamento na Web?
Para entender melhor por que o Gospider é especial para o rastreamento da Web, vamos explorar seus recursos em detalhes e examinar os sinalizadores compatíveis.
Recursos
Abaixo estão os principais recursos fornecidos pelo Gospider quando se trata de rastreamento da Web:
- Rastreamento rápido da Web: Rastreamento eficiente de sites individuais em alta velocidade.
- Rastreamento paralelo: Rastreia vários sites ao mesmo tempo para uma coleta de dados mais rápida.
- Análise de
sitemap.xml: Manipula automaticamente os arquivos de mapa do site para aprimorar o rastreamento. - Análise
do robots.txt: Está em conformidade com as diretrizesdo robots.txtpara rastreamento ético. - Análise de links JavaScript: Extrai links de arquivos JavaScript.
- Opções de rastreamento personalizáveis: Ajuste a profundidade do rastreamento, a simultaneidade, o atraso, os tempos limite e muito mais com sinalizadores flexíveis.
- Randomização de
agente de usuário: Randomiza entre User-Agents móveis e da Web para obter solicitações mais realistas. Descubra o melhorUser-Agentpara rastreamento na Web. - Personalização de cookies e cabeçalhos: Permite cookies e cabeçalhos HTTP personalizados.
- Localizador de links: Identifica URLs e outros recursos em um site.
- Localizar buckets do AWS S3: Detecta buckets do AWS S3 a partir de fontes de resposta.
- Localizar subdomínios: Descobre subdomínios a partir de fontes de resposta.
- Fontes de terceiros: Extrai URLs de serviços como Wayback Machine, Common Crawl, VirusTotal e Alien Vault.
- Fácil formatação de saída: Gera resultados em formatos que são fáceis de
grepe analisar. - Suporte ao Burp Suite: Integra-se ao Burp Suite para facilitar os testes e o rastreamento.
- Filtragem avançada: Lista negra e lista branca de URLs, incluindo filtragem em nível de domínio.
- Suporte a subdomínios: Inclui subdomínios em rastreamentos do site de destino e de fontes de terceiros.
- Modos de depuração e detalhado: Ativa a depuração e o registro detalhado para facilitar a solução de problemas.
Opções de linha de comando
Este é o aspecto de um comando Gospider genérico:
gospider [flags]Em particular, os sinalizadores suportados são:
-s, --site: Site a ser rastreado.-S, --sites: Lista de sites a serem rastreados.-p, --proxy: URL do proxy.-o, --output: Pasta de saída.-u, --user-agent: Agente de usuário a ser usado (por exemplo,web,mobiou um agente de usuário personalizado).--cookie: Cookie a ser usado (por exemplo,testA=a; testB=b).-H, --header: Cabeçalho(s) a ser(em) usado(s) (você pode repetir o sinalizador várias vezes para vários cabeçalhos).--burp string: Carrega cabeçalhos e cookies de uma solicitação HTTP bruta do Burp Suite.--blacklist: Regex de URL da lista negra.--whitelist: Regex de URL da lista de permissões.--whitelist-domain: Whitelist Domain.-t, --threads: Número de threads a serem executados em paralelo (padrão:1).-c, --concurrent: Máximo de solicitações simultâneas para domínios correspondentes (padrão:5).-d, --depth: Profundidade máxima de recursão para URLs (definida como0para recursão infinita, padrão:1).-k, --delay int: Atraso entre as solicitações (em segundos).-K, --random-delay int: Atraso extra aleatório antes de fazer solicitações (em segundos).-m, --timeout int: Tempo limite da solicitação (em segundos, padrão:10).-B, --base: Desabilita tudo e usa apenas conteúdo HTML.--js: Habilita o localizador de links em arquivos JavaScript (padrão:true).--subs: Inclui subdomínios.--sitemap: Rastreiao sitemap.xml.--robots: Rastreia oarquivo robots.txt(padrão:true).-a, --other-source: Localiza URLs de fontes de terceiros, como Archive.org, CommonCrawl, VirusTotal, AlienVault.-w, --include-subs: Inclui subdomínios rastreados de fontes de terceiros (padrão: somente o domínio principal).-r, --include-other-source: Inclui URLs de fontes de terceiros e ainda os rastreia--debug: Habilita o modo de depuração.--json: Habilita a saída JSON.-v, --verbose: Habilita a saída detalhada.-l, --length: Mostra o comprimento do URL.-L, --filter-length: Filtra URLs por tamanho.-R, --raw: Mostra a saída bruta.-q, --quiet: Suprime toda a saída e mostra apenas os URLs.--no-redirect: Desabilita os redirecionamentos.--version: Verifica a versão.-h, --help: Mostra a ajuda.
Rastreamento da Web com o Gospider: Guia passo a passo
Nesta seção, você aprenderá a usar o Gospider para rastrear links de um site com várias páginas. Especificamente, o site de destino será o Books to Scrape:
O site contém uma lista de produtos distribuídos em 50 páginas. Cada entrada de produto nessas páginas de listagem também tem sua própria página de produto dedicada. As etapas abaixo o guiarão pelo processo de uso do Gospider para recuperar todos esses URLs de páginas de produtos!
Pré-requisitos e configuração do projeto
Antes de começar, verifique se você tem o seguinte:
- Go instalado em seu computador: Se você ainda não tiver instalado o Go, faça o download no site oficial e siga as instruções de instalação.
- Um IDE Go: O Visual Studio Code com a extensão Go é recomendado.
Para verificar se o Go está instalado, execute:
go versionSe o Go estiver instalado corretamente, você verá uma saída semelhante a esta (no Windows):
go version go1.24.1 windows/amd64Excelente! O Go está configurado e pronto para ser usado.
Crie uma nova pasta de projeto e navegue até ela no terminal:
mkdir gospider-project
cd gospider-project Agora, você está pronto para instalar o Gospider e usá-lo para rastrear a Web!
Etapa 1: Instalar o Gospider
Execute o seguinte comando go install para compilar e instalar o Gospider globalmente:
go install github.com/jaeles-project/gospider@latestApós a instalação, verifique se o Gospider está instalado executando:
gospider -hIsso deve imprimir as instruções de uso do Gospider conforme abaixo:
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 gospiderIncrível! O Gospider foi instalado e agora você pode usá-lo para rastrear um ou mais sites.
Etapa 2: rastrear URLs na página de destino
Para rastrear todos os links na página de destino, execute o seguinte comando:
gospider -s "https://books.toscrape.com/" -o output -d 1Este é um detalhamento dos sinalizadores Gospider usados:
-s "https://books.toscrape.com/": Especifica o URL de destino.-o output: Salva os resultados do rastreamento dentro da pastade saída.-d 1: Define a profundidade de rastreamento como1, o que significa que o Gospider só detectará URLs na página atual. Em outras palavras, ele não seguirá os URLs encontrados para descobrir links mais profundos.
O comando acima produzirá a seguinte estrutura:
gospider-project/
└── output/
└── books_toscrape_comAbra o arquivo books_toscrape_com dentro da pasta de saída e você verá um resultado semelhante a este:
[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.jsO arquivo gerado contém diferentes tipos de links detectados:
[url]: As páginas/recursos rastreados.[href]: Todos os links<a href>encontrados na página.[javascript]: URLs para arquivos JavaScript.[linkfinder]: Links extraídos incorporados no código JavaScript.
Etapa nº 3: rastrear todo o site
No resultado acima, você pode ver que o Gospider parou na primeira página de paginação. Ele detectou o link para a segunda página, mas não a visitou.
Você pode verificar isso porque o arquivo books_toscrape_com contém:
[href] - https://books.toscrape.com/catalogue/page-2.htmlA tag [href] indica que o link foi encontrado. Entretanto, como não há nenhuma entrada [url] correspondente com o mesmo URL, o link foi encontrado, mas nunca visitado.
Se você inspecionar a página de destino, verá que o URL acima corresponde à segunda página de paginação:
Para rastrear o site inteiro, você precisa seguir todos os links de paginação. Conforme mostrado na imagem acima, o site de destino contém 50 páginas de produtos (observe o texto “Página 1 de 50”). Defina a profundidade do Gospider como 50 para garantir que ele alcance todas as páginas.
Como isso envolverá o rastreamento de um grande número de páginas, também é uma boa ideia aumentar a taxa de simultaneidade (ou seja, o número de solicitações simultâneas). Por padrão, o Gospider usa um nível de simultaneidade de 5, mas aumentá-lo para 10 acelerará a execução.
O comando final para rastrear todas as páginas de produtos é:
gospider -s "https://books.toscrape.com/" -o output -d 50 -c 10Desta vez, o Gospider levará mais tempo para ser executado e produzirá milhares de URLs. A saída agora conterá entradas como:
[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.htmlO principal detalhe a ser verificado na saída é a presença do URL da última página de paginação:
[url] - [code-200] - https://books.toscrape.com/catalogue/page-50.htmlMaravilhoso! Isso confirma que o Gospider seguiu com êxito todos os links de paginação e rastreou todo o catálogo de produtos conforme planejado.
Etapa 4: Obter somente a página do produto
Em apenas alguns segundos, o Gospider coletou todos os URLs de um site inteiro. Esse poderia ser o fim deste tutorial, mas vamos dar um passo adiante.
E se você quiser extrair apenas URLs de páginas de produtos? Para entender como esses URLs são estruturados, inspecione um elemento de produto na página de destino:
A partir dessa inspeção, você pode observar como os URLs da página do produto seguem esse formato:
https://books.toscrape.com/catalogue/<product_slug>/index.htmlPara filtrar apenas as páginas de produtos dos URLs brutos rastreados, você pode usar um script Go personalizado.
Primeiro, crie um módulo Go no diretório do projeto Gospider:
go mod init crawlerEm seguida, crie uma pasta crawler dentro do diretório do projeto e adicione um arquivo crawler.go a ela. Em seguida, abra a pasta do projeto em seu IDE. Sua estrutura de pastas deve ter a seguinte aparência:
gospider-project/
├── crawler/
│ └── crawler.go
└── output/
└── books_toscrape_comO script crawler.go deve:
- Execute o comando Gospider em um estado limpo.
- Ler todos os URLs do arquivo de saída.
- Filtre apenas URLs de páginas de produtos usando um padrão regex.
- Exporte os URLs de produtos filtrados para um arquivo .txt.
Abaixo está o código Go para atingir o objetivo:
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)
}O programa Go automatiza o rastreamento da Web utilizando:
os.RemoveAll()para excluir o diretório de saída(output/), se ele já existir, para garantir um início limpo.exec.Command()ecmd.Run()para construir e executar um processo de linha de comando do Gospider para rastrear o site de destino.os.Open()ebufio.NewScanner()para abrir o arquivo de saída gerado pelo Gospider(books_toscrape_com) e lê-lo linha por linha.regexp.MustCompile()eFindAllString()para usar uma regex para extrair URLs de páginas de produtos de cada linha – empregandoslices.Contains()para evitar duplicatas.os.Create()ebufio.NewWriter()para gravar os URLs filtrados da página do produto em um arquivoproduct_urls.txt. Etapa 5: Execução do script de rastreamento Inicie o scriptcrawler.gocom o seguinte comando:
go run crawler/crawler.goO script registrará o seguinte no 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.txtO script de rastreamento Gospider encontrou com sucesso 1.000 URLs de páginas de produtos. Como você pode verificar facilmente no site de destino, esse é exatamente o número de páginas de produtos disponíveis:
Esses URLs serão armazenados em um arquivo product_urls.txt gerado na pasta do seu projeto. Abra esse arquivo e você verá:
https://books.toscrape.com/catalogue/a-light-in-the-attic_1000/index.html
# omitted for brevity...
https://books.toscrape.com/catalogue/frankenstein_20/index.htmlParabéns! Você acabou de criar um script Gospider para realizar o rastreamento da Web em Go.
[Extra] Adicionar a lógica de raspagem ao rastreador Gospider
Geralmente, o rastreamento da Web é apenas uma etapa em um projeto maior de raspagem da Web. Saiba mais sobre a diferença entre essas duas práticas lendo nosso guia sobre web crawling vs. web scraping.
Para tornar este tutorial mais completo, também demonstraremos como usar os links rastreados para raspagem da Web. O script de raspagem Go que estamos prestes a criar irá:
- Leia os URLs da página do produto no arquivo
product_urls.txt, que foi gerado anteriormente usando o Gospider e a lógica personalizada. - Visite cada página de produto e extraia os dados do produto.
- Exporte os dados do produto extraído para um arquivo CSV.
É hora de adicionar a lógica de raspagem da Web à sua configuração do Gospider!
Etapa 1: Instalar o Colly
A biblioteca usada para raspagem da Web é a Colly, uma elegante estrutura de raspagem e rastreamento para Golang. Se você não estiver familiarizado com sua API, confira nosso tutorial sobre raspagem da Web com Go.
Execute o seguinte comando para instalar o Colly:
go get -u github.com/gocolly/colly/...Em seguida, crie um arquivo scraper.go dentro da pasta scraper no diretório do projeto. A estrutura de seu projeto deve ter a seguinte aparência:
gospider-project/
├── crawler/
│ └── crawler.go
├── output/
│ └── books_toscrape_com
└── scraper/
└── scraper.goAbra o scraper.go e importe o Colly:
import (
"bufio"
"encoding/csv"
"os"
"strings"
"github.com/gocolly/colly"
)Fantástico! Siga as etapas abaixo para usar o Colly para extrair dados das páginas de produtos rastreadas.
Etapa 2: Leia os URLs a serem extraídos
Use o código a seguir para recuperar os URLs das páginas de produtos a serem extraídas do arquivo filtered_urls.txt, que foi gerado pelo 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())
}Para que o snippet acima funcione, inclua essas importações no início do seu arquivo:
import (
"bufio"
"os"
)Excelente! A fatia de urls conterá todos os URLs de páginas de produtos prontos para serem coletados.
Etapa nº 3: implementar a lógica de extração de dados
Antes de implementar a lógica de extração de dados, você deve entender a estrutura do HTML da página do produto.
Para fazer isso, acesse a página de um produto em seu navegador no modo anônimo – para garantir uma nova sessão. Abra o DevTools e inspecione os elementos da página, começando pelo nó HTML da imagem do produto:
Em seguida, inspecione a seção de informações do produto:
Dos elementos inspecionados, você pode extrair:
- O título do produto da tag
<h1>. - O preço do produto do primeiro nó
.price_colorna página. - A classificação do produto (estrelas) da classe
.star-rating. - O URL da imagem do produto do elemento
#product_gallery img.
Com esses atributos, defina a seguinte estrutura Go para representar os dados extraídos:
type Product struct {
Title string
Price string
Stars string
ImageURL string
}Como várias páginas de produtos serão extraídas, defina uma fatia para armazenar os produtos extraídos:
var products []ProductPara extrair os dados, comece inicializando um Colly Collector:
c := colly.NewCollector()Use o retorno de chamada OnHTML() no Colly para definir a lógica de raspagem:
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)
})Observe a estrutura else if usada para obter a classificação por estrelas com base no atributo class de .star-rating. Além disso, veja como o URL relativo da imagem é convertido em um URL absoluto usando strings.Replace().
Adicione a seguinte importação obrigatória:
import (
"strings"
)Agora seu Go scraper está configurado para extrair dados de produtos conforme desejado!
Etapa nº 4: Conecte-se às páginas de destino
O Colly é uma estrutura de raspagem da Web baseada em callback com um ciclo de vida de callback específico. Isso significa que você pode definir a lógica de raspagem antes de recuperar o HTML, o que é uma abordagem incomum, mas poderosa.
Agora que a lógica de extração de dados está implementada, instrua Colly a visitar cada página de produto:
pageLimit := 50
for _, url := range urls[:pageLimit] {
c.Visit(url)
}Observação: o número de URLs foi limitado a 50 para evitar sobrecarregar o site de destino com muitas solicitações. Em um script de produção, você pode remover ou ajustar essa limitação de acordo com suas necessidades.
O Colly irá agora:
- Visite cada URL da lista.
- Aplique a chamada de retorno
OnHTML()para extrair os dados do produto. - Armazene os dados extraídos na fatia de
produtos.
Incrível! Tudo o que resta é exportar os dados extraídos para um formato legível por humanos, como CSV.
Etapa 5: Exportar os dados extraídos
Exporte a fatia de produtos para um arquivo CSV usando a seguinte lógica:
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})
}O snippet acima cria um arquivo products.csv e o preenche com os dados extraídos.
Não se esqueça de importar o pacote CSV da biblioteca padrão do Go:
import (
"encoding/csv"
)É isso aí! Seu projeto de rastreamento e raspagem do Gospider agora está totalmente implementado.
Etapa nº 6: Juntar tudo
O scraper.go agora deve conter:
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})
}
}Inicie o raspador com o comando abaixo:
go run scraper/scraper.goA execução pode levar algum tempo, portanto, seja paciente. Após a conclusão, um arquivo products.csv aparecerá na pasta do projeto. Abra-o e você verá os dados extraídos estruturados de forma organizada em um formato tabular:
E pronto! Gospider para engatinhar + Colly para raspar é uma dupla vencedora.
Limitações da abordagem do Gospider para rastreamento na Web
As maiores limitações da abordagem de rastreamento do Gospider são:
- Banimentos de IP devido ao excesso de solicitações.
- Tecnologias antirrastreamento usadas por sites para bloquear bots de rastreamento.
Vamos ver como lidar com ambos!
Evite proibições de IP
A consequência do excesso de solicitações do mesmo computador é que seu endereço IP pode ser banido pelo servidor de destino. Esse é um problema comum no rastreamento da Web, especialmente quando não é bem configurado ou planejado de forma ética.
Por padrão, o Gospider respeita o arquivo robots.txt para minimizar esse risco. No entanto, nem todos os sites têm um arquivo robots.txt. Além disso, mesmo quando têm, ele pode não especificar regras válidas de limitação de taxa para os rastreadores.
Para limitar as proibições de IP, você pode tentar usar os sinalizadores integrados do Gospider --delay, --random-delay, --timeout para reduzir a velocidade das solicitações. Ainda assim, encontrar a combinação certa pode consumir muito tempo e nem sempre ser eficaz.
Uma solução mais eficaz é usar um proxy rotativo, que garante que cada solicitação do Gospider seja originada de um endereço IP diferente. Isso evita que o site de destino detecte e bloqueie suas tentativas de rastreamento.
Para usar um proxy rotativo com o Gospider, passe o URL do proxy com o sinalizador -p (ou --proxy):
gospider -s "https://example.com" -o output -p "<PROXY_URL>"Se você não tiver um URL de proxy rotativo, obtenha um gratuitamente!
Contornar a tecnologia de rastreamento
Mesmo com um proxy rotativo, alguns sites implementam medidas rigorosas contra raspagem e rastreamento. Por exemplo, a execução deste comando Gospider em um site protegido pelo Cloudflare:
gospider -s "https://community.cloudflare.com/" -o outputO resultado será:
[url] - [code-403] - https://community.cloudflare.com/Como você pode ver, o servidor de destino respondeu com uma resposta 403 Forbidden. Isso significa que o servidor detectou e bloqueou com êxito a solicitação do Gospider, impedindo-o de rastrear qualquer URL na página.
Para evitar esses bloqueios, você precisa de uma API de desbloqueio da Web completa. Esse serviço pode contornar sistemas anti-bot e anti-raspagem, dando-lhe acesso ao HTML desbloqueado de qualquer página da Web.
Observação: o Web Unlocker da Bright Data não só lida com esses desafios, mas também pode operar como um proxy. Portanto, uma vez configurado, você pode usá-lo como um proxy comum com o Gospider usando a sintaxe mostrada anteriormente.
Conclusão
Nesta postagem do blog, você aprendeu o que é o Gospider, o que ele oferece e como usá-lo para rastreamento da Web em Go. Você também viu como combiná-lo com o Colly para obter um tutorial completo de rastreamento e raspagem.
Um dos maiores desafios da raspagem da Web é o risco de ser bloqueado, seja devido a proibições de IP ou a soluções antirraspagem. As melhores maneiras de superar esses desafios são usar proxies da Web ou uma API de raspagem como o Web Unlocker.
A integração com o Gospider é apenas um dos muitos cenários suportados pelos produtos e serviços da Bright Data. Explore nossas outras ferramentas de raspagem da web:
- APIs do Web Scraper: Pontos de extremidade dedicados para extrair dados da Web novos e estruturados de mais de 100 domínios populares.
- API SERP: API para lidar com todo o gerenciamento de desbloqueio contínuo para SERP e extrair uma página.
- Funções de raspagem: Uma interface de raspagem completa que permite que você execute seus raspadores como funções sem servidor.
- Navegador de raspagem: Navegador compatível com Puppeteer, Selenium e Playwright com atividades de desbloqueio integradas
Inscreva-se agora na Bright Data e teste nossos serviços de proxy e produtos de raspagem gratuitamente!
Não é necessário cartão de crédito
