Zurück zum Blog
Anleitungen
Mihnea-Octavian ManolacheLast updated on Mar 31, 20268 min read

So verwenden Sie HTTP-Header mit Axios, um eine Erkennung zu vermeiden

So verwenden Sie HTTP-Header mit Axios, um eine Erkennung zu vermeiden

HTTP-Header sind ein wichtiger Bestandteil jeder HTTP-Anfrage oder -Antwort, da sie es dem Client und dem Server ermöglichen, zusätzliche Informationen über die Anfrage auszutauschen. Bei der Entwicklung einer Node.js-Webanwendung ist es wichtig, über einen zuverlässigen und benutzerfreundlichen HTTP-Client zu verfügen, um Anfragen an APIs und andere Server zu stellen.

Insbesondere JavaScript und Node.js bieten eine ganze Reihe von Optionen, wenn es um HTTP-Clients geht. Einer meiner persönlichen Favoriten (und sicherlich einer der fünf besten JavaScript-HTTP-Clients) ist jedoch Axios. Deshalb konzentrieren wir uns heute auf das Setzen von HTTP-Headern mit Axios.

Axios ist eine weit verbreitete JavaScript-Bibliothek, die das Senden von HTTP-Anfragen vereinfacht und besonders nützlich ist, wenn man in einer Node.js-Umgebung mit APIs arbeitet. In diesem Artikel werden wir die verschiedenen Möglichkeiten untersuchen, wie Axios für die Arbeit mit HTTP-Headern genutzt werden kann. Am Ende sollten Sie in der Lage sein, Folgendes zu verstehen:

  • Was ein HTTP-Header ist und wie er funktioniert
  • Warum Axios ein hervorragender HTTP-Client für JavaScript ist
  • Wie man HTTP-Header mit Axios in einer echten Web-App verwendet

Wie die HTTP-Kommunikation funktioniert

Bevor wir uns mit der Definition eines HTTP-Headers befassen, halte ich es für wichtig, zumindest einen Überblick darüber zu haben, wie das HTTP-Protokoll funktioniert. Wie Sie sicherlich bereits wissen, ist das Hypertext Transfer Protocol (HTTP) die Grundlage, auf der das heutige Web aufbaut. Auf einer allgemeinen Ebene ermöglicht es den Austausch von Informationen zwischen einem Server und seinen Clients. Der tatsächliche Ablauf dieses Informationsaustauschs sieht in etwa so aus:

  • Der Client öffnet eine neue TCP-Verbindung
  • Er sendet eine Nachricht an den Server, die als HTTP-Anfrage bezeichnet wird
  • Der Server empfängt und interpretiert die Anfrage
  • Er sendet dann eine Nachricht zurück an den Client, die als HTTP-Antwort bezeichnet wird
  • Der Client liest die Nachricht und setzt die Verbindung fort oder schließt sie

Der wichtige Teil, auf den wir uns heute konzentrieren werden, ist die Nachricht, insbesondere die vom Client gesendete Nachricht. Damit die Kommunikation zwischen Server und Client effizient verläuft, müssen die Nachrichten gemäß dem HTTP-Protokoll formatiert sein. Bei der HTTP-Anfrage setzen sich die Elemente der Nachricht wie folgt zusammen:

Die Methode beschreibt, was wir mit unserer Anfrage ausführen möchten (ob wir Informationen empfangen, senden, aktualisieren möchten usw.)

  • Der Pfad, die URL-Adresse, die wir erreichen wollen
  • Die Version des HTTP-Protokolls, die wir verwenden
  • Die HTTP-Header, die dazu dienen, zusätzliche Informationen und Metadaten zusammen mit unserer Anfrage zu senden
  • Der Body, falls wir eine Methode verwenden, die Informationen an den Server sendet (wie z. B. eine POST-Anfrage)

Was sind HTTP-Header in Axios und wie funktionieren sie?

Einfach ausgedrückt sind HTTP-Header Felder, die zusätzliche Informationen und Metadaten an die Nachricht übergeben. Unter „Nachricht“ verstehen wir wiederum die Anfrage, wenn sie vom Client gesendet wird, und die Antwort, wenn sie vom Server gesendet wird. Somit können sowohl der Server als auch der Client Header übermitteln und empfangen. Nehmen wir zum Beispiel an, Sie möchten eine dauerhafte Verbindung zum Server herstellen. Standardmäßig werden HTTP-Verbindungen nach jeder Anfrage geschlossen. Um dies zu vermeiden, müssen Sie lediglich den `Keep-Alive`-Header übermitteln.

Was HTTP-Header mit Axios betrifft, gibt es eigentlich nichts Besonderes zu beachten. Wie bereits besprochen, ist Axios ein HTTP-Client, und wir haben bereits festgestellt, dass HTTP-Clients Header senden und empfangen können.

Warum Axios ein großartiger HTTP-Client für JavaScript ist

Nachdem wir nun einen Überblick darüber haben, wie HTTP funktioniert, lassen Sie uns über „Clients“ sprechen. JavaScript bietet einige Optionen für die „programmatische Interaktion“ mit einem Server über HTTP. Zu den beliebtesten Optionen gehören `axios`, `node-fetch` und `got`.

In der JavaScript-Community gibt es unterschiedliche Meinungen darüber, welches man verwenden sollte. Natürlich hat jedes Paket viele Vor- und Nachteile, doch ich selbst habe mich nach einem einfachen Geschwindigkeitstest zwischen den dreien für Axios entschieden.

Hier ist das Skript, das ich zum Testen der Geschwindigkeit verwendet habe:

// index.js

import { get_timing, array_sum } from './helpers.js'

import got from 'got'

import axios from 'axios'

const CALLS = 5

const send = async () => {

   const res = {}

  

   let start = process.hrtime()

   await got('https://httpbin.org/')

   const g = get_timing(start)

   res.got = g

   start = process.hrtime()

   await axios.get('https://httpbin.org/')

   const a = get_timing(start)

   res.axios = a

   start = process.hrtime()

   await fetch('https://httpbin.org/')

   const f = get_timing(start)

   res.fetch = f

   return res

}

let test_results = {

   got: [],

   axios: [],

   fetch: []

}

let avg = {}

console.log(`[i] Process started with ${CALLS} iterations.`)

for (let i = 0; i<=CALLS; i++) {

   let r = await send()

   Object.entries(test_results).map(([key, value]) => test_results[key].push(r[key]))

}

Object.entries(test_results).forEach(([key, value]) => {

       console.log(`\n[+] ${key}`)

       console.log(`    [i] Average: ${array_sum(value)/value.length}`)

       console.log(`    [i] Values: ${value}`)

       avg[key] = array_sum(value)/value.length

   }

)

console.log(`\n🚀🚀🚀 WINNER: ${Object.keys(avg).reduce((key, v) => avg[v] < avg[key] ? v : key)}  [${CALLS} calls sent] 🚀🚀🚀`)

Und hier sind die `helper`-Funktionen:

// helpers.js

export const get_timing = (start) => {

   const NS_PER_SEC = 1e9

   const NS_TO_MS = 1e6

   const diff = process.hrtime(start)

   return (diff[0] * NS_PER_SEC + diff[1]) / NS_TO_MS

}

export const array_sum = (array) => {

   return array.reduce((accumulator, value) => {

     return accumulator + value

   }, 0)

}

Ich habe Tests mit 5, 10, 20 und 30 Anfragen durchgeführt, die mit jedem Paket gesendet wurden, jeweils 10 Iterationen, und hier ist die Übersicht über die Ergebnisse:

Mit „Iteration“ beziehe ich mich auf die Anzahl der Skriptausführungen unter Verwendung dieser Bash-Formel, die eine .txt-Datei mit den Ergebnissen jeder Iteration generiert:

~ » for i in {1..10}

do

node got.js > "${i}.txt"

echo "${i} done"

done

Wie Sie sehen werden, wenn Sie sich die detaillierte Ergebnistabelle ansehen, gibt es für jeden Batch unterschiedliche Zeiten, und manchmal ist Axios nicht der Schnellste. Insgesamt erzielte Axios jedoch einen Durchschnitt von 387 Millisekunden und war damit eine halbe Sekunde schneller als seine Konkurrenten. Got und Fetch hatten eine sehr ähnliche Antwortzeit von durchschnittlich etwa 435 Millisekunden. Wenn Geschwindigkeit für Ihr Projekt wichtig ist, ist Axios daher vielleicht der beste HTTP-Client für Sie.

So senden Sie HTTP-Header mit Axios

Ich persönlich finde, dass das Lernen durch Praxis fast sofortige Ergebnisse bringt. Da wir nun sowohl das Wissen als auch die Werkzeuge zum Senden von HTTP-Headern haben, lassen Sie uns mit einem kleinen Projekt beginnen. In diesem Abschnitt richten wir ein neues Node-Projekt ein, installieren Axios und verwenden es, um HTTP-Header an einen Server zu senden.

Das Projekt einrichten

Bevor wir fortfahren, stellen Sie sicher, dass Ihr Rechner über Folgendes verfügt:

Tipp: Du kannst überprüfen, ob Node JS installiert ist, indem du den folgenden Befehl in dein Terminal eingibst:

~ » node -v

v19.3.0

Erstellen wir nun einen neuen Ordner und öffnen ihn in unserer IDE. Wenn Sie einen UNIX-ähnlichen Rechner (Mac oder Linux) verwenden, können Sie programmgesteuert ein neues Verzeichnis über Ihr Terminal erstellen, indem Sie den folgenden Befehl eingeben:

~ » mkdir axios_project && cd axios_project

~ » npm init -y

~ » npm i axios

~ » touch index.js

~ » code .

Diese Befehle bewirken Folgendes:

  • Ein neues Verzeichnis (mit dem Namen „axios_project“) erstellen und dorthin navigieren
  • Ein neues Node.js-Projekt in diesem Verzeichnis initialisieren
  • Installieren von `axios` in Ihrem Projekt
  • Erstellen einer neuen Datei „index.js“
  • Öffnen Sie Ihre IDE für das aktuelle Projekt

Code zum Lernen

Es gibt tatsächlich mehrere Möglichkeiten, HTTP-Header mit Axios zu senden. Du kannst beispielsweise ein Konfigurationsobjekt verwenden, wie hier beschrieben, oder die Instanzmethoden nutzen, die die von dir übergebene Konfiguration automatisch mit der Instanzkonfiguration zusammenführen. Du kannst auch das Objekt `axios.defaults.headers.common` verwenden, um Standard-Header für alle Axios-Anfragen festzulegen.

Beachte außerdem, dass Axios ein Promise-basierter HTTP-Client ist. Das bedeutet, dass wir entweder innerhalb einer asynchronen Funktion darauf warten müssen oder die Antwort auflösen müssen.

Mit diesen beiden Aspekten im Hinterkopf wollen wir nun mit dem eigentlichen Programmieren beginnen. Wir werden in der Datei „index.js“ arbeiten. Der Einfachheit halber fassen wir zunächst noch einmal zusammen, was wir tun müssen:

  • Importiere `axios` in unsere Datei
  • Ein Konfigurationsobjekt definieren, das unsere Header enthält
  • Die Konfiguration an `axios` übergeben, um eine Anfrage zu stellen
  • Die Antwort in unserem Terminal ausgeben

#1: Senden einer GET-Anfrage mithilfe des Konfigurationsobjekts

import axios from "axios"

const config = {

   method: 'GET',

   url: 'https://httpbin.org/headers',

   headers: {

       'HTTP-Axios-Headers': 'This is my custom header.'

   }

}

axios(config)

   .then((response) => {

       console.log(response)

   })

   .catch((err) => {

       console.log(err)

   })

Das Senden von HTTP-Headers mit Axios ist denkbar einfach. Um dieses Skript auszuführen, führen Sie einfach den folgenden Befehl in Ihrem Terminal aus:

~ » node index.js  

{

  status: 200,

  statusText: 'OK',

  headers: ...,

  config: ...,

  request: ...,

  data: {

    headers: {

      'Accept': 'application/json, text/plain, */*',

      'Accept-Encoding': 'gzip, compress, deflate, br',

      'Host': 'httpbin.org',

      'Http-Axios-Headers': 'This is my custom header.',

      'User-Agent': 'axios/1.2.2',

      'X-Amzn-Trace-Id': 'Root=1-63b54d94-7656f02113483dfa036c476c'

    }

  }

}

Die gesamte Antwort ist recht umfangreich und folgt diesem Schema. Was uns jedoch am meisten interessiert, ist der `data`-Teil, der die eigentliche Antwort enthält, die wir vom Server erhalten haben. Sehen Sie sich nun die obige Antwort an. Denken Sie daran, dass wir einen benutzerdefinierten Header `Http-Axios-Headers` an den Server gesendet haben, und wie Sie sehen können, hat der Server diesen auch empfangen.

#2: Senden einer POST-Anfrage mithilfe des Methoden-Alias

import axios from "axios"

const data = {

   'foo':'bar'

}

const config = {

   headers: {

       'HTTP-Axios-Headers': 'This is my custom header.'

   }

}

axios.post('http://httpbin.org/post', data, config)

   .then(response => console.log(response.data))

   .catch(err => console.log(err))

Beachten Sie, dass ich, um eine POST-Anfrage zu senden, ein neues `data`-Objekt zu unserem Skript hinzugefügt und auch die URL geändert habe. Wenn Sie nun das Skript ausführen, werden Sie feststellen, dass dies die vom Server empfangenen Daten sind:

{

  args: {},

  data: '{"foo":"bar"}',

  files: {},

  form: {},

  headers: {

    Accept: 'application/json, text/plain, */*',

    'Accept-Encoding': 'gzip, compress, deflate, br',

    'Content-Length': '13',

    'Content-Type': 'application/json',

    Host: 'httpbin.org',

    'Http-Axios-Headers': 'This is my custom header.',

    'User-Agent': 'axios/1.2.2',

    'X-Amzn-Trace-Id': 'Root=1-63b5508a-3a86493f087662d3169e80ee'

  },

  json: { foo: 'bar' },

  origin: '49.12.221.20',

  url: 'http://httpbin.org/post'

}

Verwendung von HTTP-Headern in Axios für das Web-Scraping

Wenn Sie vorhaben, Axios für das Web-Scraping zu verwenden, beachten Sie bitte, dass die meisten Websites Schutzregeln haben, die Anfragen von automatisierter Software (einschließlich Web-Scrapern) blockieren.

Die Verwendung von HTTP-Headern, insbesondere des `User-Agent`-Headers, kann eine nützliche Technik sein, um beim Web-Scraping nicht erkannt zu werden. Der User-Agent-Header identifiziert den Client-Browser und das Betriebssystem gegenüber dem Server, und Webserver können auf Grundlage dieser Informationen unterschiedliche Inhalte bereitstellen oder Anfragen blockieren. Durch das Setzen des User-Agent-Headers können Sie einen gängigen Webbrowser imitieren und so Ihre Chancen erhöhen, einige Erkennungsmechanismen zu umgehen.

Hier ist ein Beispiel dafür, wie man den User-Agent-Header mit Axios verwendet, um beim Web-Scraping nicht erkannt zu werden:

import axios from "axios"

axios.defaults.headers.common['User-Agent'] = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'

axios({

   method: 'GET',

   url: 'https://httpbin.org/get',

}).then(response => {

   console.log(response.data)

});

Beachten Sie, dass ich diesmal die Option „config defaults“ von Axios verwendet habe, die den Header auf alle folgenden Anfragen anwendet. In diesem Beispiel ist der User-Agent-Header so gesetzt, dass er den Chrome-Browser auf einem Windows-10-Betriebssystem imitiert. Sie können versuchen, verschiedene User-Agent-Werte oder eine Vielzahl unterschiedlicher Header zu verwenden, um herauszufinden, was für Ihren spezifischen Anwendungsfall am besten funktioniert.

Es ist anzumerken, dass das Ändern des User-Agent-Headers zwar in manchen Fällen helfen kann, eine Erkennung zu vermeiden, dies jedoch keine narrensichere Methode ist und Webserver möglicherweise dennoch erkennen können, dass Sie einen Web-Scraper verwenden. Daher ist es ratsam, eine Kombination verschiedener Techniken zu nutzen, um eine Erkennung zu vermeiden und die Nutzungsbedingungen der Website einzuhalten.

Fazit

Die Verwendung von HTTP-Headern mit Axios (oder jedem anderen HTTP-Client) kann die Effizienz der Kommunikation zwischen Server und Client steigern. Darüber hinaus kann sie Ihnen sogar helfen, eine Erkennung zu vermeiden, wenn Sie einen Web-Scraper erstellen. Tatsächlich verwenden wir bei WebScrapingAPI verschiedene User-Agents als eine der grundlegenden Umgehungstechniken.

Natürlich beschränkt sich die Erkennung nicht nur auf User-Agents, aber sie ist ein guter Ausgangspunkt. Hier finden Sie ein nützliches Tutorial dazu, wie Sie beim Web-Scraping verhindern können, dass Ihre IP-Adresse gesperrt wird – es hilft Ihnen dabei, besser zu verstehen, wie Umgehungstechniken funktionieren.

Wussten Sie übrigens, dass Sie mit der Web Scraping API benutzerdefinierte Header für Ihre Anfrage festlegen können? Falls nicht, erfahren Sie hier mehr darüber.

Über den Autor
Mihnea-Octavian Manolache, Full-Stack-Entwickler @ WebScrapingAPI
Mihnea-Octavian ManolacheFull-Stack-Entwickler

Mihnea-Octavian Manolache ist Full-Stack- und DevOps-Entwickler bei WebScrapingAPI. Er entwickelt Produktfunktionen und sorgt für die Wartung der Infrastruktur, die den reibungslosen Betrieb der Plattform gewährleistet.

Los geht’s

Sind Sie bereit, Ihre Datenerfassung zu erweitern?

Schließen Sie sich den über 2.000 Unternehmen an, die WebScrapingAPI nutzen, um Webdaten im Unternehmensmaßstab ohne zusätzlichen Infrastrukturaufwand zu extrahieren.