Cómo utilizar Gospider para el rastreo y el scraping web

En esta guía aprenderás:

Qué es y cómo funciona Gospider
Qué prestaciones ofrece
Cómo utilizarlo para el rastreo web
Cómo integrarlo con Colly para el web scraping
Sus principales limitaciones y cómo sortearlas

Sumerjámonos.

¿Qué es Gospider?

Gospider es una herramienta CLI de rastreo web rápida y eficiente escrita en Go. Está construida para escanear sitios web y extraer URLs en paralelo, manejando múltiples peticiones y dominios al mismo tiempo. Además, respeta robots.txt y puede descubrir enlaces incluso en archivos JavaScript.

Gospider ofrece varios indicadores de personalización para controlar la profundidad del rastreo, los retrasos de las solicitudes y mucho más. También es compatible con la integración de proxy, junto con varias otras opciones para un mayor control sobre el proceso de rastreo.

¿Qué hace que Gospider sea único en el rastreo web?

Para entender mejor por qué Gospider es especial para el rastreo web, exploremos sus características en detalle y examinemos las banderas compatibles.

Características

A continuación se enumeran las principales funciones que ofrece Gospider en lo que respecta al rastreo web:

Rastreo web rápido: Rastrea eficazmente sitios web individuales a alta velocidad.
Rastreo paralelo: Rastrea varios sitios simultáneamente para obtener datos más rápidamente.
Análisis desitemap.xml: Maneja automáticamente los archivos de mapa del sitio para mejorar el rastreo.
Análisis derobots.txt: Cumple las directivasrobots.txt para un rastreo ético.
Análisis de enlaces JavaScript: Extrae enlaces de archivos JavaScript.
Opciones de rastreo personalizables: Ajuste la profundidad de rastreo, la concurrencia, el retardo, los tiempos de espera y mucho más con indicadores flexibles.
Aleatorizacióndel agente de usuario: Aleatoriza entre User-Agents móviles y web para peticiones más realistas. Descubre el mejor User-Agent para el rastreo web.
Personalización de cookies y cabeceras: Permite personalizar las cookies y las cabeceras HTTP.
Buscador de enlaces: Identifica las URL y otros recursos de un sitio.
Encuentra buckets de AWS S3: Detecta buckets de AWS S3 a partir de fuentes de respuesta.
Buscar subdominios: Descubre subdominios a partir de fuentes de respuesta.
Fuentes de terceros: Extrae URL de servicios como Wayback Machine, Common Crawl, VirusTotal y Alien Vault.
Formato de salida sencillo: Los resultados se muestran en formatos fáciles de codificar y analizar.
Compatibilidad con Burp Suite: Se integra con Burp Suite para facilitar las pruebas y el rastreo.
Filtrado avanzado: Listas negras y blancas de URL, incluido el filtrado a nivel de dominio.
Compatibilidad con subdominios: Incluye subdominios en rastreos tanto del sitio de destino como de fuentes de terceros.
Modos de depuración y detallado: Activa la depuración y el registro detallado para facilitar la solución de problemas.

Opciones de la línea de comandos

Este es el aspecto de un comando genérico de Gospider:

gospider [flags]

En concreto, las banderas admitidas son:

-s, --sitio: Sitio a rastrear.
-S, --sitios: Lista de sitios a rastrear.
-p, --proxy: URL del proxy.
-o, --output: Carpeta de salida.
-u, --agente-usuario: Agente de usuario a utilizar (por ejemplo, web, mobi, o un user-agent personalizado).
--cookie: Cookie a utilizar (por ejemplo, testA=a; testB=b).
-H, --header: Cabecera(s) a utilizar (se repite la bandera varias veces para múltiples cabeceras).
--cadena burp: Carga cabeceras y cookies de una solicitud HTTP sin procesar de Burp Suite.
--blacklist: Lista negra de URL Regex.
--whitelist: Lista blanca de URL Regex.
--whitelist-domain: Dominio de la lista blanca.
-t, --threads: Número de hilos a ejecutar en paralelo (por defecto: 1).
-c, --concurrent: Máximo de peticiones concurrentes para dominios coincidentes (por defecto: 5).
-d, --depth: Profundidad máxima de recursión para URLs (se establece en 0 para recursión infinita, por defecto: 1).
-k, --delay int: Retraso entre peticiones (en segundos).
-K, --random-delay int: Retraso extra aleatorio antes de realizar peticiones (en segundos).
-m, --timeout int: Tiempo de espera de la solicitud (en segundos, por defecto: 10).
-B, --base: Desactiva todo y sólo utiliza contenido HTML.
--js: Habilita el buscador de enlaces en archivos JavaScript (por defecto: true).
--subs: Incluye subdominios.
--sitemap: Rastrea sitemap.xml.
--robots: Rastrea robots.txt (por defecto: true).
-a, --other-source: Encuentra URLs de fuentes de terceros como Archive.org, CommonCrawl, VirusTotal, AlienVault.
-w, --include-subs: Incluye subdominios rastreados desde fuentes de terceros (por defecto: sólo dominio principal).
-r, --include-other-source: Incluye URLs de terceras fuentes y las rastrea.
--debug: Activa el modo de depuración.
--json: Habilita la salida JSON.
-v, --verbose: Activa la salida verbose.
-l, --length: Muestra la longitud de la URL.
-L, --filter-length: Filtra las URL por longitud.
-R, --raw: Muestra la salida sin procesar.
-q, --quiet: Suprime toda la salida y sólo muestra las URL.
--no-redirect: Desactiva las redirecciones.
--version: Comprueba la versión.
-h, --help: Muestra la ayuda.

Web Crawling con Gospider: Guía paso a paso

En esta sección, aprenderá a utilizar Gospider para rastrear enlaces de un sitio multipágina. En concreto, el sitio de destino será Books to Scrape:

El sitio contiene una lista de productos repartidos en 50 páginas. Cada entrada de producto en estas páginas de listado también tiene su propia página de producto dedicada. Los pasos siguientes le guiarán a través del proceso de utilización de Gospider para recuperar todas esas URL de páginas de productos.

Requisitos previos y configuración del proyecto

Antes de empezar, asegúrate de tener lo siguiente:

Go instalado en tu ordenador: Si aún no has instalado Go, descárgalo de la web oficial y sigue las instrucciones de instalación.
Un IDE Go: Se recomienda Visual Studio Code con la extensión Go.

Para verificar que Go está instalado, ejecute

go version

Si Go está instalado correctamente, debería ver una salida similar a esta (en Windows):

go version go1.24.1 windows/amd64

¡Estupendo! Go está configurado y listo para funcionar.

Crea una nueva carpeta de proyecto y navega hasta ella en el terminal:

mkdir gospider-project  
cd gospider-project

Ahora ya puedes instalar Gospider y utilizarlo para rastrear la web.

Paso 1: Instalar Gospider

Ejecute el siguiente comando go install para compilar e instalar Gospider globalmente:

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

Tras la instalación, compruebe que Gospider está instalado ejecutando:

gospider -h

Esto debería imprimir las instrucciones de uso de Gospider como se indica a continuación:

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

¡Sorprendente! Gospider ha sido instalado, y ahora puede utilizarlo para rastrear uno o más sitios web.

Paso 2: Rastrear las URL de la página de destino

Para rastrear todos los enlaces de la página de destino, ejecute el siguiente comando:

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

Este es un desglose de las banderas Gospider utilizadas:

-s "https://books.toscrape.com/": Especifica la URL de destino.
-o salida: Guarda los resultados del rastreo dentro de la carpeta de salida.
-d 1: Establece la profundidad de rastreo en 1, lo que significa que Gospider sólo detectará URLs en la página actual. En otras palabras, no seguirá las URL encontradas para descubrir enlaces más profundos.

El comando anterior producirá la siguiente estructura:

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

Abra el archivo books_toscrape_com dentro de la carpeta de salida, y verá un resultado similar a éste:

[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

El archivo generado contiene diferentes tipos de enlaces detectados:

[url]: Las páginas/recursos rastreados.
[href]: Todos los enlaces <a href> encontrados en la página.
[javascript]: URLs a archivos JavaScript.
[linkfinder]: Enlaces extraídos incrustados en código JavaScript.

Paso 3: Rastrear todo el sitio web

En el resultado anterior, puede ver que Gospider se detuvo en la primera página de paginación. Detectó el enlace a la segunda página, pero no la visitó.

Puede comprobarlo porque el archivo books_toscrape_com contiene:

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

La etiqueta [href ] indica que se ha encontrado el enlace. Sin embargo, como no hay una entrada [url ] correspondiente con la misma URL, el enlace se encontró pero nunca se visitó.

Si inspecciona la página de destino, verá que la URL anterior corresponde a la segunda página de paginación:

Inspección del elemento "siguiente" en la primera página de paginación

Para rastrear todo el sitio web, es necesario seguir todos los enlaces de paginación. Como se muestra en la imagen anterior, el sitio de destino contiene 50 páginas de productos (observe el texto “Página 1 de 50”). Establezca la profundidad de Gospider en 50 para asegurarse de que llega a todas las páginas.

Dado que esto implicará rastrear un gran número de páginas, también es una buena idea aumentar el nivel de concurrencia (es decir, el número de peticiones simultáneas). Por defecto, Gospider utiliza un nivel de concurrencia de 5, pero aumentarlo a 10 acelerará la ejecución.

El comando final para rastrear todas las páginas de productos es:

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

Esta vez, Gospider tardará más en ejecutarse y producirá miles de URLs. La salida contendrá ahora 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.html

El detalle clave a comprobar en la salida es la presencia de la URL de la última página de paginación:

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

¡Maravilloso! Esto confirma que Gospider ha seguido correctamente todos los enlaces de paginación y ha rastreado todo el catálogo de productos como se pretendía.

Paso nº 4: Obtener sólo la página del producto

En tan sólo unos segundos, Gospider recopiló todas las URL de un sitio entero. Este podría ser el final de este tutorial, pero vayamos un paso más allá.

¿Y si sólo desea extraer las URL de las páginas de productos? Para entender cómo están estructuradas estas URL, inspeccione un elemento de producto en la página de destino:

Inspección de un elemento HTML de producto

A partir de esta inspección, puede observar cómo las URL de las páginas de productos siguen este formato:

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

Para filtrar sólo las páginas de productos de las URL rastreadas sin procesar, puede utilizar un script Go personalizado.

En primer lugar, cree un módulo Go dentro del directorio de su proyecto Gospider:

go mod init crawler

A continuación, cree una carpeta crawler dentro del directorio del proyecto y añádale un archivo crawler.go. A continuación, abra la carpeta del proyecto en su IDE. La estructura de carpetas debería ser la siguiente:

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

El script crawler. go debería:

Ejecute el comando Gospider desde un estado limpio.
Lee todas las URL del archivo de salida.
Filtrar sólo las URL de las páginas de productos utilizando un patrón regex.
Exporte las URL de los productos filtrados a un archivo .txt.

A continuación se muestra el código Go para lograr el 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)
}

El programa Go automatiza el rastreo web utilizando:

os.RemoveAll() para borrar el directorio de salida(output/)-si ya existe-para garantizar un inicio limpio.
exec.Command() y cmd.Run() para construir y ejecutar un proceso de línea de comandos Gospider para rastrear el sitio web de destino.
os.Open() y bufio.NewScanner() para abrir el archivo de salida generado por Gospider(books_toscrape_com) y leerlo línea por línea.
regexp.MustCompile() y FindAllString() para utilizar una regex para extraer las URL de las páginas de productos de cada línea, empleando slices.Contains() para evitar duplicados.
os.Create() y bufio.NewWriter() para escribir las URL de las páginas de productos filtradas en un archivo product_urls.txt. Paso 5: Ejecución del script de rastreo Inicie el script crawler.go con el siguiente comando:

go run crawler/crawler.go

El script registrará lo siguiente en el 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

El script de rastreo de Gospider ha encontrado con éxito 1.000 URL de páginas de productos. Como puede comprobar fácilmente en el sitio de destino, ese es exactamente el número de páginas de productos disponibles:

El contador de productos en el sitio de destino

Esas URL se almacenarán en un archivo product_urls.txt generado en la carpeta de su proyecto. Abra ese archivo y 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.html

¡Enhorabuena! Usted acaba de construir un script Gospider para realizar rastreo web en Go.

[Extra] Añadir la lógica de raspado al rastreador Gospider

El rastreo web suele ser sólo un paso dentro de un proyecto más amplio de web scraping. Obtenga más información sobre la diferencia entre estas dos prácticas leyendo nuestra guía sobre web crawling vs. web scraping.

Para que este tutorial sea más completo, también demostraremos cómo utilizar los enlaces rastreados para el web scraping. El script Go scraping que estamos a punto de construir:

Lea las URL de las páginas de productos del archivo product_urls.txt, que se generó anteriormente utilizando Gospider y lógica personalizada.
Visite cada página de producto y raspe los datos del producto.
Exporte los datos de los productos raspados a un archivo CSV.

Es hora de añadir la lógica del web scraping a su configuración de Gospider.

Paso nº 1: Instalar Colly

La librería utilizada para el web scraping es Colly, un elegante framework de scraper y crawler para Golang. Si no estás familiarizado con su API, echa un vistazo a nuestro tutorial sobre web scraping con Go.

Ejecute el siguiente comando para instalar Colly:

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

A continuación, cree un archivo scraper.go dentro de la carpeta scraper dentro del directorio de su proyecto. La estructura de tu proyecto debería ser la siguiente:

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

Abre scraper.go e importa Colly:

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

        "github.com/gocolly/colly"
)

¡Fantástico! Siga los pasos que se indican a continuación para utilizar Colly para extraer datos de las páginas de productos rastreadas.

Paso nº 2: Leer las URL a raspar

Utilice el código siguiente para recuperar las direcciones URL de las páginas de productos que se van a raspar del archivo filtered_urls.txt, generado por 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 el fragmento anterior funcione, incluya estas importaciones al principio de su archivo:

import (
        "bufio"
        "os"
)

¡Genial! La porción de URLs contendrá todas las URLs de las páginas de productos listas para el scraping.

Paso 3: Implementar la lógica de extracción de datos

Antes de implementar la lógica de extracción de datos, debe comprender la estructura del HTML de la página del producto.

Para ello, visite la página de un producto en su navegador en modo incógnito, para garantizar una nueva sesión. Abra DevTools e inspeccione los elementos de la página, empezando por el nodo HTML de la imagen del producto:

Inspección del elemento de imagen del producto

A continuación, inspeccione la sección de información sobre el producto:

Los elementos de información del producto

De los elementos inspeccionados, puede extraer:

El título del producto de la etiqueta <h1>.
El precio del producto del primer nodo .price_color de la página.
La calificación del producto (estrellas) de la clase .star-rating.
La URL de la imagen del producto del elemento #product_gallery img.

Dados estos atributos, defina el siguiente Go struct para representar los datos raspados:

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

Dado que se extraerán varias páginas de productos, defina una sección para almacenar los productos extraídos:

var products []Product

Para rastrear los datos, comience por inicializar un Colly Collector:

c := colly.NewCollector()

Utilice la llamada de retorno OnHTML() en Colly para definir la lógica de raspado:

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 la estructura else if utilizada para obtener la clasificación por estrellas basada en el atributo class de .star-rating. Además, vea cómo la URL relativa de la imagen se convierte en una URL absoluta utilizando strings.Replace().

Añade la siguiente importación obligatoria:

import (
        "strings"
)

Ahora su Go scraper está configurado para extraer datos de productos como desee.

Paso nº 4: Conectarse a las páginas de destino

Colly es un marco de raspado web basado en retrollamadas con un ciclo de vida de retrollamadas específico. Esto significa que puede definir la lógica de raspado antes de recuperar el HTML, lo que constituye un enfoque inusual pero potente.

Ahora que la lógica de extracción de datos está en su lugar, instruya a Colly para que visite cada página de producto:

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

Nota: El número de URLs se ha limitado a 50 para evitar saturar el sitio web de destino con demasiadas peticiones. En un script de producción, puede eliminar o ajustar esta limitación en función de sus necesidades.

Colly lo hará ahora:

Visite cada URL de la lista.
Aplica la llamada de retorno OnHTML() para extraer los datos del producto.
Almacene los datos extraídos en la sección de productos.

¡Asombroso! Todo lo que queda es exportar los datos a un formato legible como CSV.

Paso 5: Exportar los datos obtenidos

Exporte la porción de productos a un archivo CSV utilizando la siguiente 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})
}

El fragmento anterior crea un archivo products.csv y lo rellena con los datos obtenidos.

No olvide importar el paquete CSV de la biblioteca estándar de Go:

import (
       "encoding/csv"
)

Ya está. Su proyecto de rastreo y scraping Gospider está ahora totalmente implementado.

Paso nº 6: Póngalo todo junto

scraper.go debería contener ahora:

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})
        }
}

Ejecute el raspador con el siguiente comando:

go run scraper/scraper.go

La ejecución puede tardar algún tiempo, así que tenga paciencia. Una vez finalizada, aparecerá un archivo products.csv en la carpeta del proyecto. Ábralo y verá los datos raspados estructurados ordenadamente en un formato tabular:

¡Et voilà! Gospider para gatear + Colly para raspar es un dúo ganador.

Limitaciones del enfoque de Gospider para el rastreo web

Las mayores limitaciones del enfoque de rastreo de Gospider son:

Baneos de IP por hacer demasiadas peticiones.
Tecnologías anti rastreo utilizadas por los sitios web para bloquear los robots rastreadores.

Veamos cómo abordar ambas cuestiones.

Evite las prohibiciones de IP

La consecuencia de demasiadas peticiones desde la misma máquina es que tu dirección IP puede ser baneada por el servidor de destino. Este es un problema común en el rastreo web, especialmente cuando no está bien configurado o planificado éticamente.

Por defecto, Gospider respeta robots.txt para minimizar este riesgo. Sin embargo, no todos los sitios web tienen un archivo robots. txt. Además, incluso cuando lo tienen, puede que no especifique reglas válidas de limitación de velocidad para los rastreadores.

Para limitar las prohibiciones de IP, puede utilizar las opciones --delay, --random-delay, --timeout de Gospider para ralentizar las solicitudes. Sin embargo, encontrar la combinación adecuada puede llevar mucho tiempo y no siempre es eficaz.

Una solución más eficaz es utilizar un proxy rotatorio, que garantiza que cada solicitud de Gospider se originará en una dirección IP diferente. Eso evita que el sitio de destino detecte y bloquee tus intentos de rastreo.

Para utilizar un proxy rotativo con Gospider, pase la URL del proxy con el indicador -p (o --proxy):

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

Si no tiene una URL de proxy rotatorio, ¡obtenga una gratis!

Eludir la tecnología antirrastreo

Incluso con un proxy rotatorio, algunos sitios web implementan estrictas medidas anti-scraping y anti-crawling. Por ejemplo, ejecutando este comando de Gospider contra un sitio web protegido por Cloudflare:

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

El resultado será:

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

Como puede ver, el servidor de destino respondió con un 403 Prohibido. Esto significa que el servidor detectó y bloqueó correctamente la solicitud de Gospider, impidiéndole rastrear cualquier URL de la página.

Para evitar esos bloqueos, necesitas una API de desbloqueo web todo en uno. Ese servicio puede saltarse los sistemas anti-bot y anti-scraping, dándote acceso al HTML desbloqueado de cualquier página web.

Nota: El Web Unlocker de Bright Data no sólo gestiona estos retos, sino que también puede funcionar como proxy. Por lo tanto, una vez configurado, puede utilizarlo como un proxy normal con Gospider utilizando la sintaxis mostrada anteriormente.

Conclusión

En esta entrada del blog, aprendiste lo que es Gospider, lo que ofrece, y cómo usarlo para el rastreo web en Go. También viste cómo combinarlo con Colly para un tutorial completo de rastreo y scraping.

Uno de los mayores retos del web scraping es el riesgo de ser bloqueado, ya sea por prohibiciones de IP o por soluciones anti-scraping. La mejor forma de superar estos problemas es utilizar proxies web o una API de scraping como Web Unlocker.

La integración con Gospider es sólo uno de los muchos escenarios que soportan los productos y servicios de Bright Data. Explore nuestras otras herramientas de raspado web:

API de Web Scraper: Puntos finales dedicados para extraer datos web frescos y estructurados de más de 100 dominios populares.
API SERP: API para manejar toda la gestión de desbloqueo en curso para SERP y extraer una página.
Funciones deraspado: Una interfaz de raspado completa que le permite ejecutar sus raspadores como funciones sin servidor.
Navegador de raspado: Navegador compatible con Puppeteer, Selenium y Playwright con actividades de desbloqueo integradas.

Regístrese ahora en Bright Data y pruebe gratis nuestros servicios proxy y productos de scraping.

Prueba gratuita

Comienza con Google

No se requiere tarjeta de crédito

Cómo realizar rastreo web con Gospider en 2025