Gepostet inWeb-Scraping

Wie man mit Golang 2025 Daten aus dem Web scrapen kann

Keine Kommentare
Daten aus dem Web mit go scrapen

Web Scraping ist eine leistungsstarke Technik, um Daten aus Websites zu extrahieren, und Golang (Go) ist eine ausgezeichnete Sprache für diese Aufgabe. Go ist für seine Leistung und Effizienz bekannt und kann Web Scraping mit Leichtigkeit bewältigen. Wie kann man also mit Golang Daten aus dem Web scrapen? Dieser Leitfaden führt Sie durch den Prozess des Scrappings von Webseiten mit Golang und behandelt die dazugehörigen Techniken und Tipps.

Inhalt ausblenden
I Ist Golang gut für Scraping Daten aus dem Web?
II Grundlegende Konfiguration zum Scrapen von Webdaten mit Golang
II.I Einrichten der Umgebung
II.II Erforderliche Pakete installieren
II.III Den Scraper schreiben
II.IV Betrieb des Abstreifers
II.V Zusätzliche Überlegungen
III Fortgeschrittene Techniken zum Scrapen von Webdaten mit Golang
III.I Handhabung der Paginierung
III.II Umgang mit JavaScript-gerendertem Inhalt
III.III Verwaltung von Sitzungen und Cookies
III.IV Drosselung und Ratenbegrenzung
III.V Handhabung von AJAX-Anfragen
III.VI Umgang mit Captchas und Anti-Scraping-Mechanismen
III.VII Verwendung von Proxies
III.VIII Gleichzeitiges Scraping
III.IX Scraping von Daten aus APIs
III.X Speichern von Daten
III.XI Fehlerbehandlung und Protokollierung
IV Wesentliche Bibliotheken für Web Scraping in Golang
V Zusammenfassung

Ist Golang gut für Scraping Daten aus dem Web?

Bevor man mehr über das Scraping von Daten aus dem Web mit Golang erfährt, ist es wichtig zu verstehen, warum man Golang für das Web Scraping wählt und welche Vorteile es bietettages.

Golang ist aufgrund seiner hohen Leistung, seines effizienten Gleichzeitigkeitsmodells und seiner robusten Standardbibliothek eine gute Wahl für Web Scraping. Mit seiner Fähigkeit, mehrere Anfragen gleichzeitig mit Hilfe von Goroutinen zu verarbeiten, und seinen eingebauten Paketen für HTTP-Anfragen und HTML-Parsing kann Go effizient große Datenmengen scrapen. Seine Einfachheit und seine Fähigkeiten zur Fehlerbehandlung rationalisieren den Entwicklungsprozess weiter, während Bibliotheken von Drittanbietern wie Colly und Goquery zusätzliche Funktionen bieten. Obwohl Go für Web Scraping weniger verbreitet ist als Python, ist es aufgrund seiner Vorteile eine überzeugende Option für diejenigen, die mit der Sprache vertraut sind.

Grundlegende Konfiguration zum Scrapen von Webdaten mit Golang

Beim Scraping von Daten aus dem Web mit Go (Golang) werden HTTP-Anfragen gestellt, um Webseiten abzurufen, und dann der HTML-Inhalt geparst, um die gewünschten Informationen zu extrahieren. Im Folgenden finden Sie eine Schritt-für-Schritt-Anleitung zum Scraping von Daten aus dem Web mit Go:

    1. Einrichten der Umgebung

      Stellen Sie zunächst sicher, dass Go auf Ihrem System installiert ist. Weder Leute können es von der offizielle Website.

      golang

    2. Erforderliche Pakete installieren

      Es werden einige Pakete benötigt, die bei HTTP-Anfragen und HTML-Parsing helfen. Die beliebtesten Pakete sind net/http für HTTP-Anfragen und goquery für das Parsen von HTML.

      Holen Sie sich ein bestimmtes Paket, indem Sie wie folgt vorgehen:

      go get github.com/PuerkitoBio/goquery

      Den Scraper schreiben

      Hier ist ein einfaches Beispiel, wie man mit Golang Daten von einer Website auslesen kann:

      Paket Haupt

importieren (
    "fmt"
    "log"
    "net/http"

    "github.com/PuerkitoBio/goquery"
)

func main() {
    // URL der abzufragenden Website
    url := "https://example.com"

    // HTTP-GET-Anfrage stellen
    res, err := http.Get(url)
    if err != nil {
        log.Fatal(err)
    }
    defer res.Body.Close()

    // Prüfen Sie den Statuscode der Antwort
    if res.StatusCode != 200 {
        log.Fatalf("Daten konnten nicht geholt werden: %d %s", res.StatusCode, res.Status)
    }

    // Parsen des HTML
    doc, err := goquery.NewDocumentFromReader(res.Body)
    if err != nil {
        log.Fatal(err)
    }

    // Suchen und Drucken der Daten
    doc.Find("h1").Each(func(index int, item *goquery.Selection) {
        Überschrift := item.Text()
        fmt.Println(Überschrift)
    })
}

      HTTP-Anfragen stellen:

      http.Get(url) stellt eine HTTP-GET-Anfrage an die angegebene URL.
      res.Body.Close() sorgt dafür, dass der Antwortkörper nach dem Lesen geschlossen wird.

      Parsing von HTML:

      goquery.NewDocumentFromReader(res.Body) parst die HTML-Antwort und gibt ein goquery.Document-Objekt zurück.

      Daten extrahieren:

      doc.Find("h1").Each() findet alle h1-Elemente in der HTML-Datei und durchläuft sie.
      item.Text() extrahiert den Textinhalt der einzelnen h1-Elemente.

    3. Betrieb des Abstreifers

      Speichern Sie den obigen Code in einer Datei, z. B. main.go, und führen Sie ihn mit aus:

      go main.go ausführen

Zusätzliche Überlegungen

Umgang mit Fehlern: Behandeln Sie Fehler immer angemessen, um sicherzustellen, dass Ihr Scraper nicht unerwartet abstürzt.

Respektieren Sie robots.txt: Überprüfen Sie die robots.txt-Datei der Website, um sicherzustellen, dass Sie die Website scrapen dürfen.

Ratenbegrenzung: Implementieren Sie eine Ratenbegrenzung, um den Server nicht mit Anfragen zu überlasten.

Benutzer-Agent: Legen Sie einen benutzerdefinierten User-Agent-Header fest, um Ihren Scraper zu identifizieren, z. B.:

req, err := http.NewRequest("GET", url, nil)
if err != nil {
    log.Fatal(err)
}
req.Header.Set("User-Agent", "Golang_Scraper/1.0")

client := &http.Client{}
res, err := client.Do(req)
if err != nil {
    log.Fatal(err)
}
defer res.Body.Close()

// Parsen Sie das HTML wie zuvor

Fortgeschrittene Techniken zum Scrapen von Webdaten mit Golang

Handhabung der Paginierung

Viele Websites verwenden Paginierung, um den Inhalt auf mehrere Seiten aufzuteilen. Um alle Daten abzurufen, müssen Sie die Paginierung handhaben, indem Sie die einzelnen Seiten nacheinander anfragen.

Hier ist ein Beispiel für die Handhabung der Paginierung:

Paket Haupt

importieren (
    "fmt"
    "log"
    "net/http"
    "strconv"

    "github.com/PuerkitoBio/goquery"
)

func main() {
    baseURL := "https://example.com/page/"
    Seite := 1

    for {
        url := baseURL + strconv.Itoa(Seite)
        res, err := http.Get(url)
        if err != nil {
            log.Fatal(err)
        }
        defer res.Body.Close()

        if res.StatusCode != 200 {
            log.Println("Keine weiteren Seiten zu holen, Abbruch.")
            break
        }

        doc, err := goquery.NewDocumentFromReader(res.Body)
        if err != nil {
            log.Fatal(err)
        }

        doc.Find(".item").Each(func(index int, item *goquery.Selection) {
            title := item.Find(".title").Text()
            fmt.Println(title)
        })

        Seite++
    }
}

Umgang mit JavaScript-gerendertem Inhalt

Einige Websites verwenden JavaScript, um Inhalte dynamisch darzustellen. Go hat keine eingebaute Möglichkeit, JavaScript auszuführen, aber Sie können eine kopfloser Browser wie Chromedp.

go get -u github.com/chromedp/chromedp

Beispiel für die Verwendung von Chromedp zum Scrapen von JavaScript-gerenderten Inhalten:

Paket Haupt

importieren (
    "kontext"
    "fmt"
    "log"

    "github.com/chromedp/chromedp"
)

func main() {
    ctx, cancel := chromedp.NewContext(context.Background())
    cancel() aufschieben

    var htmlInhalt string

    err := chromedp.Run(ctx,
        chromedp.Navigate("https://example.com"),
        chromedp.OuterHTML("body", &htmlContent),
    )
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println(htmlContent)
}

Verwaltung von Sitzungen und Cookies

Wenn eine Website eine Anmeldung oder Sitzungsverwaltung erfordert, können Sie Cookies und Sitzungen mit dem http.CookieJar.

Beispiel für die Verwaltung von Cookies:

Paket Haupt

importieren (
    "fmt"
    "log"
    "net/http"
    "net/http/cookiejar"

    "github.com/PuerkitoBio/goquery"
)

func main() {
    jar, _ := cookiejar.New(nil)
    client := &http.Client{Jar: jar}

    // Einloggen und Cookies speichern
    loginURL := "https://example.com/login"
    loginForm := url.Values{}
    loginForm.Set("benutzername", "ihr_benutzername")
    loginForm.Set("passwort", "ihr_passwort")

    res, err := client.PostForm(loginURL, loginForm)
    if err != nil {
        log.Fatal(err)
    }
    res.Body.Close()

    // Zugriff auf eine geschützte Seite
    url := "https://example.com/protected-page"
    res, err = client.Get(url)
    if err != nil {
        log.Fatal(err)
    }
    defer res.Body.Close()

    doc, err := goquery.NewDocumentFromReader(res.Body)
    if err != nil {
        log.Fatal(err)
    }

    doc.Find(".protected-content").Each(func(index int, item *goquery.Selection) {
        Inhalt := Element.Text()
        fmt.Println(content)
    })
}

Drosselung und Ratenbegrenzung

Um zu vermeiden, dass Websites die Datenübertragung blockieren, sollten Sie eine Ratenbeschränkung einführen, indem Sie Verzögerungen zwischen den Anfragen einführen.

Beispiel für Ratenbegrenzung:

Paket Haupt

importieren (
    "fmt"
    "log"
    "net/http"
    "time"

    "github.com/PuerkitoBio/goquery"
)

func main() {
    urls := []string{"https://example.com/page1", "https://example.com/page2"}

    for _, url := range urls {
        res, err := http.Get(url)
        if err != nil {
            log.Fatal(err)
        }
        defer res.Body.Close()

        doc, err := goquery.NewDocumentFromReader(res.Body)
        if err != nil {
            log.Fatal(err)
        }

        doc.Find(".item").Each(func(index int, item *goquery.Selection) {
            title := item.Find(".title").Text()
            fmt.Println(title)
        })

        // Verzögern, um eine Blockierung zu vermeiden
        time.Sleep(2 * time.Second)
    }
}

Handhabung von AJAX-Anfragen

Einige Websites laden Daten dynamisch über AJAX-Anfragen. Sie können diese Anfragen mit Tools wie den Browser-Entwickler-Tools erfassen und replizieren, um die API-Endpunkte zu finden.

Beispiel für den Abruf von Daten von einem AJAX-API-Endpunkt:

Paket Haupt

import (
    "kodierung/json"
    "fmt"
    "log"
    "net/http"
)

Typ Item struct {
    Titel string `json: "title"`
}

func main() {
    url := "https://example.com/api/items"

    res, err := http.Get(url)
    if err != nil {
        log.Fatal(err)
    }
    defer res.Body.Close()

    var items []Item
    if err := json.NewDecoder(res.Body).Decode(&items); err != nil {
        log.Fatal(err)
    }

    for _, item := range items {
        fmt.Println(item.Title)
    }
}

Umgang mit Captchas und Anti-Scraping-Mechanismen

Websites verwenden häufig CAPTCHAs und andere Anti-Scraping-Mechanismen. Während das programmatische Lösen von CAPTCHAs komplex ist und oft gegen die Nutzungsbedingungen verstößt, können Sie Techniken wie rotierende Benutzer-Agenten und Proxys verwenden, um eine Entdeckung zu vermeiden.

Beispiel für rotierende Benutzeragenten:

Paket Haupt

importieren (
    "fmt"
    "log"
    "net/http"
    "math/rand"
    "time"
)

func main() {
    userAgents := []string{
        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, wie Gecko) Chrome/58.0.3029.110 Safari/537.3",
        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.11; rv:54.0) Gecko/20100101 Firefox/54.0",
        // Fügen Sie hier weitere Benutzeragenten hinzu
    }

    client := &http.Client{}
    rand.Seed(time.Now().UnixNano())

    for i := 0; i < 5; i++ {
        req, err := http.NewRequest("GET", "https://example.com", nil)
        if err != nil {
            log.Fatal(err)
        }

        req.Header.Set("User-Agent", userAgents[rand.Intn(len(userAgents))])
        res, err := client.Do(req)
        if err != nil {
            log.Fatal(err)
        }
        res.Body.Close()

        fmt.Println("Anfrage gesendet mit User-Agent:", req.Header.Get("User-Agent"))
    }
}

Verwendung von Proxies

Um Ihre IP-Adresse weiter zu schützen, können Sie Proxys verwenden. Dienste wie OkeyProxy oder MacroProxy bieten Proxy-Lösungen an.

Als einer der besten Proxy-Anbieter, OkeyProxy wird von HTTP/HTTPS/SOCKS unterstützt und bietet mehr als 150 Millionen echte private IPs, die mehr als 200 Länder/Gebiete abdecken. IP-Sperre vermeiden und gewährleistet die Sicherheit, Zuverlässigkeit und Stabilität der Netzverbindungen.

okeyproxy

Beispiel für die Verwendung eines Proxy für Daten-Scraping mit http.Client:

Paket Haupt

importieren (
    "fmt"
    "log"
    "net/http"
    "net/url"
)

func main() {
    proxyURL, _ := url.Parse("http://proxyusername:proxypassword@proxyserver:port")
    transport := &http.Transport{
        Proxy: http.ProxyURL(proxyURL),
    }

    client := &http.Client{Transport: transport}

    res, err := client.Get("https://example.com")
    if err != nil {
        log.Fatal(err)
    }
    res.Body.Close() aufschieben

    fmt.Println("Antwortstatus:", res.Status)
}

Gleichzeitiges Scraping

Um das Scraping zu beschleunigen, können Sie Goroutines verwenden, um mehrere Anfragen gleichzeitig zu bearbeiten. Dies ist nützlich für das Scrapen großer Datensätze.

Beispiel für gleichzeitiges Scraping mit Goroutines:

Paket Haupt

importieren (
    "fmt"
    "log"
    "net/http"
    "sync"

    "github.com/PuerkitoBio/goquery"
)

func scrape(url string, wg *sync.WaitGroup) {
    wg.Done() aufschieben

    res, err := http.Get(url)
    if err != nil {
        log.Println(err)
        return
    }
    defer res.Body.Close()

    doc, err := goquery.NewDocumentFromReader(res.Body)
    if err != nil {
        log.Println(err)
        return
    }

    doc.Find(".item").Each(func(index int, item *goquery.Selection) {
        title := item.Find(".title").Text()
        fmt.Println(title)
    })
}

func main() {
    urls := []string{
        "https://example.com/page1",
        "https://example.com/page2",
        // Weitere URLs hinzufügen
    }

    var wg sync.WaitGroup

    for _, url := Bereich urls {
        wg.Add(1)
        go scrape(url, &wg)
    }

    wg.Wait()
}

Scraping von Daten aus APIs

Viele Websites bieten APIs für den Zugriff auf Daten an. Die Verwendung von APIs ist oft einfacher und effizienter als das Scrapen von HTML.

Beispiel für den Aufruf einer API:

Paket Haupt

import (
    "kodierung/json"
    "fmt"
    "log"
    "net/http"
)

func main() {
    url := "https://api.example.com/data"

    res, err := http.Get(url)
    if err != nil {
        log.Fatal(err)
    }
    defer res.Body.Close()

    var data map[string]interface{}
    if err := json.NewDecoder(res.Body).Decode(&data); err != nil {
        log.Fatal(err)
    }

    fmt.Println("API-Daten:", data)
}

Speichern von Daten

Je nach Ihren Anforderungen müssen Sie die gesammelten Daten in einer Datenbank oder einer Datei speichern. Hier ist ein Beispiel für das Schreiben von Daten in eine CSV-Datei:

Paket Haupt

importieren (
    "kodierung/csv"
    "fmt"
    "log"
    "os"
    "net/http"
    "github.com/PuerkitoBio/goquery"
)

func main() {
    Datei, err := os.Create("Daten.csv")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    writer := csv.NewWriter(file)
    defer writer.Flush()

    urls := []string{"https://example.com/page1", "https://example.com/page2"}

    for _, url := range urls {
        res, err := http.Get(url)
        if err != nil {
            log.Fatal(err)
        }
        defer res.Body.Close()

        doc, err := goquery.NewDocumentFromReader(res.Body)
        if err != nil {
            log.Fatal(err)
        }

        doc.Find(".item").Each(func(index int, item *goquery.Selection) {
            title := item.Find(".title").Text()
            writer.Write([]string{title})
        })
    }

    fmt.Println("Daten geschrieben in data.csv")
}

Fehlerbehandlung und Protokollierung

Robuste Fehlerbehandlung und Protokollierung sind für die Fehlersuche und Wartung von Scrapern unerlässlich. Sie können die Protokollierungsfunktionen von Go oder externe Bibliotheken wie logrus für erweiterte Protokollierung verwenden.

Wesentliche Bibliotheken für Web Scraping in Golang

  1. CollyInstallation: go get -u github.com/gocolly/colly Leistungsstarkes und einfach zu bedienendes Web Scraping Framework.
  2. Goquery:jQuery-ähnliche Bibliothek zur Manipulation und Abfrage von HTML.Installation: go get -u github.com/PuerkitoBio/goquery
  3. AnfrageVereinfachter HTTP-Client zum Stellen von Anfragen.Installation: go get -u github.com/imroc/req
  4. Grequests:Bibliothek für HTTP-Anfragen auf höherer Ebene, ähnlich der Requests-Bibliothek von Python.Installation: go get -u github.com/levigross/grequests
  5. Verchromt:Browser-Automatisierung mit Chrome DevTools Protocol.Installation: go get -u github.com/chromedp/chromedp
  6. StabModerne Browser-Automatisierungsbibliothek für Go, mit Schwerpunkt auf Benutzerfreundlichkeit und modernen Funktionen.Installation: go get -u github.com/ysmood/rod
  7. Go-SeleniumEin Selenium WebDriver-Client für Go, nützlich für die Automatisierung von Browsern Installation: go get -u github.com/tebeka/selenium
  8. ScollyEin Wrapper um Colly für vereinfachtes Web-Scraping.Installation: go get -u github.com/scolly/scolly
  9. BrowshotEin Go-Client für die Browshot-API, um Screenshots zu machen und Inhalte von Webseiten zu scrapen.Installation: go get -u github.com/browshot/browshot-go
  10. Puppenspieler-goEine Go-Portierung von Puppeteer, einer Node-Bibliothek zur Steuerung von Chrome ohne Kopfhörer Installation: go get -u github.com/chromedp/puppeteer-go
  11. Go-AnfragenEinfache HTTP-Anfrage-Bibliothek, inspiriert von Pythons Requests.Installation: go get -u github.com/deckarep/golang-set
  12. HttpproxyEin einfacher HTTP-Proxy-Server für Go, nützlich für die Weiterleitung von Web-Scraping-Datenverkehr.Installation: go get -u github.com/henrylee2cn/httpproxy
  13. KrabbelndInstallation: go get -u github.com/whyrusleeping/crawling - eine Bibliothek zum Aufbau verteilter Webcrawler
  14. K6Obwohl K6 in erster Linie ein Lasttest-Tool ist, kann es mit seinen Skripting-Fähigkeiten auch zum Scraping von Webdaten verwendet werden.
  15. Netz/httpDie Standardbibliothek für HTTP-Anfragen in Go.Installation: Eingebaut in Go, keine separate Installation erforderlich.
  16. Goquery-htmlEine weitere HTML-Parsing-Bibliothek mit Goquery-basierten Erweiterungen Installation: go get -u github.com/PuerkitoBio/goquery-html
  17. HttpclientEin High-Level-HTTP-Client für Go, der fortgeschrittene Anfrage-Funktionen bietet.Installation: go get -u github.com/aymerick/raymond

Diese Bibliotheken und Tools decken eine Reihe von Funktionen ab, von einfachen HTTP-Anfragen bis hin zur vollständigen Browser-Automatisierung, was sie vielseitig für unterschiedliche Web-Scraping-Anforderungen macht.

Zusammenfassung

Das Scraping von Daten aus dem Web mit Golang bietet mehrere Vorteile, darunter Leistungseffizienz und einfache Gleichzeitigkeit. Die leichtgewichtigen Goroutinen und Channels von Go ermöglichen die Verarbeitung mehrerer gleichzeitiger Anfragen mit minimalem Ressourcen-Overhead, was es ideal für umfangreiche Datenextraktionsaufgaben macht. Darüber hinaus unterstützt die starke Standardbibliothek von Go robuste HTTP- und HTML-Parsing-Funktionen, die die Entwicklung effizienter und zuverlässiger Web-Scraping-Anwendungen vereinfachen. Diese Kombination aus Geschwindigkeit, Gleichzeitigkeit und integrierten Tools macht Golang zu einer überzeugenden Wahl für Web-Scraping-Projekte, die hohe Leistung und Skalierbarkeit erfordern.

Tags:

Kommentare

Noch keine Kommentare. Warum fangen Sie nicht mit der Diskussion an?

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert